Multi-condition simulation data batch generation method and system for tire test bed

Abstract

The application discloses a batch generation method and system for multi-working condition simulation data of a tire test bench, and particularly relates to the technical field of simulation data processing of the tire test bench, which comprises the following steps: obtaining historical test records and a target simulation parameter table; reading a bench instruction frame and a bench response frame according to a sampling time; splicing the bench instruction frame into a target working condition word in ascending order according to a channel address; changing a target entering bit to a target working condition word changing bit; intercepting the bench response frame to form an entering front response sequence; and writing the entering front response sequence into a historical working condition record table; merging the target working condition word into the historical working condition record table; performing wild binary split point detection on the same word entering front response sequence; generating a candidate subinterval according to a sampling bit; identifying the entering front state change under the same target working condition by converting the bench instruction into the target working condition word and intercepting the entering front response sequence; generating a hidden state particle and writing the hidden state particle into a tire simulation initial condition; and batch executing a multi-state simulation task in an industrial cloud computing environment.

Description

Technical Field

[0001] This invention relates to the field of tire testing bench simulation data processing technology, and more specifically, to a method and system for batch generation of multi-condition simulation data for tire testing benches. Background Technology

[0002] Multi-condition simulation data from tire testing benches are mainly used for tire mechanical performance analysis, bench test scheme arrangement, and control model verification. Existing processing methods generally establish condition tables around target parameters such as speed, vertical load, sideslip angle, slip ratio, braking torque, and ambient temperature, and then generate a large number of simulation tasks by using orthogonal experiments, random sampling, reuse of historical conditions, or proxy models. In continuous tests such as high-speed durability, braking and steering superposition, and variable load lateral deviation, the same tire will continuously undergo temperature rise, loading, unloading, brake release and lateral deviation recovery. The test bench cannot restore the tire to a completely consistent initial state before each target working condition begins. Tread temperature, ground contact mark, material hysteresis and slip residue will be carried into the next working condition with the previous working condition. In this situation, simply merging or removing duplicate operating conditions based on the target parameters will mistakenly identify records with "same parameters but different outputs" in the actual measurements as redundant or abnormal samples. This results in the cloud-generated data covering the parameter table, but during bench retesting, the lateral force, return torque, ground pressure, and temperature response repeatedly fail to correspond under the same speed, load, and side slip angle. The root cause is that the target parameters do not record the tire's historical state before entering the current operating condition. The technical problem to be solved by this application is: how to identify the historical state of the tire based on the output differences of repeated working conditions during the batch generation of multi-condition simulation data on a tire testing bench, and generate simulation data with different historical state sources under the same target working condition. Summary of the Invention

[0003] To overcome the aforementioned deficiencies in the prior art, embodiments of the present invention provide a method and system for batch generation of multi-condition simulation data for tire testing benches. This method converts bench commands into target condition words and extracts pre-entry response sequences, identifies pre-entry state changes under the same target condition, generates hidden state particles and writes them into the initial conditions of tire simulation, and then batch executes multi-state simulation tasks in an industrial cloud computing environment to solve the problems mentioned in the background art.

[0004] To achieve the above objectives, the present invention provides the following technical solution: a method for batch generation of multi-condition simulation data for tire testing benches, comprising: S1. Obtain historical test records and target simulation parameter table. Read bench command frames and bench response frames according to sampling time. Concatenate bench command frames into target operating condition words in ascending order of channel address. Use the target operating condition word change bit as the target entry bit. Extract bench response frames forward to form a pre-entry response sequence and write it into the historical operating condition record table. S2. Merge the historical working condition record table with the target working condition word, perform wild binary segmentation change point detection on the response sequence before the same word enters, generate candidate sub-intervals according to the sampling position, screen out wild sub-intervals according to the hash remainder between the target working condition word and the interval endpoints, calculate the mean square difference gain of the left and right segments bit by bit, and take the first gain as the candidate change bit. S3. The difference between the lengths of the front and back segmented codes is used as the description length reduction. Positive values ​​retain candidate change bits and recursively segment, while non-positive values ​​stop, generating a table of change bits to be entered before the change. S4. Divide the pre-entry response sequence according to the pre-entry change position table, and generate hidden state particles from the first and last response values ​​of the segment, the number of samples, and the difference between the first and last responses. S5. Perform the sequential Monte Carlo algorithm on the hidden state particles, copy the particles in the order of segmentation, calculate the particle likelihood weight with the same word platform response frame co-position difference value, normalize and resample according to the cumulative distribution to generate the hidden state particle table. S6. Generate the target working condition word to be simulated from the target simulation parameter table, match it with the hidden state particle table, write the matching particles into the initial conditions of tire simulation for design optimization, verification or simulation, and generate a multi-state simulation task table. S7. Read the multi-state simulation task table in the industrial cloud computing environment, generate a sorting word for computational load by multiplying the number of changed positions before entry, the number of hidden state particles, and the number of simulation steps, enqueue them in descending order, and assign them to the central processing unit that ranks first in ascending order of cumulative computational load to execute the simulation, and output the multi-condition simulation dataset.

[0005] In a preferred embodiment, S1 includes: S11. Obtain historical test records and target simulation parameter table. Read the channel address bit width and channel quantization step size from the target simulation parameter table. Convert the channel sampled values ​​in the bench command frame into channel integer values ​​according to the channel quantization step size. Then, concatenate the channel address bit width and channel integer values ​​to generate channel segments. S12. Arrange the channel segments at the same sampling time in ascending order of channel address, concatenate the first and last channels of the arranged channel segments to generate the target operating condition word, and perform bitwise XOR on the target operating condition words of adjacent sampling times to generate the target operating condition change word. S13. Read the non-zero bit number of the target working condition change word, write the sampling time corresponding to the first non-zero bit number as the target entry bit, and extract the bench response frame from the target entry bit to the sampling time after the previous target entry bit. Generate the pre-entry response sequence in ascending order of sampling time and write it into the historical working condition record table.

[0006] In a preferred embodiment, S2 includes: S21. Read the same word from the historical working condition record table with the target working condition word and enter the previous response sequence. Subtract the previous sampling bit response value from the next sampling bit response value to generate a response difference word. Perform fixed-length concatenation on the response difference words of the same sampling bit in ascending order of channel address to generate the same word difference string. S22. Perform the wild binary segmentation change point detection algorithm on the same word difference string. Calculate the segment length using the first and last position numbers of the current segment to be segmented. Concatenate the target condition word with the first and last position numbers and take the modulo to obtain the left offset position. Concatenate the target condition word with the last position number and take the modulo to obtain the right offset position. Extract wild sub-intervals within the current segment to be segmented according to the left and right offset positions. S23. Set segmentation bits bit by bit in the wild sub-interval. Generate a mean difference word by using the mean of the difference string on the left and the mean of the difference string on the right of the segmentation bit. Generate a balancing weight by dividing the product of the number of samples on the left and right sides by the number of samples in the wild sub-interval. Then, multiply the sum of the squares of the mean difference word by the balancing weight to generate a segmentation gain word.

[0007] In a preferred embodiment, S2 further includes: S24. Read the first segmentation bit in descending order of the segmentation gain word, take the first segmentation bit as the sub-interval change bit, divide the current segment to be divided by the sub-interval change bit, calculate the residual fixed-point coding length before division and the residual fixed-point coding length after division respectively, and subtract the change bit code length from the difference between the two to generate the coding reduction amount. S25. When the encoding reduction is positive, retain the sub-interval change bits and continue to use the segments on both sides of the sub-interval change bits as segments to be segmented to execute S22 to S24; when the encoding reduction is not positive, stop the segmentation of the current segment to be segmented and write the retained sub-interval change bits into the entry change bit table in ascending order of sampling bits.

[0008] In a preferred embodiment, S3 includes: S31. Read the candidate change bit and the response segment where the candidate change bit is located. Connect the first and last sampled values ​​of the response segment to form the segment baseline. Subtract the corresponding value of the segment baseline from each sampled value in the response segment to generate an unsegmented residual string. Generate the unsegmented coding length according to the fixed-point coding bit number of the unsegmented residual string. S32. Divide the response segment into a left response segment and a right response segment based on the candidate change bits. Generate the left residual string and the right residual string in the same way as in S31. Add the encoding length of the left residual string, the encoding length of the right residual string, and the encoding length of the candidate change bit number to generate the segmentation encoding length. S33. Subtract the segmented coding length from the unsegmented coding length to generate the description length reduction. When the description length reduction is positive, retain the candidate change bits and continue to segment the corresponding response segments. When the description length reduction is non-positive, stop segmenting the corresponding response segments and output the pre-entry change bit table for tire simulation state boundary identification in ascending order of sampled bits.

[0009] In a preferred embodiment, S4 includes: S41. Read the pre-entry change bit table and the pre-entry response sequence, write the first bit number of the pre-entry response sequence to the first bit of the segmentation boundary string, write the sampling bits in the pre-entry change bit table to the middle bit of the segmentation boundary string in ascending order, write the last bit number of the pre-entry response sequence to the last bit of the segmentation boundary string, and generate a response segmentation segment with the sampling frames between adjacent boundary bit numbers. S42. Perform intra-segment state coding for each response segment, read the first and last response values ​​of the response segment, subtract the first response value from the last response value to generate the first and last response difference, write the rising response direction word if the first and last response difference is greater than zero, write the hold response direction word if the first and last response difference is equal to zero, write the falling response direction word if the first and last response difference is less than zero, and generate the continuous sampling number by subtracting the first number from the last position number of the response segment and adding one. S43. Concatenate the response direction word, continuous sampling number and the difference between the first and last responses according to the response segmentation order to generate segment state words, and concatenate the segment state words under the same pre-entry response sequence end to end in segment order to generate hidden state particles for tire simulation initial state recognition.

