US2025131178A1PendingUtilityA1
Method for Optimizing Placement Process of Surface Mounters Based on Heuristic Adaptive Tabu Search
Est. expiryOct 23, 2043(~17.2 yrs left)· nominal 20-yr term from priority
H10P 72/0446G06F 30/392G06F 30/398G06F 2115/12G06N 5/01H01L 21/67144
54
PatentIndex Score
0
Cited by
0
References
0
Claims
Abstract
A method for optimizing the placement process of a surface mounter using a heuristic adaptive tabu search is presented, relevant to surface-mount technology. The method includes encoding and decoding heuristic adaptive information link, where encoded information cover component allocation sequence, head sequence, heuristic algorithm selection, and pick-and-place path optimization sequence. The decoded results configure the component allocation algorithm and pick-and-place path optimization algorithm, and the optimized placement process is derived using these configured algorithms. The component allocation algorithm includes both the available feeder-oriented heuristic algorithm and the assigned feeder group-oriented heuristic algorithm, suitable for different feeder scenarios. Optimizing the selection of these algorithms achieves adaptive optimization for various production scenarios. The tabu search algorithm conducts neighborhood search operations on the adaptive information link, addressing component allocation and pick-and-place path optimization simultaneously. This approach synergistically optimizes the number of equivalent pick-up operations and pick-and-place path length, significantly enhancing production efficiency.
Claims
exact text as granted — not AI-modifiedWhat is claimed is:
1 . A method for optimizing the placement process of surface mounters based on heuristic adaptive tabu search, comprising:
invoking a heuristic adaptive information link encoding algorithm to encode a component allocation problem and a pick-and-place path optimization problem to obtain encoded information that comprises a sequence of component allocation of nozzle rows, a head sequence in a component allocation result, a selected component allocation heuristic algorithm, and a sequence of pick-and-place path optimization of sub-cycles; invoking a heuristic adaptive information link decoding algorithm to decode the encoded information, configuring the component allocation heuristic algorithm and a pick-and-place path optimization heuristic algorithm according to a decoding result, and obtaining a placement process optimization result using the configured heuristic algorithms, the component allocation heuristic algorithm being an available feeder-oriented heuristic algorithm or an assigned feeder group-oriented heuristic algorithm, and the available feeder-oriented heuristic algorithm and the assigned feeder group-oriented heuristic algorithm providing a best optimization result respectively in a production scenario where the number of feeders is sufficient and a production scenario where the number of feeders is limited; and determining whether a current number of unimproved searches is less than an unimproved tabu search upper limit; if so, performing a neighbor search operation on a heuristic adaptive information link to obtain a current heuristic adaptive information link, invoking the heuristic adaptive information link decoding algorithm to decode a current heuristic adaptive information link to obtain a corresponding placement process optimization result as a candidate solution, updating a current solution according to the candidate solution and a tabu list, updating the tabu list, and determining whether the current number of unimproved searches is less than the unimproved tabu search upper limit again; if not, outputting a current placement process optimal result obtained by searching; and performing SMT production, by a surface mounter, according to a component allocation result, a placement point allocation result, a placement sorting result, and a pickup slot allocation result FA and a pickup sorting result FP in each sub-cycle output by the algorithm.
2 . The method for optimizing the placement process of surface mounters based on heuristic adaptive tabu search according to claim 1 , wherein a specific process of invoking a heuristic adaptive information link encoding algorithm to encode a component allocation problem and a pick-and-place path optimization problem to obtain encoded information that comprises a sequence of component allocation of nozzle rows, a head sequence in a component allocation result, a selected component allocation heuristic algorithm, and a sequence of pick-and-place path optimization of sub-cycles comprises:
Step 1 , acquiring parameters of the surface mounter and PCB production data; Step 2 , obtaining a nozzle assignment result based on a nozzle assignment heuristic algorithm; and Step 3 , initializing a heuristic adaptive information link; a specific process of invoking a heuristic adaptive information link decoding algorithm to decode the encoded information, configuring the component allocation heuristic algorithm and a pick-and-place path optimization heuristic algorithm according to a decoding result, and obtaining a placement process optimization result using the configured heuristic algorithms, the component allocation heuristic algorithm being an available feeder-oriented heuristic algorithm or an assigned feeder group-oriented heuristic algorithm, and the available feeder-oriented heuristic algorithm and the assigned feeder group-oriented heuristic algorithm providing a best optimization result respectively in a production scenario where the number of feeders is sufficient and a production scenario where the number of feeders is limited comprises:
Step 4 , decoding a component allocation information link CpAlink;
executing a component allocation algorithm according to a component allocation information link decoding result to complete component allocation to obtain a component allocation result Cpg; performing path optimization in all pick-and-place cycles according to PAPlink, and updating a pick-and-place path optimization result; calculating a corresponding total PCB assembly time TotalCost according to the nozzle assignment result, the component allocation result, and the pick-and-place path optimization result; and initializing an optimal total assembly time TotalCostbest=TotalCost, and then outputting a placement process optimal result; wherein, in the production scenario where the number of feeders is sufficient, the number of feeders corresponding to each type of components is greater than the number of heads corresponding to said type of components; in the production scenario where the number of feeders is limited, there is only one available feeder for each type of components; a specific process of determining whether a current number of unimproved searches is less than an unimproved tabu search upper limit; if so, performing a neighbor search operation on a heuristic adaptive information link to obtain a current heuristic adaptive information link, invoking the heuristic adaptive information link decoding algorithm to decode a current heuristic adaptive information link to obtain a corresponding placement process optimization result as a candidate solution, updating a current solution according to the candidate solution and a tabu list, updating the tabu list, and determining whether the current number of unimproved searches is less than the unimproved tabu search upper limit again; if not, outputting a current placement process optimal result obtained by searching; and performing SMT production, by a surface mounter, according to a component allocation result, a placement point allocation result, a placement sorting result, and a pickup slot allocation result FA and a pickup sorting result FP in each sub-cycle output by the algorithm comprises: Step 5 , initializing tabu search parameters, initializing the tabu list, and determining a tabu length and the unimproved tabu search upper limit; Step 6 , determining whether a current number of unimproved tabu searches is less than the unimproved tabu search upper limit; if so, performing Step 7 ; otherwise, performing Step 9 ; Step 7 , performing a neighbor search operation on the heuristic adaptive information link to obtain the current heuristic adaptive information link, invoking the heuristic adaptive information link decoding algorithm to decode the current heuristic adaptive information link to obtain the corresponding placement process optimization result as the candidate solution, and performing Step 8 ; Step 8 , updating the current solution according to the candidate solution and the tabu list, updating the tabu list, and returning to Step 6 ; and Step 9 , outputting the current placement process optimal result obtained by searching, which specifically comprises: performing SMT production by the surface mounter according to the component allocation result Cpg, the placement point allocation result PA, the placement sorting result PS, and the pickup slot allocation result FA and the pickup sequence result FP in each sub-cycle output by the algorithm.
3 . The method for optimizing the placement process of surface mounters based on heuristic adaptive tabu search according to claim 2 , wherein the parameters of the surface mounter and the PCB production data are acquired specifically as follows:
components with a same component type name are a same type of components, types of components in a data file of a PCB to be assembled are counted to obtain a total number C of the types of components, the types of components are numbered as c∈{1,2, . . . ,C} according to an sequence in which the types of components appear in the data file of the PCB, the numbers of the types of components are called component numbers, and the number of placement points corresponding to one type of components is called the number of placement points corresponding to the component number; the number of placement points corresponding to the type of components refers to the number of all placement points corresponding to components of this type on the PCB; types of nozzles used for producing the PCB are obtained according to the data file of the PCB and a component information file, and the types of nozzles are numbered as n∈[1, . . . ,N] in a decreasing order according to the number of placement points corresponding to the types of nozzles, wherein N is a total number of the types of nozzles, numbers of the nozzles are called nozzle number; the number of placement points corresponding to each type of nozzles is saved in Pn, wherein Pn indicates the number of placement points corresponding to the nozzle number n; a maximum number of each type of available nozzles is set and saved in linNz, wherein linNz (n) indicates the number of available nozzles corresponding to the nozzle number n; a total number of heads of the surface mounter is set as H, and indexes of the heads are numbered as h∈[1, . . . ,H] in an increasing order along an X-axis; a total number of placement points is set as Q, and indexes of the placement points are numbered as q∈[1, . . . ,Q]; a total number of the pick-and-place cycles is set as K, and indexes of the pick-and-place cycles are numbered as k∈[1, . . . ,K]; a K-row and H-column two-dimensional array PS, all elements of which are 0, is initialized to be used for saving a placement sorting result, wherein an element PS(k,s) of PS indicates an s th head for placement in a k th pick-and-place cycle, PS(k,s)∈[1, . . . ,H];
the component allocation result is saved in a K-row and H-column two-dimensional array PA, wherein an element PA(k,h) of PA indicates the type of the component picked up and placed by the h th head in the k th pick-and-place cycle, PA(k,h)∈[1, . . . ,C];
indexes of types of feeders are numbered as f∈{1,2, . . . ,F}, wherein F is a total number of types of feeders;
a slot allocation result of feeder groups is saved in a one-dimensional array PS, a pickup slot allocation result in each sub-cycle is saved in FA, and a pickup sorting result is saved in FP, wherein FA and FP are both K-row and H-column two-dimensional arrays;
component numbers corresponding to each type of components are saved in pcb_cp_type_cp_lib_index;
feeder numbers corresponding to each type of components are saved in pcb_cp_type_fd_lib_index;
nozzle numbers corresponding to each type of components are saved in pcb_cp_type_nz_lib_index;
wherein, pcb_cp_type_cp_lib_index, pcb_cp_type_fd_lib_index and pcb_cp_type_nz_lib_index are all one-row and C-column arrays.
4 . The method for optimizing the placement process of surface mounters based on heuristic adaptive tabu search according to claim 3 , wherein in Step 2 , the nozzle assignment result is obtained based on the nozzle assignment heuristic algorithm specifically as follows:
the nozzle assignment result is saved in a numNZl-row and H-column array NZg, which is formed by a series of nozzle combination results and has numNZl nozzle row, wherein the “nozzle row” refers to one nozzle combination result, and in the first nozzle row NZg(1,:)=[1 1 1 2 3 4], 1, 2, 3 and 4 are both nozzle numbers and indicate that nozzles 1 are mounted on heads 1, 2 and 3, nozzle 2 is mounted on head 4, nozzle 3 is mounted on head 5, and nozzle 4 is mounted on head 6; “:” indicates that all values in a dimension are obtained by auto-increment, and NZg(k,:) indicates the acquisition of all elements in a k th placement sorting chromosome; specifically: “1:1:H” indicates the acquisition of an array from 1 to H with an increment 1, that is, [1, . . . ,H]; “H:−1:1” indicates the acquisition of an array from H to 1 with an increment −1, that is [H,H−1, . . . , 1],1:1:H is abbreviated as NZg(k,1:H); when the array is indexed, if the first value is 1, the last value will be exactly the number of elements in the dimension, so NZg(k,1:H) is further abbreviated as NZg(k,:); floorNzCyc is a one-row and numNZl-column array, and each element in floorNzCyc indicates the serial number of the first pick-and-place cycle in one nozzle row; numKinNZ1 is a one-column and numNZl-column array, and each element in numKinNZ1 indicates the number of all pick-and-place cycles in one nozzle row.
5 . The method for optimizing the placement process of surface mounters based on heuristic adaptive tabu search according to claim 4 , wherein in Step 3 , the heuristic adaptive information link is initialized specifically by the following steps:
Step 31 , initializing and assigning nozzle rows to obtain a sequence array SeqNzl=1:K for component allocation, wherein elements in the sequence array indicate component allocation sequences in the pick-and-place cycles; if SeqNzl(5) is 7, it indicates that component allocation will be performed for the nozzle row corresponding to the seventh pick-and-place cycle in the fifth round; a component allocation algorithm selection information link SeqCpAa is a one-row and K-column array, and elements in SeqCpAa indicate types of component allocation algorithms adopted when component allocation is performed for the nozzle rows; if the element is 1, an available feeder-oriented component allocation algorithm is adopted to perform Step 426 ; if the element is 0, an assigned feeder group-oriented component allocation algorithm is adopted to perform Step 427 ; initializing and assigning a component allocation algorithm selection link Seq01 link=1:1:2K, wherein elements in Seq01 link indicate indexes of the component allocation algorithms, Seq01 Bin is defined as a one-row and 2K-column array, first K columns in Seq01 Bin are 1, last K columns in Seq01 Bin is 0, and with each value in Seq01 link as an index, values corresponding to Seq01 Bin are obtained according to SeqCpAa; if Seq01 link(5) is 7, it indicates the seventh element in Seq01 Bin; if Seq01 Bin(7)=0, it indicates SeqCpAa(5)=0, that is, the assigned feeder group-oriented component allocation algorithm is adopted to perform Step 427 ; or, if Seq01 Bin(7)=1, it indicates SeqCpAa(5)=1, that is, the available feeder-oriented component allocation algorithm is adopted to perform Step 426 ; initializing and assigning a head sequence SeqHd=1:1:H used for component allocation SeqHd=1:1:H, wherein if SeqHd(2)=2, it indicates that the sequence of head 2 during component allocation is 2; initializing a component allocation information link CpAlink, wherein CpAlink is a one-row and (3*K+H)-column array formed by splicing SeqNZl, Seq01 link and SeqHd, value intervals are used for a distinguishing purpose, each value in SeqNZl is added by 30000, each value in Seq01 link is added by 20000, and each value in SeqHd is added by 10000, and then the three modified arrays are spliced to form CpAlink; where, * is a multiplication sign; SeqNZl is a sub-cycle allocation sequence array, Seq01 link is the component allocation algorithm selection link, SeqHd is a head allocation array, Seq01 Bin is an algorithm selection binary array, and SeqCpAa is component allocation algorithm selection information; and Step 32 , initializing a pick-and-place path optimization sequence information link PAPlink, wherein the pick-and-place path optimization sequence information link is a one-row and K-column array, and PAPlink=1:1:K; the heuristic adaptive information link HATSlink is a one-row and (4*K+H)-column array formed by splicing CpAlink and PAPlink.
6 . The method for optimizing the placement process of surface mounters based on heuristic adaptive tabu search according to claim 5 , wherein in Step 4 , the component allocation information link CpAlink is decoded by the following steps:
executing the component allocation algorithm according to the component allocation information link decoding result to complete component allocation to obtain the component allocation result Cpg;
performing path optimization in all the pick-and-place cycles according to PAPlink, and updating the pick-and-place path optimization result;
calculating the corresponding total PCB assembly time TotalCost according to the nozzle assignment result, the component allocation result, and the pick-and-place path optimization result;
initializing the optimal total assembly time TotalCostbest=TotalCost, and then outputting the placement process optimal result;
a specific process comprises:
Step 41 , decoding the component allocation information link CpAlink specifically as follows:
Step 411 , using a numNZl-row and two-column array idxCyc to locate a current nozzle row number and pick-and-place cycle number under operation, wherein data in the first row of idxCyc indicate the number of the nozzle row under allocation in the nozzle assignment result NZg, data in the second row of idxCyc indicate the serial number of the first pick-and-place cycle to be allocated in the current nozzle row, and idxCyc(1,1)=1 indicates that component row 1 of the component allocation result corresponds to nozzle row 1; idxCyc(1,2)=floorNzCyc(1) indicates that component row 1 of the component allocation result corresponds to the current first pick-and-place cycle floorNzCyc(1); one component row indicates an array formed by numbers of the types of components picked up and placed by the heads in one sub-cycle;
Step 412 , saving data information greater than 30000 in the component allocation information link CpAlink in the sub-cycle allocation sequence array SeqNZl, and subtracting 30000 from the data to obtain actual values; Step 413 , saving data information greater than 20000 in the component allocation information link CpAlink the component allocation algorithm selection link Seq01 link, and subtracting 20000 from the data to obtain actual values; obtaining the component allocation algorithm selection information SeqCpAa=Seq01 Bin (Seq01 link) according to the component allocation algorithm selection link Seq01 link and the algorithm selection binary array Seq01 Bin;
Step 414 , saving data information greater than 10000 in the component allocation information link CpAlink in the head allocation array SeqHd, and subtracting 10000 from the data to obtain actual values;
Step 42 , performing the component allocation algorithm according to the component allocation information link decoding result to complete component allocation to obtain the component allocation result Cpg;
wherein, Cpg is an H-column two-dimensional array; elements in Cpg indicate the types of components picked and placed by the heads in the sub-cycles, and Cpg(4,3)=18 indicates that a component to be picked and placed by the third head in the fourth sub-cycle is of type 18;
Step 43 , performing path optimization in all the pick-and-place cycles according to PAPlink, and updating the pick-and-place path optimization result specifically as follows:
wherein, PAPlink is the pick-and-place path optimization sequence information link;
Step 431 , initializing a pick-and-place cycle count variable cntK=1, wherein the pick-and-place cycle count variable cntK is used for counting pick-and-place cycles that have completed path optimization;
Step 432 , determining whether cntK>K, that is, determining whether path optimization of all the pick-and-place cycles have been completed; if so, determining that path optimization of all the cycles has been completed, and performing Step 44 ; if not, performing Step 433 ;
Step 433 , obtaining a current cycle idxK=PAPlink(cntK) under optimization according to the pick-and-place path optimization sequence information link PAPlink; Step 434 , performing path optimization on the (idxK) th pick-and-place cycle to obtain a pick-and-place path optimization result: a placement point allocation result PA(idxK,:), a placement sorting result PS(idxK,:), and a pickup slot allocation result FA(idxK,:) and a pickup sorting result FP(idxK,:) in each sub-cycle; and Step 435 , updating the count variable cntK=cntK+1, and returning to Step 432 ;
Step 44 , calculating the total PCB assembly time TotalCost by:
obtaining a total movement distance total_dis of a head assembly according to the pick-and-place path optimization result, and calculating the total PCB assembly time TotalCost=total_dis/v based on the total movement distance total_dis and an average movement speed v of the head assembly; and
Step 45 , initializing the total PCB assembly time TotalCost, and then performing Step 5 .
7 . The method for optimizing the placement process of surface mounters based on heuristic adaptive tabu search according to claim 6 , wherein in Step 42 , a specific process of performing component allocation algorithm according to the component allocation information link decoding result to complete component allocation to obtain the component allocation result Cpg comprises:
Step 421 , initializing parameters related to component allocation specifically as follows:
Step 4211 , obtaining a nozzle assignment result NZgs=NZg(:,SeqHd) after the heads are rearranged according to SeqHd;
wherein, SeqHd is a head sequence during component allocation, NZgs is the nozzle assignment result after the heads are rearranged, and NZg(:,SeqHd) is a nozzle assignment result sequentially read according to SeqHd;
Step 4212 , sumSP=0, NZg0=NZgs, numKinCpl=numKinNZl;
wherein, the variable sumSP is the number of pickup operations reduced by means of simultaneous pickup;
the variable NZg0 is a nozzle assignment result obtained according to the sub-cycles for component allocation;
the variable numKinCpl is the number of pickup cycles in each component row;
the variable numKinNZl is the number of pick-and-place cycles in each nozzle row;
Step 4213 , saving a temporary component allocation result under update in CPg0;
wherein, flagNZg0 is a flag array indicating that allocation of nozzle rows under update has been completed and is a one-row and numNZl-column array, and elements in flagNZg0 indicate whether component allocation of the nozzle rows has been completed;
numFdLim0 is a one-row and C-column array and indicates available feeders under update, and elements in the numFdLim0 indicate the numbers of available feeders corresponding to different types of components;
Fdg0 indicates feeder groups under update and is initialized into an empty array;
numFdg0 indicates the number of feeder groups under update and is initialized to 0;
numSPH0 indicates the number of different simultaneous pickup types under update and is initialized into a one-row and H-column array, the values of which are 0;
numPtinCp0 indicates the number of placement points corresponding to different types of components under update and is a one-row and C-column array, and elements in numPtinCp0store the number of placement points corresponding to non-allocated components;
the simultaneous pickup type refers to a possible case of simultaneous pickup of components on multiple feeders at one position when components on the feeders of the surface mounter are picked up, the number of the simultaneous pickup types corresponds to the number of the heads, there are totally H simultaneous pickup types SP1-SPH, and SP2 indicates that when a pickup action is performed at said position, two heads are able to simultaneously pick up components from two feeders;
wherein, numNZl is a total number of the nozzle rows, and CPg0 is the temporary component allocation result; and
Step 4214 , numCPl0=numNZl, idxCyc0=idxCyc, sumSP0Max=−1, numNZl0K=0, cntK=0;
wherein, numCPl0 is the number of component rows under update;
idxCyc0 is an index array of cycles under update;
sumSP0Max is a maximum simultaneous pickup count variable and is initialized to −1, and there will be no simultaneous pickup after component allocation, so this variable is set to 0;
numNZl0K is used for saving nozzle rows that have completed component allocation;
cntK is used for counting pick-and-place cycles that have completed component allocation, is also used as a coded information index, and is initialized to 0;
numNZl is a total number of nozzle rows;
idxCyc is used for locating the current nozzle row number and pick-and-place cycle number under operation;
Step 422 , determining whether the number numNZl0K of nozzle rows that have completed component allocation is less than the total number numNZl of nozzle rows; if so, performing Step 423 ; otherwise, returning to Step 43 ;
Step 423 , saving the current temporary component allocation result in a temporary variable, and determining whether component allocation has been completed specifically as follows:
Step 4231 , NZg0T=NZg0, numKinCplT=numKinCpl, CPgT1=CPg0, flagNZgT=flagNZg0, numFdLimT1=numFdLim0, FdgT1=Fdg0, numFdgT1=numFdg0, numSPHT1=numSPH0, numPtinCpT1=numPtinCp0, numCPlT1=numCPl0, idxCycT1=idxCyc0, cntK=cntK+1;
wherein, NZg0T is a temporary nozzle assignment result variable, and NZg0 is the nozzle assignment result obtained according to the sub-cycles for component allocation;
numKinCplT is a temporary variable of the number of pick-and-place cycles in each component row, and numKinCpl is the number of pick-and-place cycles in each component row;
CPgT1 saves the temporary component allocation result, and CPg0 is the temporary component allocation result under update;
flagNZgT is a flag array indicating that allocation of temporary nozzle rows has been completed, and flagNZg0 is a flag array indicating that allocation of nozzle rows under update has been completed;
numFdLimT1 is an array of the number of temporary available feeders, and numFdLim0 is an array of available feeders under update;
FdgT1 indicates temporary feeder groups, and Fdg0 indicates feeder groups under update;
numFdgT1 is the number of temporary feeder groups, and numFdg0 is the number of feeder groups under update;
numSPHT1 is the number of temporary simultaneous pickups, and numSPH0 is the number of simultaneous pickups under update;
numPtinCpT1 is the number of temporary placement points corresponding to different types of components, and numPtinCp0 is the number of placement points under update corresponding to different types of components;
numCPlT1 is the number of temporary component rows, and numCPl0 is the number of component rows under update;
idxCycT1 is an index array of temporary cycles, and idxCyc0 is an index array of cycles under update;
Step 4232 , idxNZi=SeqNZl(cntK), idxNZl=idxCycT1 (idxNZi,1);
wherein, idxNZi indicates an index of a current nozzle row under component allocation;
idxNZl indicates a component row corresponding to the component allocation result;
SeqNZl(cntK) is data in the (cntK) th row of the sub-cycle allocation sequence array;
idxCycT1 (idxNZi,1) is the number of the nozzle row corresponding to the (idxNZi) th row of the index array of temporary cycles; and Step 4233 , if flagNZgT (idxNZi)=1, determining that component allocation has been performed on the component row, and returning to Step 422 ; if flagNZgT (idxNZi)=0, determining component allocation has not been performed on the component row, and performing Step 424 ; Step 424 , acquiring simultaneous pickup type data according to current nozzle row information specifically as follows: Step 4241 , NZl=NZg0T(idxNZi), wherein columns that are not equal to 0 in NZl are saved in an array idxNot0, the size of which is numNot0, NZl indicates the current nozzle row under component allocation, and numbers of nozzles to be allocated in the current nozzle row are saved in idxNot0; Step 4242 , cntNzT=0, wherein cntNzT is a count variable and is used for counting the types of nozzles in the current nozzle row; when the types of nozzles in the current nozzle row are saved in libNzT, uplimflagSpT corresponds to a simultaneous pickup type search upper limit of the types of nozzles saved in libNzT, and flagSpT corresponds to a simultaneous pickup type search count array of the types of nozzles saved in libNzT; libNzT, uplimflagSpT and flagSpT are updated and assigned in Step 4244 and are all one-dimensional arrays; the types of nozzles in the current nozzle row are saved in libNzT; Step 4243 , if the current nozzle row NZl under component allocation is not empty, performing Step 4244 ; otherwise, performing Step 425 ; Step 4244 , if NZl(1)=1, cntNzT=cntNzT+1, libNzT.push(NZl(1)), multiplying numSpT_1 greater than 1 in numSpT(NZl(1)) by numSpT(NZl(1)), and saving the product in uplimflagSpT, that is, uplimflagSpT.push(numSpT_1*numSpT(NZl(1))), flagSpT.push(0); otherwise, directly performing Step 4245 ; wherein, numSpT is a one-row and numNZl-column array and saves the number of simultaneous pickup types corresponding to N types of nozzles; “.push( )” refers to the interpolation of a value at the end of an array; cntNzT is a count variable for counting the types of nozzles in the current nozzle row, and libNzT.push(NZl(1)) indicates the interpolation of the current nozzle row under component allocation into libNzT, in which the types of nozzles in the current nozzle row are saved; numSpT(NZl(1)) is the number of simultaneous pickup types corresponding to the current nozzle row NZl(1) under component allocation, wherein numSpT indicates the number of simultaneous pickup types corresponding to different types of nozzles, numSpT_1 is the number greater than 1 in numSpT(NZl(1)), uplimflagSpT corresponds to the simultaneous pickup type search upper limit of the types of nozzle saved in libNzT, uplimflagSpT.push(numSpT_1*numSpT(NZl(1))) indicates the interpolation of a product of numSpT_1 and numSpT(NZl(1)) at the end of the array uplimflagSpT, and flagSpT.push(0) indicates the interpolation of 0 at the end of flagSpT, wherein flagSpT corresponds to the simultaneous pickup type search count array of the types of nozzles saved in libNzT; and Step 4245 , removing nozzles numbers, identical with NZl(1), from the current nozzle row NZl under component allocation, and returning to Step 4243 ; Step 425 , before component allocation is performed column by column on the current nozzle row, selecting a component allocation algorithm strategy specifically as follows: Step 4251 , flagOKT being a flag array indicating that component allocation of the heads has been completed and being a one-row and H-column array, and elements in flagOKT indicating whether component allocation of columns in the current nozzle row has been completed, if flagOKT is 1, determining that component allocation has not been completed; if flagOKT is 0, determining that component allocation has been completed, initializing flagOKT to an all-zero array, and under an idxNot0 index, setting flag OKT to 1, indicating “not allocated”; wherein, numKinCol is an array of the number of to-be-allocated placement points corresponding to the heads and is a one-row and H-column array, in which the number of to-be-allocated placement points in the columns in the current nozzle row is saved, and numKinCol is initialized into an all −1 array; Step 4252 , setting all values in numFdLimT2=numFdLimT1, flagOK=flagOKT, FdgPrior1=SeqCpAa (cntK and numKinCol to numKinCplT (idxNZi); wherein, numFdLimT2 indicates an array of second temporarily used available feeders; flagOK indicates a flag array indicating that allocation of temporarily used heads has been completed; FdgPrior1 indicates a feeder assignment flag; if FdgPrior1=1, it indicates that allocation is performed preferably according to available feeders; if FdgPrior1=0, it indicates that allocation is performed preferably according to feeder groups; SeqCpAa (cntK) indicates the (cntK) th element in the component allocation algorithm selection information link SeqCpAa, numKinCol indicates the array of the number of to-be-allocated placement points corresponding to the heads, numKinCplT (idxNZi) indicates the (idxNZi) th element in the variable of the number of pick-and-place cycles in temporary component rows, and idxNZi is an index of the current nozzle row under component allocation; Step 4253 , if FdgPrior1=1, FdgPrior2=1; otherwise, FdgPrior2=0, wherein if FdgPrior2=1, it indicates that remaining heads cannot be allocated according to feeder groups; if FdgPrior2=0, it indicates that remaining heads can be allocated according to feeder groups; Step 4254 , cntNot0=1, flagAvailable=0; wherein, cntNot0 is a count variable and used for counting heads to be allocated; if flagAvailable is 0, it indicates that available feeders are not used during current allocation; Step 4255 , if cntNot0 is less than numNot0, performing step 4256 ; otherwise, performing Step 429 ; Step 4256 , idxH=idxNot0(cntNot0), cntNot0=cntNot0+1; wherein, idxH is the head number corresponding to current component allocation; idxNot0(cntNot0) indicates the (cntNot0) th element in idxNot0, wherein idxNot0 indicates columns greater than 0 in the current nozzle row under component allocation; Step 4257 , if flagOK (idxH)=1, which indicates that the current head is not allocated, performing Step 4258 ; otherwise, performing Step 429 ; wherein, flagOK (idxH) indicates the (idxH) th element in the flag array indicating that allocation of the heads has been completed, and idxH indicates the number of the current head under component allocation; Steps 4258 , saving indexes corresponding to values, equal to NZg0T(idxNZi,idxH), in libNzT in the variable idxlibNzT; wherein, NZg0T(idxNZi,idxH) refers to the value in the (idxNZi) th row and the (idxH) th column in NZg0T; if flagSpT(idxlibNzT)=1, idxCpTinNzT=SpT(NZg0T(idxNZi,idxH)); otherwise, idxCpTinNzT=idx_cp_type_nz_type(NZg0T(idxNZi,idxH)); idx_cp_type_nz_type is a one-row and N-column array and saves the types of components that can be picked and placed by different types of nozzles, and SpT is a one-row and N-column array and saves the simultaneous pickup types corresponding to different types of nozzles; idxlibNzT indicates indexes of values, equal to NZg0T(idxNZi,idxH), in libNzT, flagSpT(idxlibNzT) indicates the (idxlibNzT) th element in the simultaneous pickup type search count array of the types of nozzles saved in libNzT, idxCpTinNzT indicates the simultaneous pickup type corresponding to the current type of nozzles, SpT(NZg0T(idxNZi,idxH)) indicates the simultaneous pickup type corresponding to the nozzle type in the (idxNZi) th row and (idxH) th column in the temporary nozzle assignment result NZg0T, and idx_cp_type_nz_type(NZg0T(idxNZi,idxH)) indicates the type of components to be placed by the current type of nozzles NZg0T(idxNZi,idxH); and Step 4295 , if FdgPrior1=1 or FdgPrior2=1, performing Step 426 preferably according to available feeders; otherwise, performing Step 427 preferably according to feeder groups; Step 426 , performing component allocation preferably according to available feeder specifically as follows: Step 4261 , flagAvailable=1, flagFdLimTmp1=numFdLimT2, setting values equal to 0 in flagFdLimTmp1 to 1, and setting values equal to 1 in flagFdLimTmp1 to 0; wherein if flagAvailable is 1, it indicates that available feeders are used during current allocation; if flagAvailable is 0, it indicates that available feeders are not used; flagFdLimTmp1 indicates the number of transformed available feeders, and numFdLimT2 indicates the number of available feeders; Step 4262 , calculating a component selection function value numCptmpaccording to the number numPtinCpT1 of placement points to which components have not been allocated and the numbernumFdLimT2 of available feeders as follows:
numCptmp
=
numPtinCpT
1
(
idxCpTinNzT
)
-
flagFdLimTmp
1
(
idxCpTinNzT
)
×
1000
wherein, idxCpTinNzT indicates the simultaneous pickuptype corresponding to the current type of nozzles;
Step 4263 , saving a maximum component selection function value numCptmp in a variable maxCpNum, and saving an index of the maximum value in a variable idxMaxCpNum;
wherein, maxCpNum indicates the maximum component selection function value, and idxMaxCpNum indicates the index of the maximum value;
Step 4264 , if maxCpNum is equal to 0,numCptmp=numPtinCpT1 (idxCpTinNzT), saving the maximum component selection function value numCptmp in the variable maxCpNum, and saving an index of the maximum value in the variable idxMaxCpNum;
Step 4265 , calculating the type of components to be allocated, idxCpT=idxCpTinNzT(idxMaxCpNum), CPgT1 (idxNZi,idxH)=idxCpT;
wherein, idxCpT indicates the type of selected components to be allocated, CPgT1 (idxNZi,idxH) indicates a temporary component allocation result of the (idxNZi) th row and the (idxH) th column, and idxCpTinNzT(idxMaxCpNum) indicates the (idxMaxCpNum) th element of the simultaneous pickup type corresponding to the current type of nozzles; and
Step 4266 , updating related information of the components and the heads:
Step 42661 , updating the array numFdLimT2 of the second temporarily used available feeders;
numFdLimT2( pcb _ cp _type_ cp _ lib _index(idxCpT))=numFdLimT2( pcb _ cp _type_ cp _ lib _index(idxCpT))−1
wherein, pcb_cp_type_cp_lib_index(idxCpT) indicates the component number corresponding to the type idxCpT of selected components to be allocated;
Step 42662 , updating the flag array flagOK indicating that allocation of temporarily used heads has been completed, flagOK (idxH)=0;
Step 42663 , updating the array numKinCol of the number of to-be-allocated placement points corresponding to the heads;
numKinCol(idxH)=min(maxCpNum,numKinCol(idxH));
wherein, min(maxCpNum,numKinCol(idxH)) refers to calculation of the maximum component selection function value numCptmp and a minimum value in the (idxH) th column of the array of the number of to-be-allocated placement points corresponding to the heads; and
Step 42664 , updating the number of temporary placement points corresponding to different types of components;
numPtinCpT1(idxCpT)=numPtinCpT1(idxCpT)−numKinCol(idxH)
wherein, numPtinCpT1 indicates the number of temporary placement points corresponding to different types of components, and numKinCol indicates the array of the number of to-be-allocated placement points corresponding to the heads;
Step 427 , performing allocation preferably according to feeder groups specifically as follows:
Step 4271 , idxFdgHd=1, optnumSp=0, cntFdgT=1;
wherein, idxFdgHd indicates whether allocation can be performed according to feeder groups; if idxFdgHd=1, it indicates that allocation cannot be performed according to feeder groups; if idxFdgHd=0, it indicates that allocation can be performed according to feeder groups;
the variable optnumSp is used for recording an optimal number of simultaneous pickups in the current allocation process;
cntFdgT is an ergodic count of a current feeder group;
Step 4272 , if the count cntFdgTof the current feeder group is less than the number of temporary feeder groups, idxsizeFdg=1, and performing Step 4273 ; otherwise, performing Step 428 ;
wherein, idxsizeFdg indicates a count variable for NzFdg counting;
the number of components in the current feeder groups is sizeFdg, sizeFdg is equal to FdgT1(cntFdgT), the type of nozzles corresponding to the type of components in the current feeder group is saved in a variable NzFdg, which is a one-row and sizeFdg-column array, and each value in NzFdg is initialized to 0;
idxsizeFdg is a count variable for NzFdg assignment, and FdgT1(cntFdgT) indicates the (cntFdgT) th elements in the temporary feeder group;
Step 4273 , assigning the type NzFdg of nozzles corresponding to the type of components in the current feeder group specifically as follows:
Step 42731 , if the count variable idxsizeFdg for NzFdg assignment is less than the number sizeFdg of components in the current feeder group, performing Step 42732 ; otherwise, performing Step 42734 ;
Step 42732 , if FdgT1(cntFdgT) (idxsizeFdg) which indicates the (idxsizeFdg) th item in FdgT1(cntFdgT) is greater than 0, NzFdg (cntFdgT)=pcb_cp_type_nz_lib_index(FdgT1(cntFdgT) (idxsizeFdg)), and performing Step 42733 ;
wherein, NzFdg (cntFdgT) indicates the type of the (cntFdgT) th nozzle corresponding to the type of components in the current feeder group, and pcb_cp_type_nz_lib_index indicates nozzle numbers corresponding to the type of components;
Step 42733 , updating the count variable for NzFdg assignment idxsizeFdg=idxsizeFdg+1, and returning to Step 42731 ;
Step 42734 , if FdgT1(cntFdgT) (idxsizeFdg) which indicates the (idxsizeFdg) th item in FdgT1(cntFdgT) is greater than 0, NzFdg (cntFdgT)=pcb_cp_type_nz_lib_index(FdgT1(cntFdgT) (idxsizeFdg)), and performing Step 42735 ; and
Step 42735 , updating the count variable for NzFdg assignment idxsizeFdg=idxsizeFdg+1, and returning to Step 42731 ; and
Step 4274 , looping and determining whether simultaneous pickup is available when the components in the feeder group correspond to the heads, and performing component allocation, specifically:
Step 42741 , initializing the count variable i=sizeFdg−1;
wherein, sizeFdg indicates the number of components in the current feeder group;
Step 42742 , if i is greater than 1−H, performing Step 42743 ; otherwise, performing Step 42748 ;
Step 42743 , flagOK2=flagOK, numKinCol1=numKinCol, numPtinCp2=numPtinCpT, CPg2=CPgT1, cntSp=0;
wherein, flagOK2 is used for saving the flag array indicating that allocation of temporarily used heads has been completed, and flagOK indicates the flag array indicating
that allocation of temporarily used heads has been completed;
numKinCol1 is used for saving the array of the number of to-be-allocated placement points corresponding to the heads, and numKinCol is the number of to-be-allocated placement points corresponding to the heads;
numPtinCp2 is used for saving the temporary number of placement points corresponding to different types of components, and numPtinCpT1 indicates the temporary number of placement points corresponding to different types of components;
CPg2 is used for saving the temporary component allocation result, and CPgT1 indicates the temporary component allocation result;
cntSp is used for counting simultaneous pickups;
Step 42744 , minj=max((i+1),1), maxj=min(H+i, sizeFdg), wherein the minimum value is minj, the maximum value is maxj, max(a,b) is used for selecting a greater value from 1 and b, and min(a,b) is used for selecting a smaller value from a and b; H indicates the total number of heads of the surface mounter; sizeFdg indicates the number of components in the current feeder group; i is the count variable in Step 42471 and indicates the i th element in the feeder group, and j is an ergodic count variable of type of components in the feeder group used in Step 42745 and indicates the j th element in the feeder group;
Step 42745 , looping through the types of components in the feeder group for component allocation specifically as follows:
1, using j=minj as an ergodic count variable of the type of components in the feeder group;
2, if j is less than maxj, performing 3; otherwise, performing Step 42746 ;
3, idxH=j−I, idxCpT=FdgT1(cntFdgT)(j);
wherein, idxH indicates the number of heads under current component allocation, idxCpT indicates the type of components selected for component allocation, and FdgT1(cntFdgT)(j) indicates the j th element in the current temporary feeder group;
4, if flagOK2(idxH) is not equal to 0, idxCpT is not equal to 0, NzFdg(j) is equal to NZg0T(idxNZi,idxH) and numPtinCp2(idxCpT) is not equal to 0, performing the following operations:
updating the simultaneous pickup count variable cntSp, cntSp=cntSp+1;
updating the temporary component allocation result CPg2, CPg2(idxNZi,idxH)=idxCpT;
updating and saving the temporary flag array flagOK2 indicating that allocation of heads has been completed, flagOK2(idxH)=0;
updating the array numKinCol1 of the temporary number to-be-allocated placement points corresponding to heads, numKinCol1 (idxH)=min(numPtinCp2(idxCpT), numKinCol1 (idxH));
updating the temporary number numPtinCp2 of to-be-allocated placement points corresponding to heads, numPtinCp2(idxCpT)=numPtinCp2(idxCpT)-numKinCol1 (idxH);
wherein, NzFdg(j) indicates the j th type of nozzles corresponding to the type of components in the current feeder group, and CPg2(idxNZi,idxH) indicates the (idxH) th element in the temporary component allocation result in the (idxNZi) th row;
5, j=j+1, returning to 2;
Step 42746 , if the simultaneous pickup count cntSp is greater than the current optimal number optnumSp of simultaneous pickups, updating as follows:
updating the variable idxFdgHd indicating whether allocation can be performed according to feeder groups, idxFdgHd=0;
updating the optimal number optnumSp of simultaneous pickups in the current allocation process, CPg3-CPg2;
flagOK3=flagOK2, numKinCol2-numKinCol1, numPtinCp3=numPtinCp2;
wherein, CPg3 is another temporary component allocation result;
flagOK3 is another temporary array indicating whether allocation of heads has been completed, and flagOK2 is the saved temporary flag array indicating that allocation of heads has been completed;
numKinCol2 is used for saving another temporary array of the number of to-be-allocated placement points corresponding to heads;
numPtinCp3 is used for saving another number of placement points corresponding to different types of components;
Step 42747 , i=i−1, returning to Step 42747 ; and
Step 42748 , updating the ergodic count variable of the current feeder group, cntFdgT=cntFdgT+1, and returning to Step 4272 ;
Step 428 , if idxFdgHd is greater than 0, performing the following operations:
updating a flag FdgPrior2 indicating whether remaining heads can be allocated according to feeder groups, FdgPrior2=1;
updating the count variable cntNot0, cntNot0=cntNot0=1;
otherwise, performing the following operations:
updating the temporary component allocation result CPgT1, CPgT1=CPg3;
updating the temporary flag array flagOK indicating that allocation of heads has been completed, flagOK=flagOK3;
updating the array numKinCol of the number of to-be-allocated placement points corresponding to heads, numKinCol=numKinCol2;
updating the temporary number numPtinCpT1 of placement points corresponding to different types of components, numPtinCpT1=numPtinCp3;
updating the count variablecntNot0, cntNot0=1;
returning to Step 4255 ;
Step 429 , saving indexes, not equal to 0, in the array numKinCol(idxNot0) of the number of to-be-allocated placement points corresponding to heads in an array idxCPgSubcyNot0, the size of which is numCPlSubcyNot0;
if numCPlSubcyNot0 is equal to numNot0, which indicates that the number of placement points corresponding to some heads is 0, indicating that the allocation is invalid, performing Step 4201 ; if numCPlSubcyNot0 is not equal to numNot0, returning to Step 422 to perform the next round of component allocation;
wherein, idxCPgSubcyNot0 indicates non-zero indexes of the array of the number of to-be-allocated placement points corresponding to the heads, numCPlSubcyNot0 indicates the number of non-zero indexes of the array of the number of to-be-allocated placement points corresponding to the heads, and numNot0 indicates the number of non-zero columns in the current nozzle row under component allocation; and
Step 420 , further performing component allocation by means of the component allocation method, saving a component allocation result in CPg, saving a nozzle assignment result obtained according to the sub-cycles for component allocation in NZg0, updating the feeder group Fdg0 according to the nozzle assignment result, and saving the number of simultaneous pickups for different types of components in numSPH; returning to Step 422 to perform the next round of component allocation.
8 . the method for optimizing the placement process of surface mounters based on heuristic adaptive tabu search according to claim 7 , wherein initializing tabu search parameters in Step 5 comprises: initializing the neighbor operation ActionList, and determining the tabu length nAction and the unimproved tabu search upper limit NI, specifically:
Step 51 , determining a neighbor operation list ActionList according to a variable numSeq which is equal to the sum of the length of the component allocation information link CpAlink and the total number K of pick-and-place cycles, wherein ActionList is a 2*numSeq 2 −numSeq-row and three-column array, a first column of which represents an operator identifier and a second column and a third column are increasing sequences;
wherein, * indicates a multiplication sign;
first
numSeq
*
(
numSeq
-
1
)
2
rows are commuting operator, the operator identifier in the first column is 1, the second column is an increasing sequence from 1 to numSeq−1, and the third column is an increasing sequence from 2 to numSeq;
rows from the
(
numSeq
*
(
numSeq
-
1
)
2
)
th
row to the (numSeq*(numSeq−1)) th row are reversal operators, the operator identifier in the first column is 2, the second column is an increasing from 1 to numSeq-1, and the third column is an increasing sequence from 2 to numSeq;
rows from the (numSeq*(numSeq−1)) th row to the (2*numSeq 2 −numSeq) th row are interpolation operators, the operator identifier in the first column is 3, the second column is an increasing from 1 to numSeq-1, and the third column is an increasing sequence from 2 to numSeq;
ActionList(2) is to acquire the second row of the neighbor operation list, and ActionList(2)(1) is to acquire a value in the second row and the first column of the neighbor operation list;
Step 52 , denoting the number of times of being disabled of neighbor operations in the neighbor operation list as TC, and denoting the number of times of being disabled of updating is as TL;
TL=ceil(1.5√{square root over (numSeq)}), denoting the length of ActionList as nAction, and initializing TL into an nAction-row and one-column array;
wherein, ceil( ) indicates an operation of rounding up to an integer of a result when a floating number is calculated; and
Step 53 , saving an optimal tabu neighbor operation list selection index in iActionbestTabu, initializing iActionbestTabu=0, initializing an unimproved search counting variable ni=0, and initializing the unimproved tabu search upper limit to NI.
9 . The method for optimizing the placement process of surface mounters based on heuristic adaptive tabu search according to claim 8 , wherein in Step 6 , a specific process of determining whether the current number of times of unimproved tabu searches is less than the unimproved tabu search upper limit; if so, performing Step 7 ; otherwise, performing Step 9 comprises:
Step 61 , determining whether the unimproved search counting variable ni is less than or equal to NI; if so, performing Step 62 ; otherwise, performing Step 9 ;
NI=TL;
wherein, NI indicates the unimproved tabu search upper limit, and TL indicates the number of times of being disabled of updating;
Step 62 , initializing the optimal assembly time TotalCostbestTabu to be infinite inf, and initializing a count variable it in this round to 1; and
Step 63 , if it is less than TL, performing Step 71 ; otherwise, performing Step 84 .
10 . The method for optimizing the placement process of surface mounters based on heuristic adaptive tabu search according to claim 9 , wherein in Step 7 , a specific process of performing a neighbor search operation on the heuristic adaptive information link to obtain the current heuristic adaptive information link, invoking the heuristic adaptive information link decoding algorithm to decode the current heuristic adaptive information link to obtain the corresponding placement process optimization result as the candidate solution, and performing Step 8 comprises:
Step 71 , setting a tabu flag TCflag=1, and setting a neighbor operation list selection index iAction=ceil(nAction*rand( ), wherein rand( ) indicates the generation of a floating number from 0 to 1;
Step 72 , newHSlink=DoAction(HATSlink,ActionList(iAction));
wherein, newHSlink is a new heuristic adaptive information link;
HATSlink indicates the heuristic adaptive information link;
DoAction( ) is an operator identifier corresponding to ActionList(iAction)(1), and corresponding commuting, reversal and interpolation operations are performed on two indexes ActionList(iAction)(2) and ActionList(iAction)(3) of HATSlink to obtain the new heuristic adaptive information link;
ActionList(iAction)(1) indicates a first element in the (iAction) th row of the tabu list, ActionList(iAction)(2) indicates a second element in the (iAction) th row of the tabu list, and ActionList(iAction)(3) indicates a third element in the (iAction) th row of the tabu list;
Step 73 , if TC(iAction) is not equal to 0, TCflag=0; otherwise, not changing the value of the tabu flag TCflag;
TC(iAction) indicates the number of times of being disabled of the neighbor operation on the (iAction) th row of the tabu list;
Step 74 , because the heuristic adaptive information link HATSlink is a one-row and (4*K+H)-column array formed by splicing the component allocation information link CpAlink and the pick-and-place path information link PAPlink, updating the heuristic adaptive information link according to the new heuristic adaptive information link HATSlink=newHSlink, then splitting HATSlink, using first (3*K+H) columns of HATSlink to update CpAlink, and using last K columns to update PAPlink;
Step 75 , performing Step 41 and Step 42 to decode the component allocation information link CpAlink, and performing component allocation according to a decoding result; and
Step 76 , performing Step 43 , Step 44 and Step 45 to decode the updated pick-and-place path information link PAPlink, obtaining a pick-and-place path according to the decoding result, and then obtaining a candidate solution according to the nozzle assignment result, the component allocation result and the pick-and-place path optimization result;
wherein, the total PCB assembly time TotalCost is calculated as follows:
the total movement distance total_dis of the head assembly is obtained according to the pick-and-place path optimization result, and the total PCB assembly time TotalCost=total_dis/vis calculated based on total movement distance total_dis and the average movement speed v of the head assembly;
in Step 8 , a specific process of updating a current solution according to the candidate solution and a tabu list, updating the tabu list, and returning to Step 6 comprises:
Step 81 , if the total PCB assembly time TotalCost obtained by performing Step 67 is less than the optimal total assembly time TotalCostbest, updating the current solution:
updating the optimal total assembly time TotalCostbest=TotalCost;
updating the optimal heuristic adaptive information link HATSlinkbest=newHSlink;
wherein, newHSlink is a new heuristic adaptive information link;
updating an optimal neighbor operation list selection index iActionbest-iAction;
wherein iAction is the neighbor operation list selection index;
otherwise, not updating the current solution;
Step 82 , if TCflag=1 and TotalCost is less than TotalCostbestTabu, updating the tabu list:
updating the optimal total assembly time in the tabu list TotalCostbestTabu=TotalCost;
updating the optimal heuristic adaptive information link HATSlinkbestTabu=newHSlink;
updating an optimal tabu neighbor operation list selection index iActionbestTabu=iAction;
otherwise, not updating the tabu list;
Step 83 , it=it+1, returning to Step 63 ;
Step 84 , ni=ni+1;
Step 85 , updating the tabu list and the heuristic information link specifically as follows:
Step 851 , if TotalCostbest is less than TotalCost, performing Step 825 ; otherwise, performing Step 855 ;
Step 852 , updating the heuristic information link and the total PCB assembly time HATSlink=HATSlinkbest, TotalCost=TotalCostbest;
Step 853 , updating the tabu list specifically as follows:
Step 8531 , defining a loop variable i=1;
Step 8532 , if i is less than nAction, performing Step 8533 ; otherwise, returning to Step 854 ;
Step 8533 , if i is equal to iActionbest, TC(i)=TL; otherwise, TC(i)=max (TC(i)−1,0);
wherein, TC(i) indicates the number of times of being disabled of the neighbor operation on the i th row in the neighbor operation list; and
Step 8644 , i=i+1, returning to Step 8532 ;
Step 854 , ni=0;
Step 855 , updating the heuristic adaptive information link HATSlink=HATSlinkbestTabu; and
Step 856 , updating the tabu list specifically as follows:
Step 8561 , defining a loop variable i=1;
Step 8562 , if i is less than nAction, performing Step 8563 ; otherwise, performing Step 86 ;
Step 8563 , if i is equal to iActionbest, TC(i)=TL; otherwise, TC(i)=max (TC(i)−1,0); and
Step 8564 , i=i+1, returning to Step 8562 ; and
Step 86 , returning to Step 6 .Join the waitlist — get patent alerts
Track US2025131178A1 — get alerts on status changes and closely related new filings.
We store only your email — no account needed. See our privacy policy.