[0010] In a preferred embodiment, S5 includes: S51. Read the hidden state particle table and the pre-entry change bit table, convert the segment state word of each hidden state particle into a particle state vector, where the response direction word is written as rising to 1, remaining to 0, and falling back to negative 1 in the first position, the continuous sampling number is written as a binary bit length in the middle position, the last response difference word is written as a fixed-point integer in the last position, and the initial weight of each particle is written as the reciprocal of the total number of particles. S52. Execute the sequential Monte Carlo algorithm according to the sampling order of the entry into the change position table. Read the particle state vector of the previous round and the current segment state vector in the current segment. Use the current segment state vector to subtract the particle state vector of the previous round to generate the state transition difference vector. Use the particle state vector of the previous round plus the state transition difference vector to generate the predicted particle state vector. S53. Restore the last part of the predicted particle state vector to the predicted response difference word, read the actual response difference word of the same word test frame in the current segment, subtract the predicted response difference word from the actual response difference word to generate the observation residual word, and add one to the median of the absolute value of the observation residual word to generate the robust scale word. S54. Divide the observed residual word by the robust scale word to generate the standard residual word. Use the current number of samples in the segment as the student t-distribution degrees of freedom to calculate the particle likelihood value. Multiply the particle likelihood value by the weight of the previous round to generate the unnormalized weight. Then divide the unnormalized weight by the sum of the weights in this round to generate the posterior weight. S55. Perform system resampling based on the cumulative distribution of a posteriori weights. The starting sampling position is generated by dividing the remainder of the target condition word hash by the total number of particles. The interval between adjacent sampling positions is the reciprocal of the total number of particles. Copy the corresponding particles according to the cumulative distribution position where the sampling position falls, until the pre-change position table is read completely, and generate the hidden state particle table.

[0011] In a preferred embodiment, S6 includes: S61. Read the target simulation parameter table, divide the value of each channel by the corresponding quantization step size and round it to generate the integer value of the channel to be simulated, concatenate the integer values ​​of the channel to be simulated in ascending order of channel address to generate the target working condition word to be simulated, and use the target working condition word to retrieve the hidden state particle table to generate the particle working condition item. S62. Read the hidden state particles in the particle working condition item, convert the response direction word of the hidden state particles into sign bits, convert the continuous sampling number into state hold bits, convert the last response difference word into state correction bits, and write the sign bit, state hold bits and state correction bits in sequence according to the state slot address in the tire simulation template to generate the initial conditions of particle-based tire simulation. S63. Perform single-step simulation verification based on the initial conditions of particle-based tire simulation. Generate a verification response difference word from the single-step simulation output according to the channel quantization rules of S1. Subtract the last response difference word of the hidden state particle from the verification response difference word to generate a verification residual word. When the verification residual word is zero, write the initial conditions of particle-based tire simulation into the multi-state simulation task table. When the verification residual word is not zero, write the verification residual word back to the state correction bit and repeat the single-step simulation verification. Stop when the number of repetitions is equal to the number of segment state words of the hidden state particle.

[0012] In a preferred embodiment, S7 includes: S71. In the industrial cloud computing environment, read the multi-state simulation task table, read the change bit count corresponding to the target working condition word to be simulated in the change bit table before entering each simulation task, read the particle count corresponding to the target working condition word to be simulated in the hidden state particle table, read the step count in the tire simulation template, and multiply the change bit count, particle count and step count to generate the computational quantity sorting word, and write it into the simulation task queue in descending order of the computational quantity sorting word. S72. Read the allocated computing power and completed computing power of each central processing unit, subtract the completed computing power from the allocated computing power to generate the unit occupancy, sort the unit occupancy in ascending order, and assign the first task of the simulation task queue to the central processing unit with the first unit occupancy in ascending order. At the same time, add the computing power sort word to the allocated computing power of the corresponding central processing unit. S73. The central processing unit executes the simulation task and outputs the simulation result frame. It concatenates the target working condition word to be simulated and the hidden state particles to generate the result index word. It performs rolling hashing on the simulation result frame according to the sampling bit order to generate the result check word. When the result check words under the same result index word are consistent, they are written into the multi-working condition simulation dataset. When they are inconsistent, the corresponding simulation task is returned to the simulation task queue.

[0013] A batch generation system for multi-condition simulation data of a tire testing bench, comprising a data acquisition and character formation module, a change point filtering module, an encoding and retention module, a state granulation module, a particle update module, a simulation table building module, and a cloud scheduling module: The data acquisition module is used to acquire historical test records and target simulation parameter tables. It reads bench command frames and bench response frames according to the sampling time, concatenates the bench command frames into target operating condition words in ascending order of channel address, uses the change bit of the target operating condition word as the target entry bit, intercepts the bench response frame to form the pre-entry response sequence, and writes it into the historical operating condition record table. The change point filtering module is used to merge the historical working condition record table with the target working condition word, perform wild binary segmentation change point detection on the response sequence before the same word enters, generate candidate sub-intervals according to the sampling position, filter out wild sub-intervals according to the hash remainder between the target working condition word and the interval endpoints, calculate the mean square difference gain of the left and right segments bit by bit, and take the first gain as the candidate change position. The encoding retention module is used to describe the length reduction by the difference between the previous and subsequent segmented encoding lengths. Positive values ​​retain candidate change bits and recursively segment, while non-positive values ​​stop the process and generate a table of change bits to be entered before the change. The state granulation module is used to segment the pre-entry response sequence according to the pre-entry change position table, and generate hidden state particles from the first and last response values ​​of the segment, the number of samples, and the difference between the first and last responses. The particle update module is used to perform the sequential Monte Carlo algorithm on the hidden state particles, copy the particles in the order of segmentation, calculate the particle likelihood weight with the same word platform response frame co-position difference value, normalize and resample according to the cumulative distribution to generate the hidden state particle table. The simulation table building module is used to generate the target working condition word to be simulated from the target simulation parameter table, match it with the hidden state particle table, write the matching particles into the initial conditions of tire simulation for design optimization, verification or simulation, and generate a multi-state simulation task table. The cloud scheduling module is used to read the multi-state simulation task table in the industrial cloud computing environment, generate a sorting word for the computational load by multiplying the number of changed positions before entry, the number of hidden state particles, and the number of simulation steps, enqueue them in descending order, and assign them to the central processing unit that ranks first in the ascending order of cumulative computational load to execute the simulation, and output a multi-condition simulation dataset.

[0014] The technical effects and advantages of this invention are as follows: This scheme preserves the process of entering the working condition by using the target working condition word and the response sequence before entering the working condition, and then generates hidden state particles to distinguish different historical states under the same target parameters, thereby mitigating the distortion of simulation data caused by the accidental deletion of repeated working conditions. By detecting and locating the transition point before the response enters through wild binary segmentation, and verifying the change bit by reducing the amount of coding length reduction, the situation of local fluctuations entering the state boundary is reduced, thereby improving the effectiveness of response segmentation; The response segments are encoded as hidden state particles, and the direction, duration and response difference are written into the state expression, so that the tire temperature rise, load residue and side slip recovery process can participate in the construction of the simulation initial conditions. Sequential Monte Carlo updates are performed on the hidden state particles, and the particle weights are adjusted according to the actual bench response, so that the historical state source that is closer to the measured response is preserved, thus improving the state matching. After writing the initial particle conditions, a single-step simulation verification is performed, and the state correction bits are corrected according to the verification residuals to reduce the risk that the hidden state writing does not correspond to the simulation response. Attached Figure Description

[0015] Figure 1 This is a flowchart outlining the method steps of the present invention; Figure 2 This is a schematic diagram of the system module structure of the present invention. Detailed Implementation

[0016] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0017] Refer to the instruction manual appendix Figure 1-2 The method for batch generation of multi-condition simulation data for tire testing benches of the present invention includes: S1. Obtain historical test records and target simulation parameter table. Read bench command frames and bench response frames according to sampling time. Assemble the bench command frames into target operating condition words in ascending order of channel address. Use the target operating condition word change bit as the target entry bit. Extract bench response frames forward to form the pre-entry response sequence and write it into the historical operating condition record table. In this embodiment, S1 is used to convert the bench command frame in the historical test record into a fixed-length target condition word, and determine the sampling time after the target condition word changes as the target entry position. Then, the bench response frame is intercepted in reverse according to the target entry position to form a pre-entry response sequence for subsequent change point detection and reading. This implementation process includes the following steps: S11 is used to convert bench command frames into channel segments; the inputs are historical test records and target simulation parameter tables. The historical test records save bench command frames and bench response frames according to the sampling time. The bench command frame includes at least the channel address and the channel sample value, and the bench response frame includes at least the response channel address and the response sample value. The target simulation parameter table should include at least the channel address bit width, channel integer value bit width, channel quantization step size, and channel symbol marker; During processing, the bench command frame and bench response frame are read according to the sampling time. If any frame is missing, the sampling time is written into the missing frame record and the sampling time is stopped to proceed to the subsequent processing. Then, the channel sampling value in the bench command frame is read, the channel sampling value is divided by the same channel quantization step size and rounded to zero to obtain the channel integer value. When the channel symbol is marked as signed and the channel sample value is less than zero, a negative sign is written at the beginning of the channel integer value, and the absolute value is written in the remaining bits; when the channel integer value exceeds the channel integer value bit width, the boundary value that the channel integer value bit width can represent is written, and a quantization out-of-bounds record is written simultaneously. Finally, the channel address is written into an address fragment according to the channel address bit width, and the channel integer value is written into a numerical fragment according to the channel integer value bit width. The address fragment and the numerical fragment are concatenated end to end, and the channel fragment is output for S12 to read. S12 is used to transform channel segments at the same sampling time into target condition words, and to obtain target condition change words from target condition words at adjacent sampling times; the input is the channel segments generated by S11. During processing, channel segments are collected according to the sampling time. First, the address segment in each channel segment is read. Then, the channel segments are arranged from low to high according to the channel address represented by the address segment. After arrangement, the channel segments are concatenated end to end to generate the target operating condition word for that sampling time. Then, read the target operating condition word at the previous sampling time and the target operating condition word at the next sampling time, and perform an XOR operation bit by bit. When all bits of the XOR result are zero, no target operating condition change word is generated. When the XOR result contains a non-zero bit, write the XOR result as the target operating condition change word and write the non-zero bit number as the change channel bit number; If the target operating condition word lengths are not equal, the target operating condition word is re-split according to the channel address bit width and channel integer value bit width in the target simulation parameter table; if there are still sampling moments with unequal lengths after splitting, an operating condition word abnormal record is written, and the sampling moment is stopped and S13 is entered. S13 is used to convert the target operating condition change word into the target entry word and extract the response sequence before entry; the input is the target operating condition word generated by S12, the target operating condition change word, and the bench response frame in the historical test record; During processing, the target operating condition change word is read in the order of sampling time. When there is a non-zero bit in the target operating condition change word, the next sampling time corresponding to the generation of the target operating condition change word is written as the target entry bit. The non-zero bit number in the target operating condition change word is only written as the change channel bit number. Then read the bench response frames backward from the target entry position until the sampling time after the previous target entry position, and encapsulate them into a pre-entry response sequence in ascending order of sampling time; If there is no previous target entry position before the target entry position, the sampling starts from the first sampling moment in the historical test record that simultaneously has a test command frame and a test response frame; When there is only one valid sampling moment between two adjacent target entry positions, a single-frame pre-entry response sequence is generated and a short sequence marker is written. The short sequence marker is used for subsequent change point detection to stop recursive segmentation. Finally, the target condition word, target entry position, change channel number, pre-entry response sequence, short sequence marker, missing frame record, and quantization out-of-bounds record are written into the historical condition record table. Through the above implementation method, the bench command frame is converted into a target working condition word with a fixed disassembly method, the change of the target working condition word is converted into a target entry bit, the bench response frame is extracted into a pre-entry response sequence, and the historical working condition record table simultaneously saves the source of the anomaly, so that subsequent steps can read data in the same format according to the target working condition word. In practical applications: When the tire test bench switches from low-speed rolling to braking and lateral deviation conditions, the channel segments of the braking channel and the lateral deviation channel change at the next sampling time. After bitwise XOR, the target condition change word is generated, and the next sampling time is written as the target entry position. The system forward intercepts the bench response frames between the sampling time after the previous target entry position and the current target entry position, forming a pre-entry response sequence that records the temperature rise, residual load, and lateral deviation recovery process before brake establishment.

[0018] S2. Merge the historical working condition record table with the target working condition word, perform wild binary segmentation change point detection on the response sequence before the same word enters, generate candidate sub-intervals according to the sampling position, screen out wild sub-intervals according to the hash remainder between the target working condition word and the interval endpoints, calculate the mean square difference gain of the left and right segments bit by bit, and take the first gain as the candidate change bit. In this embodiment, S2 is used to find the state transition sampling bit in the pre-entry response sequence of the same target condition word and belonging to the same tire test object. The processing first converts the pre-entry response sequence into a signed fixed-point difference expression, then generates wild sub-intervals from the target condition word and the endpoints of the current segment to be segmented, then uses the segmentation gain word to locate candidate change bits, and uses the residual coding reduction amount to determine whether the candidate change bits are written into the pre-entry change bit table; this implementation process includes the following steps: S21 is used to generate a differential string with the same word and limit the reading range of the differential string with the same word; the input is the target condition word in the historical condition record table, the tire test object identifier, the test batch number, and the pre-entry response sequence; During processing, first read the pre-entry response sequence according to the target working condition word and the tire test object identifier. Pre-entry response sequences with different test batch numbers are not merged into the same word difference string. Then, read the bench response frame in the pre-entry response sequence in ascending order of sampling bits, and generate the response difference word by subtracting the response value of the previous sampling bit from the response value of the next sampling bit. The response differential word uses a signed fixed-point integer. The first bit is written with the sign, and the remaining bits are written with the absolute value. When the absolute value exceeds the response differential bit width, the boundary value corresponding to the response differential bit width is written, and a differential out-of-bounds record is written. When there are multiple response channels for the same sampling bit, the response differential word is first read in ascending order of channel address, and then fixed-length concatenation is performed according to the response differential bit width to generate the differential frame of that sampling bit; all differential frames are concatenated end to end in ascending order of sampling bits to generate a differential string with the same word for S22 to read; when there is only one sampling bit in the previous response sequence, a short sequence marker is written and entry into S22 is stopped. S22 is used to generate wild sub-intervals and handle endpoint exceptions; the input is the homonymous difference string generated by S21 and the current segment to be segmented; when executed for the first time, the current segment to be segmented is the complete homonymous difference string; when executed recursively, the current segment to be segmented is the segment to the left or right of the changed position retained in the previous round. During processing, the first and last position numbers of the current segment to be segmented are read. The segment length is obtained by subtracting the first position number from the last position number and adding one. The target condition word is concatenated with the first and last positions of the first and last positions and converted into an integer. The left offset is obtained by taking the modulo of the segment length. The right offset is obtained by concatenating the target condition word with the last position number and converting it into an integer. When the left offset is equal to the right offset, increment the right offset by one and take the modulo of the segment length again; when the left offset is greater than the right offset, swap the left and right offsets; then add the first offset to the first position to get the first position of the wild sub-interval, and add the first offset to the right offset to get the last position of the wild sub-interval; when the number of sampling bits inside the wild sub-interval is less than three, stop outputting the wild sub-interval and stop the segmentation calculation of the current segment to be segmented; when the number of sampling bits inside the wild sub-interval is not less than three, output the wild sub-interval for S23 to read. S23 is used to calculate the segmentation gain word within the wild sub-interval; the input is the wild sub-interval output by S22; during processing, the segmentation bits are enumerated starting from the first sample bit after the first bit of the wild sub-interval and ending at the last sample bit before the last bit of the wild sub-interval. For each segment, the left and right differential frames of the segment are decomposed into signed differential values ​​according to the response differential bit width; then, using the channel address as the column index, the average differential value of the left and right channels is calculated respectively, and the channel average difference word is obtained by subtracting the average differential value of the left and right channels from the average differential value of the right channel. The mean difference of all channels is squared and summed to generate the sum of squared mean differences; at the same time, the left sample number is multiplied by the right sample number and then divided by the wild child interval sample number to generate the balanced weights. Finally, the sum of squared mean differences is multiplied by the balancing weight to generate the segmentation gain word; when the segmentation gain words of multiple segmentation bits are the same, the first segmentation bit is read in ascending order of sampling bits; the segmentation gain word and the corresponding segmentation bit are written together into the segmentation gain table for S24 to read. S24 is used to convert the first segmentation bit in the segmentation gain table into an encoded retention object; the input is the segmentation gain table generated by S23 and the current segment to be segmented; during processing, the first segmentation bit is read in descending order of the segmentation gain word, the first segmentation bit is written as the sub-interval change bit, and the current segment to be segmented is split into the left segment and the right segment using the sub-interval change bit. For the current segment to be segmented before segmentation, read the first and last difference values ​​of the segment and perform linear interpolation according to the sampling bit distance to generate the segment baseline; subtract the baseline value of the same position from each difference value in the current segment to be segmented to generate the residual string before segmentation; count each residual value in the residual string by adding the absolute value binary bit length to the sign bit, write 1 when the residual value is zero, and add the bit lengths of all residual values ​​to obtain the fixed-point encoding length of the residual before segmentation; The left and right segments are segmented in the same way to generate the residual fixed-point code length after segmentation; then the residual fixed-point code length before segmentation is subtracted from the residual fixed-point code length after segmentation, and the binary bit length of the sub-interval change bit is subtracted to generate the code reduction amount, which is then read by S25. S25 is used to complete the recursive segmentation and output the entry into the pre-change bit table; the input is the code reduction amount and sub-interval change bits generated by S24; during processing, when the code reduction amount is positive, the sub-interval change bits are written to the reserved change bit buffer, and the left and right segments of the sub-interval change bits are written as the new current segments to be segmented, and S22 to S24 are continued. When the reduction in encoding is not positive, the sub-interval change bits are not written, and the recursive segmentation of the current segment to be segmented is stopped; after the recursion ends, all sub-interval change bits in the reserved change bit buffer are read and sorted in ascending order of sampled bits. When the same sampling bit is repeatedly written by different wild sub-intervals, only one sampling bit is retained, and the number of repetitions is written to the change bit source count field; the entry change bit table generated by S25 is used as the input of S3, and S3 then performs a segmentation and encoding length verification on the response segment where the candidate change bit is located. The verified entry change bit table is used by S4 to segment the entry response sequence. Through the above implementation method, S2 is not a normal binary segmentation of the pre-entry response sequence, but a process of generating change bits constrained by the target working condition word, tire test object identifier, current segment endpoint and residual code reduction amount. The sampling bits in the pre-entry change bit table correspond to both the sudden change in response differential structure and the decrease in residual code cost. In practical applications: When multiple pre-entry response sequences exist for the same tire test object under the same target working condition word, the response difference before and after braking intervention forms a segmentation gain word in the wild sub-interval; if the segmentation bit cuts the current segment to be segmented, and the length of the residual fixed-point code plus the length of the change bit code is less than the length of the residual fixed-point code before segmentation, the system writes the segmentation bit into the reserved change bit cache, and then S3 performs encoding verification on the response segment where the sampling bit is located, ultimately providing response boundaries for the generation of the segment state word of the hidden state particles.

[0019] S3. The difference between the lengths of the front and back segmented codes is used as the description length reduction. Positive values ​​retain candidate change bits and recursively segment, while non-positive values ​​stop, generating a table of change bits to be entered before the change. In this embodiment, S3 is used to perform residual coding verification on the candidate change bits output by S2. A candidate change bit is only written into the pre-change bit table if the residual coding length decreases after segmenting the response fragment, and the decrease covers the coding cost of the candidate change bit itself. The relationship between S3 and S2 is as follows: S2 first generates candidate change bits and coding reduction amounts within the wild sub-interval; S3 then generates a description length reduction amount within the complete response fragment containing the candidate change bit. When both the coding reduction amount of S2 and the description length reduction amount of S3 are positive, the candidate change bit becomes a pre-change bit. This implementation process includes the following steps: S31 is used to generate the unsegmented coding length and exclude candidate change bits with invalid endpoints; the inputs are the candidate change bits output by S2, the response segment where the candidate change bits are located, the first bit number of the response segment, the last bit number of the response segment, and the coding reduction amount in S2; During processing, first read the code reduction amount in S2. If the code reduction amount is not positive, write the candidate change bit into the record of the initial screening failure and stop the current candidate change bit review. If the code reduction amount is positive, continue to determine whether the candidate change bit is located between the first and last positions of the response segment. If the candidate change bit is equal to the first or last position of the response segment, write the candidate change bit into the endpoint invalid record and stop the current response segment review. When the candidate change position is located inside the response segment, read the first and last sampled values ​​of the response segment, subtract the first and last sampled values ​​of the response segment from the last sampled position number to obtain the segment span, and then perform linear interpolation according to the sampled position distance to generate the segment baseline co-position value for each sampled position; Then, the sampled value within the response segment is subtracted from the corresponding value of the segment baseline to generate an unsegmented residual string. The residual values ​​in the unsegmented residual string are encoded using signed fixed-point numbers, with one bit written for the sign bit and the absolute value part counted according to the binary bit length. When the residual value is zero, the absolute value binary bit length is written as one. The bits of all residual value encodings are added together to generate the unsegmented encoding length, which is then read by S32. S32 is used to generate the segmented coding length and fix the coding cost of the candidate change bit number; the input is S31 to confirm the valid candidate change bit and response segment; during processing, the candidate change bit is used as the segmentation boundary, the first bit of the response segment to the previous sample bit of the candidate change bit is truncated as the left response segment, and the candidate change bit to the last bit of the response segment is truncated as the right response segment. Neither the left nor the right response segment can be empty. If either response segment is empty, the candidate change bit will be written into the invalid segmentation record and the current response segment review will be stopped. The left response segment will be linearly interpolated based on its first and last sampled values ​​to generate the left segment baseline. The right response segment will be linearly interpolated based on its first and last sampled values ​​to generate the right segment baseline. The left residual string is generated by subtracting the left segment baseline co-position value from the left response segment sample value, and the right residual string is generated by subtracting the right segment baseline co-position value from the right response segment sample value; the encoding lengths of the left and right residual strings are calculated according to the signed fixed-point number encoding rules in S31. The candidate change bit number encoding length is generated according to the sampling bit number range of the response segment. Specifically, the number of candidate positions is obtained by subtracting the first bit number of the response segment from the last bit number and adding one. Then, the number of candidate positions is converted into binary bit length. Finally, the left residual string encoding length, the right residual string encoding length and the candidate change bit number encoding length are added to generate the segmented encoding length, which is then read by S33. S33 is used to generate the pre-entry change bit table based on the reduction in description length and to process repeated change bits; the inputs are the unsegmented coding length generated by S31, the segmented coding length generated by S32, the candidate change bits, and the response segment where the candidate change bits are located. During processing, the description length reduction is generated by subtracting the segmented coding length from the unsegmented coding length. When the description length reduction is positive, the candidate change bits are written to the reserved change bit buffer, and the left and right response fragments are continued as response fragments to be reviewed. The candidate change bits inside each fragment are read and S31 to S33 are executed. When the reduction in length is zero or negative, the candidate change bit is written to the unreserved record, and the review of the response segment containing the candidate change bit is stopped; after the review of all response segments is completed, the candidate change bits in the reserved change bit cache are read in ascending order of the sampled bits. The repeated sampled bits are only retained once, and the number of repetitions is written to the change bit source count field. Finally, a pre-entry change bit table is generated for tire simulation state boundary identification, which is used by S4 to segment the pre-entry response sequence; if the reserved change bit buffer is empty, an empty change bit mark is written, and S4 generates a single response segment according to the first and last bit numbers of the pre-entry response sequence. Through the above implementation method, S3 further restricts the candidate change bits obtained in S2 to the sampling bits that can reduce the coding cost of the response fragment residual. The coding reduction in S2 is used for the initial screening of wild sub-intervals, and the description length reduction in S3 is used for the verification of the complete response fragment. The two judgment results are connected and no longer form duplication or conflict. In practical applications: When the same tire test object transitions from rolling condition to braking lateral deviation condition, S2 may provide candidate change bits at both the braking response start position and the local noise position; S3 calculates the residual code length before and after the two candidate change bits are segmented. At the braking response start position, the residual strings of the left and right response segments are shortened, and the reduction in description length is positive, so it is written into the change bit table before entry; after the local noise position is segmented, the change bit number needs to be recorded additionally, and the residual code length does not decrease, so the reduction in description length is not positive, and it is not written into the change bit table before entry.

[0020] S4. Divide the pre-entry response sequence according to the pre-entry change position table, and generate hidden state particles from the first and last response values ​​of the segment, the number of samples, and the difference between the first and last responses. In this embodiment, S4 is used to convert the pre-entry change bit table into the segmentation boundary of the pre-entry response sequence, and compress each response segment into a segment state word, so that the residual temperature rise, residual loading, residual braking, or side slip recovery process before the tire enters the target working condition enters S5 in the form of hidden state particles; when the pre-entry change bit table is empty, the entire pre-entry response sequence forms a response segment; when the pre-entry change bit table is not empty, the pre-entry response sequence forms multiple response segments according to the sampling bit order; this implementation process includes the following steps: S41 is used to generate response segments and fix the boundary assignment method; the input quantities are the pre-entry change bit table and the pre-entry response sequence. The pre-entry response sequence includes at least the target condition word, the target entry bit, the sampling bit number, the response channel address, and the response sampling value. During processing, first read the first and last position numbers of the pre-entry response sequence, write the first position number into the first position of the segmentation boundary string, write the last position number into the last position of the segmentation boundary string, then read the sampled bits in the pre-entry change bit table, delete sampled bits that are less than the first position number or greater than the last position number, retain repeated sampled bits only once, and write them into the middle position of the segmentation boundary string in ascending order of sampled bits. When generating response segments, the previous response segment contains the left boundary bit number but not the right boundary bit number, and the last response segment contains the left boundary bit number to the tail bit number. When the previous change bit table is empty, a response segment is generated directly with the first bit number to the tail bit number. When adjacent boundary tag numbers are equal, delete the next boundary tag number and write it into the boundary duplication record. When there is no sampling frame between adjacent boundary tag numbers, write the empty segment record and do not generate a response segment. Output the response segment table. The response segment table retains the target condition word, target entry bit and segment sequence number for S42 to read. S42 is used to convert the response segments into intra-segment status codes and write the direction and values ​​according to the rules; the input is the response segment table generated by S41; during processing, the response segments are read in segment order, and the first and last response sample values ​​are read in ascending order according to the response channel address within each response segment. The first and last response difference is generated by subtracting the first response sample value from the last response sample value. When the difference between the first and last responses is greater than zero, the response direction word is written as 1; when the difference between the first and last responses is equal to zero, the response direction word is written as zero; when the difference between the first and last responses is less than zero, the response direction word is written as negative 1. The continuous sampling number is obtained by subtracting the first position number from the last position number of the response segment and then adding one. S42 stores the value of the continuous sampling number itself, and S5 reads the binary bit length of the continuous sampling number when converting the particle state vector. The first and last response difference is written using a signed fixed-point integer. When it exceeds the width of the first and last response difference field, the boundary value of that field width is written, and a state difference out-of-bounds record is generated. When there is only one sampling frame in the response segment, the first and last response sampling values ​​are taken as the same response sampling value, the first and last response difference is written as zero, the response direction word is written as zero, and the continuous sampling number is written as one. The response direction word, continuous sampling number, and first and last response difference corresponding to each response channel address are output for S43 to concatenate. S43 is used to generate hidden state particles and fix the splicing structure of segment state words; the input is the response direction word, continuous sampling number, and end-first response difference output by S42; during processing, the particle encoding configuration table is read from the target simulation parameter table or the tire simulation template. The particle encoding configuration table gives the response direction word field width, continuous sampling number segment width, end-first response difference field width, and response channel address field width. Within each response segment, the response channel address is first written according to the bit width of the response channel address field, and then the response direction word, continuous sampling number and the difference between the first and last responses under the same response channel address are written in sequence to form a channel state segment. Within the same response segment, channel state fragments are concatenated end-to-end in ascending order of response channel address to generate segment state words; segment state words under the same pre-entry response sequence are then concatenated end-to-end in segment order to generate hidden state particles. The hidden state particles are simultaneously written with the target working condition word, target entry bit, segment sequence number and particle code number for S5 to read; when any response segment lacks a response sample value, the segment state missing record written for that response segment does not participate in the hidden state particle splicing; when all response segments lack response sample values, an empty particle marker is written and entry into S5 is stopped. Through the above implementation method, the pre-entry change bit table is converted into a response segment with fixed boundary affiliation. The response segment is converted into a segment state word with direction, duration and response difference. The hidden state particles are generated by sequentially splicing the segment state words. S5 can directly read the hidden state particles and convert them into particle state vectors. In practical applications: Before the tire test bench enters the braking and lateral deviation condition, it enters the pre-change bit table to record the braking response establishment sampling bit and the lateral deviation response recovery sampling bit. The system first forms the pre-braking response segment, the post-braking response segment, and the post-lateral deviation recovery response segment. Then, it calculates the response direction word, the number of continuous samples, and the difference between the first and last responses under each response channel address. Finally, it generates hidden state particles in segment order so that subsequent sequential Monte Carlo updates can distinguish different pre-entry states under the same target condition word.

[0021] S5. Perform the sequential Monte Carlo algorithm on the hidden state particles, copy the particles in the order of segmentation, calculate the particle likelihood weight with the same word platform response frame co-position difference value, normalize and resample according to the cumulative distribution to generate the hidden state particle table. In this embodiment, S5 updates the hidden state particles generated by S4 from "segment state codes" to "hidden state particle tables with posterior weights". The processing does not directly filter a segment state word, but performs prediction, observation, weighting, and system resampling segment by segment according to the segmentation order formed by the pre-entry change bit table, so that different pre-entry state sources under the same target condition word are preserved or weakened in the bench response differences; the hidden state particles output by S4 are first written to the particle buffer to be updated, and S5 reads the particle buffer to be updated and outputs the hidden state particle table after the update is completed; this implementation process includes the following steps: S51 is used to convert the hidden state particles into particle state vectors that can be recursively derived by the sequential Monte Carlo algorithm and to determine the first round weights; the inputs are the hidden state particles output by S4, the pre-entry change bit table, the target working condition word, the tire test object identifier, and the particle code configuration table. During processing, first read the same group of hidden state particles according to the target working condition word and the tire test object identifier. Hidden state particles under different tire test object identifiers are not merged into the same particle group. Then, according to the particle coding configuration table, decompose the segment state word of each hidden state particle. The response direction word in the segment state word is written as 1 when rising, 0 when holding, and negative 1 when falling, and is written to the first and second positions of the particle state vector. The continuous sampling number in the segment state word does not change the original value. First, calculate the binary length of the continuous sampling number, and then write the binary length into the middle position of the particle state vector. The last bit of the response difference word in the segment state word is written into the last position of the particle state vector as a signed fixed-point integer. The number of particles that have completed the conversion under the same target working condition word and the same tire test object identifier is written as the total number of particles, and the initial weight of each particle is written as the reciprocal of the total number of particles; if the total number of particles is zero, an empty particle record is written, and S5 does not perform subsequent updates, which are then read by the benchmark simulation task generated by S6. S52 is used to perform prediction recursion according to the segment order corresponding to the pre-entry change bit table; the input is the particle state vector generated by S51, the pre-entry change bit table and the segment state word generated by S4; during processing, the segment order is first generated by the first digit of the pre-entry response sequence, the sampling bit in the pre-entry change bit table and the last digit of the pre-entry response sequence, and each two adjacent boundaries form a current segment. During the first update, the particle state vector of the previous round is used as the first segment of the particle state vector of the same hidden state particle. During non-first updates, the particle state vector obtained by resampling the previous round is used as the particle state vector of the previous round. The current segment state vector is obtained by converting the segment state word corresponding to the current segment according to the S51 conversion method; the state transition difference vector is generated by subtracting the previous round particle state vector from the current segment state vector; and the predicted particle state vector is generated by adding the previous round particle state vector to the state transition difference vector. If the current segment does not have a corresponding segment state word, the particle state vector from the previous round is used as the predicted particle state vector, and the segment state missing record is written; the predicted particle state vector is written to the current round prediction cache for S53 to read. S53 is used to compare the predicted particle state vector with the same-character test bench response frame and generate a robust scale word; the input is the predicted particle state vector generated by S52, the same-character test bench response frame in the historical test record table, and the current segment. During processing, the last bit of the predicted particle state vector is read and restored to the predicted response difference word according to the bit width of the last bit response difference field; then, the actual response difference word of the current segment is read from the same-word test frame response frame. The actual response difference word is generated by subtracting the response value of the previous sample bit from the response value of the next sample bit. The sign and fixed-point bit width follow the response difference word rules in S2; the observation residual word is generated by subtracting the predicted response difference word from the actual response difference word. When the observation residual word contains multiple sampling bits, the absolute values ​​of the observation residual words are arranged in ascending order of sampling bits, and the middle value is taken as the median. When the number of sampling bits is even, the sum of the two middle values ​​is divided by two to obtain the median. The robust scale word is generated by adding one to the median. When there is only one observation residual word in the current segment, the robust scale word is the absolute value of the observation residual word plus one. When the same word is missing from the test response frame, a missing observation mark is written, the observation residual word is written as zero, and the robust scale word is written as one, so that S54 can process it as a missing observation. S54 is used to calculate the posterior weights of particles based on the observation residual words and to handle weight anomalies. The inputs are the observation residual words generated by S53, the robust scaling word, the number of samples in the current segment, and the weights from the previous round. During processing, the observation residual words are first divided by the robust scaling word to generate the standard residual words. The number of samples in the current segment is written as the student t-distribution degrees of freedom, and if the student t-distribution degrees of freedom are less than one, one is written. When calculating the particle likelihood value, the standard residual word is substituted into the student t-distribution density bit by bit and the log likelihood is accumulated. To prevent numerical underflow, the log likelihood of all particles in the current round is read first, and the first sorted value in the current round is subtracted from each log likelihood. Then the exponent is taken to obtain the particle likelihood value. The unnormalized weight is generated by multiplying the particle likelihood value by the weight of the previous round, and then the unnormalized weight is divided by the sum of the weights of the current round to generate the posterior weight. When the sum of the weights of the current round is zero, the posterior weight of all particles in the current round is written as the reciprocal of the total number of particles. When there are missing observation markers in S53, the particle likelihood value is written as 1, so that the posterior weight of the current round only inherits the weight of the previous round. S55 is used to perform system resampling according to the posterior weights and output the hidden state particle table; the inputs are the posterior weights generated by S54, the target working condition word and the total number of particles; during processing, the posterior weights are accumulated in the order of particles to generate a cumulative distribution. When the last digit of the cumulative distribution is not equal to one, the cumulative distribution is regenerated by dividing each cumulative value by the last digit of the cumulative distribution. Hash the target condition word to obtain a hash integer, divide the hash integer by the hash modulus to obtain a hash fraction between zero and one, and then divide the hash fraction by the total number of particles to generate the starting sampling bit. The interval between adjacent sampling bits is the reciprocal of the total number of particles. When each sampling position falls into the cumulative distribution, the particle at the corresponding position is copied. If the sampling position exceeds one, the number of sampling positions is reduced by one and the particle continues to fall into the cumulative distribution. The copied particles are written into the target working condition word, tire test object identifier, segment sequence number, posterior weight and source particle number. Copied particles with the same source particle number are merged and written into the copy number. After each current segment is completed, the resampled particles are read as the previous round particles for the next segment, until all segments corresponding to the previous change bit table are processed and a hidden state particle table is generated. The hidden state particle table is indexed by the target working condition word, the tire test object identifier and the source particle number, so that S6 can match the target working condition word to be simulated. Through the above implementation method, S5 transforms the hidden state particles obtained in S4 into a hidden state particle table with posterior weights segment by segment. The prediction process uses segment state words, the observation process uses the same word platform response frame, the weighting process uses the student t-distribution likelihood and robust scale word, and the resampling process uses the system sampling bits obtained by the target condition word hash. The entire update process can obtain the same output under the same input. In practical applications: Before the same tire test object enters the braking and lateral deviation condition, there are residual particles in the hidden state before braking establishment, residual particles after braking release, and residual particles after lateral deviation recovery. S5 converts the segment state word into the predicted response difference word in each segment, and then uses the actual response difference word to calculate the observation residual word. When the residual particle before braking establishment is close to the actual response difference word, the corresponding particle gets a higher posterior weight and the number of replications is increased in the system resampling. The number of replications of particles that deviate from the actual response difference word is reduced. The final output hidden state particle table is used by S6 to write the initial conditions of the tire simulation.

[0022] S6. Generate the target working condition word to be simulated from the target simulation parameter table, match it with the hidden state particle table, write the matching particles into the initial conditions of tire simulation for design optimization, verification or simulation, and generate a multi-state simulation task table. In this embodiment, S6 is used to convert the target simulation parameter table into the target working condition word to be simulated, and write the hidden state particle table output by S5 into the initial state slot of the tire simulation template, so that the same target working condition word to be simulated can form a baseline simulation task and a particle-based simulation task; S6 also verifies the correction state bit through single-step simulation, and writes it into the multi-state simulation task table only after verifying that the residual word is zero; the implementation process includes the following steps: S61 is used to generate the target operating condition word to be simulated and retrieve the hidden state particle table; the inputs are the target simulation parameter table, the hidden state particle table and the channel quantization rule used by S1; the target simulation parameter table includes at least the channel address, channel value, channel quantization step size, channel integer value bit width and channel symbol mark; During processing, the channel value in the target simulation parameter table is read according to the channel address. The channel value is divided by the quantization step size of the same channel and rounded to zero to generate the integer value of the channel to be simulated. When the channel sign is signed and the channel value is less than zero, the negative sign is written to the first bit of the integer value of the channel to be simulated, and the remaining bits are written to the absolute value. When the integer value of the channel to be simulated exceeds the channel integer value bit width, the boundary value that the channel integer value bit width can represent is written, and a quantization out-of-bounds record to be simulated is generated; then the integer values ​​of the channel to be simulated are concatenated in ascending order of channel address to generate the target condition word to be simulated; then the hidden state particle table is searched with the target condition word to be simulated, and when the target condition word in the hidden state particle table is exactly the same as the target condition word to be simulated, a hit particle is generated. When a hit particle exists, the target condition word to be simulated, the hit particle, and the particle code number are bound into a particle condition item; when no hit particle exists, a baseline particle condition item is generated and a no-hidden-state flag is written for S62 to read. S62 is used to convert the particle working condition into the initial conditions of the tire simulation; the inputs are the particle working condition generated by S61, the tire simulation template, and the initial state slot table; the initial state slot table is given by the tire simulation template and records the response direction slot address, state holding slot address, state correction slot address, and slot value bit width; During processing, the hit particles in the particle condition item are read, and the response direction word, continuous sampling number, and last response difference word are extracted according to the segment status word width. The response direction word is written as 1 when rising, 0 when holding, and negative 1 when falling, generating a sign bit. The continuous sampling number is written as the value itself into the status holding bit, without being converted to binary bit length in S62. The last response difference word is written as a signed fixed-point integer into the status correction bit. When the sign bit, state hold bit, and state correction bit exceed the corresponding slot value width, write the boundary value that the slot value width can represent and generate a slot value out-of-bounds record; then, according to the slot address in the initial state slot table, write the sign bit into the response direction slot, write the state hold bit into the state hold slot, and write the state correction bit into the state correction slot to generate the initial conditions for particle-based tire simulation. When the particle condition item has no hidden state flag, the response direction slot is written to zero, the state holding slot is written to one, the state correction slot is written to zero, the baseline tire simulation initial conditions are generated, and the baseline tire simulation initial conditions are also written to the initial conditions cache to be verified. S63 is used to perform single-step simulation verification and determine whether to write to the multi-state simulation task table; the inputs are the particle-based tire simulation initial conditions generated by S62, the baseline tire simulation initial conditions, the target working condition word to be simulated, and the hit particles. During processing, a simulation step is executed according to the simulation step size in the tire simulation template to obtain the single-step simulation output; then, the single-step simulation output is converted into a verification response differential word according to the channel quantization step size of S1. The sign and bit width of the verification response differential word follow the channel integer value rules in S1; the verification residual word is generated by subtracting the last response difference word of the hit particle from the verification response differential word. When the residual word is zero, the target working condition word to be simulated, the hit particle code, the initial conditions of particleized tire simulation and the simulation task number are written into the multi-state simulation task table. The write key uses the target working condition word to be simulated, the hit particle code and the simulation task number. When the verification residual word is not zero, the state correction slot is rewritten by subtracting the verification residual word from the state correction bit, and the single-step simulation verification is repeated. When the number of repetitions equals the number of segment state words of the hit particle, and the verification residual word is still not zero, the hit particle and the final verification residual word are written to the verification failure record, but not to the multi-state simulation task table. When the particle working condition item has no hidden state flag, the verification residual word comparison is not performed. Instead, the target working condition word to be simulated, the initial conditions of the benchmark tire simulation, and the benchmark task number are directly written into the multi-state simulation task table. Through the above implementation method, S6 converts the parameters to be simulated in the target simulation parameter table into the target working condition word to be simulated, and then retrieves the hidden state particle table according to the target working condition word to be simulated; when there is a hit particle, the hit particle is written into the initial state slot of the tire simulation template, and after single-step simulation verification, it is written into the multi-state simulation task table; when there is no hit particle, the baseline tire simulation initial conditions are generated and written into the multi-state simulation task table. In practical applications: When the target working condition word to be simulated corresponds to the braking side slip working condition, if there are residual particles before braking establishment and residual particles after side slip recovery in the hidden state particle table, the system writes the segment state words of the two hit particles into the initial state slot, and verifies the correction state slot through single-step simulation; after verifying that the residual word is zero, the two hit particles form two particle-based simulation tasks, so that the same braking side slip working condition has different pre-entry state sources when simulated in the industrial cloud.

[0023] S7. Read the multi-state simulation task table in the industrial cloud computing environment, generate a computational load sorting word by the product of the number of changed positions before entry, the number of hidden state particles and the number of simulation steps, enqueue it in descending order, and assign it to the central processing unit with the first position in ascending order of cumulative computational load to execute the simulation, and output the multi-condition simulation dataset. In this implementation, S7 is used to execute a multi-state simulation task table in an industrial cloud computing environment. Simulation tasks corresponding to different target conditions and hidden state particles are entered into the simulation task queue according to their computational load sorting words, and are allocated for execution based on the current occupancy of the central processing unit. After simulation, the result index and result verification words determine whether the simulation result frame is written to the multi-condition simulation dataset or returned to the simulation task queue. This implementation process includes the following steps: S71 is used to generate a simulation task queue; the inputs are a multi-state simulation task table, a pre-entry change bit table, a hidden state particle table, and a tire simulation template; during processing, the multi-state simulation task table is read item by item in the industrial cloud computing environment, the target working condition word to be simulated is read for each simulation task, and the number of pre-entry change bits corresponding to the target working condition word to be simulated is read from the pre-entry change bit table to generate a change bit count. Read the number of hidden state particles corresponding to the target working condition word to be simulated from the hidden state particle table to generate a particle count; read the number of simulation steps corresponding to the simulation task from the tire simulation template to generate a step count; When the change bit count, particle count, or step size count is zero, the corresponding count is written to participate in the product and a zero count mark is generated; then the change bit count, particle count, and step size count are multiplied to generate a computational load sorting word; all simulation tasks are arranged in descending order according to the computational load sorting word, and when the computational load sorting words are the same, they are arranged in ascending order according to the target working condition word to be simulated, and then in ascending order according to the hidden state particle code to generate a simulation task queue for S72 to read; S72 is used to allocate simulation tasks to the central processing unit; the input is the simulation task queue and central processing unit running record generated by S71; during processing, the allocated computing power and the completed computing power of each central processing unit are read, and the unit occupancy is generated by subtracting the completed computing power from the allocated computing power. Arrange the central processing units in ascending order of unit occupancy, and if the unit occupancy is the same, arrange them in ascending order of central processing unit number; read the first task in the simulation task queue and assign the first task to the central processing unit with the highest unit occupancy in ascending order. After the task allocation is completed, the computational workload sorting word of the first task is added to the allocated computational workload of the corresponding central processing unit, and the first task is deleted from the simulation task queue. After the central processing unit completes the simulation task, it adds the computational load of the simulation task to the completed computational load of the corresponding central processing unit; if the central processing unit's running record is missing, it writes both the allocated computational load and the completed computational load of the central processing unit to zero before participating in the sorting. S73 is used to write multi-condition simulation datasets and handle inconsistent results; the inputs are the simulation result frame output by the central processing unit, the target condition word to be simulated, and the hidden state particles; during processing, the central processing unit executes simulation tasks for design optimization, verification, or simulation, and outputs simulation result frames; the system generates result index words by concatenating the target condition word to be simulated, the hidden state particle code, and the simulation task number. Then, the simulation result frame is read in the order of sampling bits. The previous hash value is multiplied by the rolling base and then added to the current sampling bit result value. The remainder of the hash modulus is then taken to generate the result verification word. When the same result index word appears for the first time, the simulation result frame and the result check word are written to the simulation result cache; when the same result index word appears again, the current result check word is compared with the result check word in the simulation result cache. When the two are consistent, the simulation result frame is written to the multi-condition simulation dataset; when the two are inconsistent, the corresponding simulation task is returned to the simulation task queue and the verification conflict count is incremented by one; when the verification conflict count reaches the number of central processing units, the return of the simulation task is stopped and the result index is written to the simulation exception record. Through the above implementation method, S7 converts the multi-state simulation task table into a simulation task queue organized by the computational load sorting word, and allocates tasks according to the unit occupancy of the central processing unit. The simulation result frame is written into the multi-condition simulation dataset through the result index word and the result verification word. In practical applications: When the braking side slip condition corresponds to multiple hidden state particles, the system will generate a simulation task for each hidden state particle and generate a computational load sorting word based on the number of changed positions before entry, the number of hidden state particles, and the number of simulation steps. The simulation task with the higher computational load sorting word will enter the queue first and then be assigned to the central processing unit with the lower unit occupancy for execution. After the simulation is completed, if the result check words under the same result index word are consistent, the simulation result frame is written to the multi-condition simulation dataset. If the result check words are inconsistent, the simulation task is returned to the queue for re-execution.

[0024] Furthermore, the present invention also includes a batch generation system for multi-condition simulation data of a tire testing bench, the system comprising a data acquisition and character formation module, a variable point filtering module, an encoding and retention module, a state granulation module, a particle update module, a simulation table building module, and a cloud scheduling module: The data acquisition module is used to acquire historical test records and target simulation parameter tables. It reads bench command frames and bench response frames according to the sampling time, concatenates the bench command frames into target operating condition words in ascending order of channel address, uses the change bit of the target operating condition word as the target entry bit, intercepts the bench response frame to form the pre-entry response sequence, and writes it into the historical operating condition record table. The change point filtering module is used to merge the historical working condition record table with the target working condition word, perform wild binary segmentation change point detection on the response sequence before the same word enters, generate candidate sub-intervals according to the sampling position, filter out wild sub-intervals according to the hash remainder between the target working condition word and the interval endpoints, calculate the mean square difference gain of the left and right segments bit by bit, and take the first gain as the candidate change position. The encoding retention module is used to describe the length reduction by the difference between the previous and subsequent segmented encoding lengths. Positive values ​​retain candidate change bits and recursively segment, while non-positive values ​​stop the process and generate a table of change bits to be entered before the change. The state granulation module is used to segment the pre-entry response sequence according to the pre-entry change position table, and generate hidden state particles from the first and last response values ​​of the segment, the number of samples, and the difference between the first and last responses. The particle update module is used to perform the sequential Monte Carlo algorithm on the hidden state particles, copy the particles in the order of segmentation, calculate the particle likelihood weight with the same word platform response frame co-position difference value, normalize and resample according to the cumulative distribution to generate the hidden state particle table. The simulation table building module is used to generate the target working condition word to be simulated from the target simulation parameter table, match it with the hidden state particle table, write the matching particles into the initial conditions of tire simulation for design optimization, verification or simulation, and generate a multi-state simulation task table. The cloud scheduling module is used to read the multi-state simulation task table in the industrial cloud computing environment, generate a sorting word for the computational load by multiplying the number of changed positions before entry, the number of hidden state particles, and the number of simulation steps, enqueue them in descending order, and assign them to the central processing unit that ranks first in the ascending order of cumulative computational load to execute the simulation, and output a multi-condition simulation dataset.

[0025] Working principle: This scheme first reads the bench command frame and bench response frame from the historical test records of the tire test bench, converts the bench command at the same sampling time into the target condition word, and extracts the response sequence before entering the target condition based on the changing position of the target condition word; then, it performs differential processing on the response sequence before entering the target condition under the same target condition word, finds the sampling bits where the response state changes by wild binary segmentation change point detection, and then verifies whether these sampling bits should be retained by the code length change; the retained pre-entry change bits are used to segment the pre-entry response sequence to form hidden state particles that can express rise, hold, fall, duration and response difference; then, the sequential Monte Carlo algorithm is used to continuously update the weight of the hidden state particles according to the actual bench response, writes the matched hidden state particles into the initial conditions of tire simulation, generates a multi-state simulation task, and executes the simulation in the industrial cloud computing environment by allocating the central processing unit according to the computational load, and finally obtains the multi-condition simulation dataset; For example, when the tire test bench switches from low-speed rolling to braking and lateral deflection conditions, the system first identifies the changes in the target condition words corresponding to the braking and lateral deflection channels and extracts a segment of the bench response before the switch. If there are state transitions such as brake establishment, residual temperature rise, or lateral deflection recovery in this segment of response, the system retains these transition positions and cuts them into several response segments, and then generates particles of different hidden states. For the same braking and lateral deflection target condition, the system does not generate just one set of ordinary simulation tasks, but generates simulation initial conditions with states before brake establishment, states after brake release, or states after lateral deflection recovery, and allocates computing power in the cloud for batch simulation, thereby obtaining multi-state simulation data that is closer to the continuous process of the real test.

[0026] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A method for batch generation of multi-condition simulation data on a tire testing bench, characterized in that, include: S1. Obtain historical test records and target simulation parameter table. Read bench command frames and bench response frames according to sampling time. Assemble the bench command frames into target operating condition words in ascending order of channel address. Use the target operating condition word change bit as the target entry bit. Extract bench response frames forward to form the pre-entry response sequence and write it into the historical operating condition record table. S2. Merge the historical working condition record table with the target working condition word, perform wild binary segmentation change point detection on the response sequence before the same word enters, generate candidate sub-intervals according to the sampling position, screen out wild sub-intervals according to the hash remainder between the target working condition word and the interval endpoints, calculate the mean square difference gain of the left and right segments bit by bit, and take the first gain as the candidate change bit. S3. The difference between the lengths of the front and back segmented codes is used as the description length reduction. Positive values ​​retain candidate change bits and recursively segment, while non-positive values ​​stop, generating a table of change bits to be entered before the change. S4. Divide the pre-entry response sequence according to the pre-entry change position table, and generate hidden state particles from the first and last response values ​​of the segment, the number of samples, and the difference between the first and last responses. S5. Perform the sequential Monte Carlo algorithm on the hidden state particles, copy the particles in the order of segmentation, calculate the particle likelihood weight with the same word platform response frame co-position difference value, normalize and resample according to the cumulative distribution to generate the hidden state particle table. S6. Generate the target working condition word to be simulated from the target simulation parameter table, match it with the hidden state particle table, write the matching particles into the initial conditions of tire simulation for design optimization, verification or simulation, and generate a multi-state simulation task table. S7. Read the multi-state simulation task table in the industrial cloud computing environment, generate a computational load sorting word by the product of the number of changed positions before entry, the number of hidden state particles, and the number of simulation steps, enqueue it in descending order, and assign it to the central processing unit that ranks first in the ascending order of cumulative computational load to execute the simulation, and output the multi-condition simulation dataset.

2. The method for batch generation of multi-condition simulation data for tire testing benches according to claim 1, characterized in that: S1 includes: S11. Obtain historical test records and target simulation parameter table. Read the channel address bit width and channel quantization step size from the target simulation parameter table. Convert the channel sampled values ​​in the bench command frame into channel integer values ​​according to the channel quantization step size. Then, concatenate the channel address bit width and channel integer values ​​to generate channel segments. S12. Arrange the channel segments at the same sampling time in ascending order of channel address, concatenate the first and last channels of the arranged channel segments to generate the target operating condition word, and perform bitwise XOR on the target operating condition words of adjacent sampling times to generate the target operating condition change word. S13. Read the non-zero bit number of the target working condition change word, write the sampling time corresponding to the first non-zero bit number as the target entry bit, and extract the bench response frame from the target entry bit to the sampling time after the previous target entry bit. Generate the pre-entry response sequence in ascending order of sampling time and write it into the historical working condition record table.

3. The method for batch generation of multi-condition simulation data for tire testing benches according to claim 2, characterized in that: S2 includes: S21. Read the same word from the historical working condition record table with the target working condition word and enter the previous response sequence. Subtract the previous sampling bit response value from the next sampling bit response value to generate a response difference word. Perform fixed-length concatenation on the response difference words of the same sampling bit in ascending order of channel address to generate the same word difference string. S22. Perform the wild binary segmentation change point detection algorithm on the same word difference string. Calculate the segment length using the first and last position numbers of the current segment to be segmented. Concatenate the target condition word with the first and last position numbers and take the modulo to obtain the left offset position. Concatenate the target condition word with the last position number and take the modulo to obtain the right offset position. Extract wild sub-intervals within the current segment to be segmented according to the left and right offset positions. S23. Set segmentation bits bit by bit in the wild sub-interval. Generate a mean difference word by using the mean of the difference string on the left and the mean of the difference string on the right of the segmentation bit. Generate a balancing weight by dividing the product of the number of samples on the left and right sides by the number of samples in the wild sub-interval. Then, multiply the sum of the squares of the mean difference word by the balancing weight to generate a segmentation gain word.

4. The method for batch generation of multi-condition simulation data for tire testing benches according to claim 3, characterized in that: S2 also includes: S24. Read the first segmentation bit in descending order of the segmentation gain word, take the first segmentation bit as the sub-interval change bit, divide the current segment to be divided by the sub-interval change bit, calculate the residual fixed-point coding length before division and the residual fixed-point coding length after division respectively, and subtract the change bit code length from the difference between the two to generate the coding reduction amount. S25. When the encoding reduction is positive, retain the sub-interval change bits and continue to use the segments on both sides of the sub-interval change bits as segments to be segmented to execute S22 to S24; when the encoding reduction is not positive, stop the segmentation of the current segment to be segmented and write the retained sub-interval change bits into the entry change bit table in ascending order of sampling bits.

5. The method for batch generation of multi-condition simulation data for tire testing benches according to claim 4, characterized in that: S3 includes: S31. Read the candidate change bit and the response segment where the candidate change bit is located. Connect the first and last sampled values ​​of the response segment to form the segment baseline. Subtract the corresponding value of the segment baseline from each sampled value in the response segment to generate an unsegmented residual string. Generate the unsegmented coding length according to the fixed-point coding bit number of the unsegmented residual string. S32. Divide the response segment into a left response segment and a right response segment based on the candidate change bits. Generate the left residual string and the right residual string in the same way as in S31. Add the encoding length of the left residual string, the encoding length of the right residual string, and the encoding length of the candidate change bit number to generate the segmentation encoding length. S33. Subtract the segmented coding length from the unsegmented coding length to generate the description length reduction. When the description length reduction is positive, retain the candidate change bits and continue to segment the corresponding response segments. When the description length reduction is non-positive, stop segmenting the corresponding response segments and output the pre-entry change bit table for tire simulation state boundary identification in ascending order of sampled bits.

6. The method for batch generation of multi-condition simulation data for tire testing benches according to claim 5, characterized in that: S4 includes: S41. Read the pre-entry change bit table and the pre-entry response sequence, write the first bit number of the pre-entry response sequence to the first bit of the segmentation boundary string, write the sampling bits in the pre-entry change bit table to the middle bit of the segmentation boundary string in ascending order, write the last bit number of the pre-entry response sequence to the last bit of the segmentation boundary string, and generate a response segmentation segment with the sampling frames between adjacent boundary bit numbers. S42. Perform intra-segment state coding for each response segment, read the first and last response values ​​of the response segment, subtract the first response value from the last response value to generate the first and last response difference, write the rising response direction word if the first and last response difference is greater than zero, write the hold response direction word if the first and last response difference is equal to zero, write the falling response direction word if the first and last response difference is less than zero, and generate the continuous sampling number by subtracting the first number from the last position number of the response segment and adding one. S43. Concatenate the response direction word, continuous sampling number and the difference between the first and last responses according to the response segmentation order to generate segment state words, and concatenate the segment state words under the same pre-entry response sequence end to end in segment order to generate hidden state particles for tire simulation initial state recognition.

7. The method for batch generation of multi-condition simulation data for tire testing benches according to claim 6, characterized in that: S5 includes: S51. Read the hidden state particle table and the pre-entry change bit table, convert the segment state word of each hidden state particle into a particle state vector, where the response direction word is written as rising to 1, remaining to 0, and falling back to negative 1 in the first position, the continuous sampling number is written as a binary bit length in the middle position, the last response difference word is written as a fixed-point integer in the last position, and the initial weight of each particle is written as the reciprocal of the total number of particles. S52. Execute the sequential Monte Carlo algorithm according to the sampling order of the entry into the change position table. Read the particle state vector of the previous round and the current segment state vector in the current segment. Use the current segment state vector to subtract the particle state vector of the previous round to generate the state transition difference vector. Use the particle state vector of the previous round plus the state transition difference vector to generate the predicted particle state vector. S53. Restore the last part of the predicted particle state vector to the predicted response difference word, read the actual response difference word of the same word test frame in the current segment, subtract the predicted response difference word from the actual response difference word to generate the observation residual word, and add one to the median of the absolute value of the observation residual word to generate the robust scale word. S54. Divide the observed residual word by the robust scale word to generate the standard residual word. Use the current number of samples in the segment as the student t-distribution degrees of freedom to calculate the particle likelihood value. Multiply the particle likelihood value by the weight of the previous round to generate the unnormalized weight. Then divide the unnormalized weight by the sum of the weights in this round to generate the posterior weight. S55. Perform system resampling based on the cumulative distribution of a posteriori weights. The starting sampling position is generated by dividing the remainder of the target condition word hash by the total number of particles. The interval between adjacent sampling positions is the reciprocal of the total number of particles. Copy the corresponding particles according to the cumulative distribution position where the sampling position falls, until the pre-change position table is read completely, and generate the hidden state particle table.

8. The method for batch generation of multi-condition simulation data for tire testing benches according to claim 7, characterized in that: S6 includes: S61. Read the target simulation parameter table, divide the value of each channel by the corresponding quantization step size and round it to generate the integer value of the channel to be simulated, concatenate the integer values ​​of the channel to be simulated in ascending order of channel address to generate the target working condition word to be simulated, and use the target working condition word to retrieve the hidden state particle table to generate the particle working condition item. S62. Read the hidden state particles in the particle working condition item, convert the response direction word of the hidden state particles into sign bits, convert the continuous sampling number into state hold bits, convert the last response difference word into state correction bits, and write the sign bit, state hold bits and state correction bits in sequence according to the state slot address in the tire simulation template to generate the initial conditions of particle-based tire simulation. S63. Perform single-step simulation verification based on the initial conditions of particle-based tire simulation. Generate a verification response difference word from the single-step simulation output according to the channel quantization rules of S1. Subtract the last response difference word of the hidden state particle from the verification response difference word to generate a verification residual word. When the verification residual word is zero, write the initial conditions of particle-based tire simulation into the multi-state simulation task table. When the verification residual word is not zero, write the verification residual word back to the state correction bit and repeat the single-step simulation verification. Stop when the number of repetitions is equal to the number of segment state words of the hidden state particle.

9. The method for batch generation of multi-condition simulation data for tire testing benches according to claim 8, characterized in that: S7 includes: S71. In the industrial cloud computing environment, read the multi-state simulation task table, read the change bit count corresponding to the target working condition word to be simulated in the change bit table before entering each simulation task, read the particle count corresponding to the target working condition word to be simulated in the hidden state particle table, read the step count in the tire simulation template, and multiply the change bit count, particle count and step count to generate the computational quantity sorting word, and write it into the simulation task queue in descending order of the computational quantity sorting word. S72. Read the allocated computing power and completed computing power of each central processing unit, subtract the completed computing power from the allocated computing power to generate the unit occupancy, sort the unit occupancy in ascending order, and assign the first task of the simulation task queue to the central processing unit with the first unit occupancy in ascending order. At the same time, add the computing power sort word to the allocated computing power of the corresponding central processing unit. S73. The central processing unit executes the simulation task and outputs the simulation result frame. It concatenates the target working condition word to be simulated and the hidden state particles to generate the result index word. It performs rolling hashing on the simulation result frame according to the sampling bit order to generate the result check word. When the result check words under the same result index word are consistent, they are written into the multi-working condition simulation dataset. When they are inconsistent, the corresponding simulation task is returned to the simulation task queue.

10. A batch generation system for multi-condition simulation data of a tire testing bench, used to implement the batch generation method for multi-condition simulation data of a tire testing bench as described in any one of claims 1-9, the system comprising a data acquisition and character formation module, a change point filtering module, an encoding and retention module, a state granulation module, a particle update module, a simulation table building module, and a cloud scheduling module, characterized in that: The data acquisition module is used to acquire historical test records and target simulation parameter tables. It reads bench command frames and bench response frames according to the sampling time, concatenates the bench command frames into target operating condition words in ascending order of channel address, uses the change bit of the target operating condition word as the target entry bit, intercepts the bench response frame to form the pre-entry response sequence, and writes it into the historical operating condition record table. The change point filtering module is used to merge the historical working condition record table with the target working condition word, perform wild binary segmentation change point detection on the response sequence before the same word enters, generate candidate sub-intervals according to the sampling position, filter out wild sub-intervals according to the hash remainder between the target working condition word and the interval endpoints, calculate the mean square difference gain of the left and right segments bit by bit, and take the first gain as the candidate change position. The encoding retention module is used to describe the length reduction by the difference between the previous and subsequent segmented encoding lengths. Positive values ​​retain candidate change bits and recursively segment, while non-positive values ​​stop the process and generate a table of change bits to be entered before the change. The state granulation module is used to segment the pre-entry response sequence according to the pre-entry change position table, and generate hidden state particles from the first and last response values ​​of the segment, the number of samples, and the difference between the first and last responses. The particle update module is used to perform the sequential Monte Carlo algorithm on the hidden state particles, copy the particles in the order of segmentation, calculate the particle likelihood weight with the same word platform response frame co-position difference value, normalize and resample according to the cumulative distribution to generate the hidden state particle table. The simulation table building module is used to generate the target working condition word to be simulated from the target simulation parameter table, match it with the hidden state particle table, write the matching particles into the initial conditions of tire simulation for design optimization, verification or simulation, and generate a multi-state simulation task table. The cloud scheduling module is used to read the multi-state simulation task table in the industrial cloud computing environment, generate a sorting word for the computational load by multiplying the number of changed positions before entry, the number of hidden state particles, and the number of simulation steps, enqueue them in descending order, and assign them to the central processing unit that ranks first in the ascending order of cumulative computational load to execute the simulation, and output a multi-condition simulation dataset.

Images