Arrangement, polarization compensation and optimization method and system of complex curved surface conformal array

Abstract

The invention relates to the technical field of antenna arrays, and particularly discloses a complex curved surface conformal array arrangement, polarization compensation and optimization method and system, and the method comprises the following steps: S1, point cloud discretization; s2, hexagonal regular arraying: selecting an initial point and a reference point from the point cloud data by taking a preset minimum array element spacing as a constraint, recursively expanding outwards according to a hexagonal geometric rule, screening candidate points meeting distance and angle tolerances, and removing overlapped points to form an array element arraying set; s3, polarization compensation: estimating a curved surface normal vector of each array element position, calculating a deflection angle between the array element normal vector and an array global main axis direction based on an Euler rotation model, correcting an array element local directional diagram to a global coordinate system through a rotation matrix, and compensating polarization mismatch; s4, optimizing a directional diagram: calculating an initial directional diagram of the array after polarization compensation, constructing an error function by taking an ideal directional diagram as a reference, solving an amplitude-phase weighted compensation value through a numerical algorithm, and minimizing a directional diagram error; and S5, carrying out controllable rarefaction.

Description

Technical Field

[0001] This invention relates to the field of antenna array technology, and in particular discloses a method and system for the arrangement, polarization compensation and optimization of complex curved surface conformal arrays. Background Technology

[0002] Phased array antennas are widely used in radar, communication, electronic warfare and navigation fields due to their high directivity, fast beam scanning and multi-target tracking capabilities. Traditional phased arrays mostly adopt planar or regular curved surface layouts, and the positions of array elements can be described by analytical functions, which facilitates optimization with the help of intelligent algorithms such as genetic algorithms.

[0003] However, with the increasing complexity of the shapes and the growing stealth requirements of modern platforms such as stealth fighters, missiles, satellites, and 5G / 6G intelligent connected vehicles, conformal arrays have become an important development trend. These arrays require antenna elements to be placed directly on the curved surfaces of complex carriers, but they face problems such as irregular geometry, lack of analytical expressions for array element positions and curvature variations, surface discontinuities, and occlusion. This leads to three major challenges for traditional methods: difficulty in array placement (the difficulty lies in automatically generating uniform array element positions that meet the minimum spacing constraints on complex curved surfaces), polarization mismatch (array elements vary with the surface normal, causing radiation pattern distortion and gain loss, and traditional methods lack effective compensation models), and optimization complexity (under irregular layouts, there are many variables, complex constraints, and high computational difficulty in radiation pattern synthesis and sparsification design).

[0004] Currently, there is an urgent need for conformal arrays in the fields of national defense, aerospace, and civilian communications. Therefore, there is a pressing need in this field for a conformal array design method that is highly versatile, highly automated, and capable of simultaneously solving the problems of array placement, compensation, and optimization. Summary of the Invention

[0005] In order to overcome the shortcomings and deficiencies of the existing technology, the purpose of this invention is to provide a method and system for the arraying, polarization compensation and optimization of complex curved surface conformal arrays.

[0006] To achieve the above objectives, the method for arraying, polarization compensation and optimization of complex curved surface conformal arrays of the present invention includes the following steps: S1. Point cloud discretization: Obtain the digital model of the complex three-dimensional carrier structure and discretize it into three-dimensional point cloud data;

[0007] S2. Hexagonal regular array: With the preset minimum spacing of array elements as a constraint, the initial point and the reference point are selected from the point cloud data, and the array is recursively expanded outward according to the hexagonal geometric rules. Candidate points that meet the distance and angle tolerances are screened, and overlapping points are removed to form an array element set.

[0008] S3. Polarization Compensation: Estimate the surface normal vector at each element position, calculate the deflection angle between the element normal vector and the global principal axis direction of the array based on the Euler rotation model, and correct the local radiation pattern of the element to the global coordinate system through the rotation matrix to compensate for polarization mismatch.

[0009] S4. Pattern Optimization: Calculate the initial array pattern after polarization compensation, construct an error function with the ideal pattern as a reference, solve the amplitude and phase weighted compensation value through numerical algorithm, and minimize the pattern error;

[0010] S5. Controllable sparsity: Using the array set as the initial solution and the sidelobe level as a constraint, an intelligent optimization algorithm is used to select a subset of array elements that can be turned off, thereby realizing the array sparsity design.

[0011] By discretizing complex 3D carrier digital models into a standardized point cloud set Ω, this method eliminates the reliance on surface analytical expressions used in traditional methods. It can directly adapt to carrier data from various sources, including CAD models and 3D scans, demonstrating exceptional versatility. The standardized coordinate representation provides a unified and accurate data foundation for subsequent array element distance calculations, orientation selection, and quantization operations. This avoids computational errors caused by inconsistent data formats, significantly improving the computational efficiency and accuracy of subsequent steps and laying a solid data foundation for the automation of the entire conformal array design process.

[0012] By employing a hexagonal geometric rule-based recursive array layout, combined with a strict distance and angle tolerance screening and overlapping point removal mechanism, this method can automatically adapt to any irregular curved surface, generating a uniformly spaced, regularly arranged array element layout without excessively close conflicts. Compared to traditional regular grid layout methods, this approach does not rely on the mathematical description of the surface, solving the problem of difficult array layout on complex curved surfaces. Furthermore, the 2% distance tolerance and 5° angle tolerance settings ensure the accuracy of the array element layout, providing standardized and high-quality array element position data for subsequent polarization compensation and radiation pattern optimization, effectively improving the reliability and stability of the entire array design.

[0013] By accurately estimating the array element normal vectors using principal component analysis (PCA) and combining this with the Eulerian rotation model of the ZYX external rotation order, a complete mathematical framework for polarization compensation was constructed, enabling precise correction of the array element radiation patterns. This method effectively quantifies and compensates for polarization mismatch caused by array element orientation deflection, solving the problems of radiation pattern distortion and gain loss that traditional methods struggle to address. It allows all array element radiation patterns to be coherently superimposed in a unified global coordinate system, significantly improving the computational accuracy of conformal array radiation patterns and ensuring the accuracy of the main lobe gain and shape, thus providing a core guarantee for high-performance array output.

[0014] Using the ideal radiation pattern of a regular area array of the same aperture as a reference, an error function was constructed using the least squares algorithm, and the radiation pattern error was minimized, achieving a "refined" optimization of the array radiation pattern. This step, based on polarization compensation, further suppressed the sidelobe increase problem caused by surface truncation and edge effects, effectively improving the overall electrical performance of the array. Simultaneously, the final compensated phase integrated polarization compensation and phase correction, providing an optimized and accurate phase basis for subsequent controllable sparsification, ensuring that the array performance does not significantly deteriorate during sparsification, thus balancing array performance improvement with the feasibility of subsequent engineering applications.

[0015] By leveraging the regular topology formed by a hexagonal array and combining the global search capability of a genetic algorithm with the efficient convergence characteristics of a particle swarm optimization algorithm, efficient array sparsity is achieved under strict constraints on sidelobe levels. This approach significantly reduces the number of active array elements while ensuring that key performance indicators such as main lobe width and sidelobe levels do not deteriorate. This effectively reduces the amount of T / R components used, system weight, power consumption, and overall cost, solving the problem of balancing performance and cost in traditional sparsity designs and greatly improving the engineering practicality and economy of conformal arrays.

[0016] Furthermore, the three-dimensional point cloud data described in S1 is denoted as set Ω = {p n =(x n ,y n ,z n p | n = 1, 2, ..., N n Let N be the three-dimensional coordinates of the nth point and N be the total number of points in the cloud. This set-based definition enables the standardized representation of point cloud data, providing a data foundation for distance calculation, orientation screening, and quantization operations of candidate points in S2.

[0017] By defining a standardized set of coordinates, point cloud data is represented in a unified manner, unifying the data format and computational benchmark. This avoids computational conflicts and errors caused by differences in representation methods among point cloud data from different sources. The standardized coordinate set provides accurate and efficient data support for S2 array element distance calculation and orientation selection, ensuring the consistency and accuracy of subsequent quantization calculations, simplifying the data processing flow, and reducing the time cost of data preprocessing. Simultaneously, the standardized data format facilitates data transfer and collaborative work between steps, providing crucial data assurance for the automated and efficient operation of the entire design process, thereby improving design efficiency and result reliability.

[0018] Furthermore, in S2, the hexagonal geometric rule generates six target directions at 60° intervals, centered on the initial point, with the reference point anchoring the orientation of the first target direction. During recursive outward expansion, the selected candidate points are used as new array element points, and the hexagonal rule is repeated with these element points as the center to generate new target directions. Candidate point selection must meet the following conditions: the distance from the current central array element point must fall within the minimum allowable error range of the spacing; the angle between the line connecting the candidate point to the central array element point and the corresponding target direction must be within the tolerance range; the distance tolerance ≤ 2% × minimum spacing, and the angle tolerance ≤ 5°. When the distance between a new candidate point and a selected array element point is less than the minimum spacing minus the preset tolerance δ, it is determined to be an overlapping point and discarded, ultimately forming an array element layout set, providing array element position data support for the array element normal vector calculation and polarization compensation in S3.

[0019] The recursive expansion design based on hexagonal rules, combined with strict tolerance control and overlapping point elimination mechanisms, ensures the uniformity and standardization of the array element layout. A 2% distance tolerance and a 5° angle tolerance effectively guarantee array accuracy and avoid performance interference caused by uneven element distribution or excessively close spacing. The recursive expansion method enables the array to adapt to curved surface shapes, automating the layout of complex surfaces without manual intervention, significantly improving array efficiency. The generated standardized array element set provides high-quality positional data for accurate calculation of S3 element normal vectors and polarization compensation, ensuring the accuracy of subsequent polarization compensation and laying a solid foundation for improving the overall array performance.

[0020] Furthermore, in S3, the principal component analysis algorithm is used to estimate the array element normal vector. By performing three-dimensional interpolation and densification on the array set, the set of neighboring points of each array element is selected, and after centering, a data matrix is ​​constructed. The covariance matrix is ​​calculated and eigenvalue decomposition is performed. The eigenvector corresponding to the smallest eigenvalue is taken as the normal vector, which provides a directional reference for the subsequent calculation of the deflection angle and correction of the local radiation pattern of the array element by the Euler rotation model, and ensures the polarization mismatch compensation effect.

[0021] Principal component analysis (PCA) combined with 3D interpolation encryption significantly improves the accuracy and reliability of array element normal vector estimation. Neighbor set analysis and eigenvalue decomposition effectively eliminate noise interference, ensuring that the normal vectors accurately reflect the local geometric characteristics of the surface. Precise normal vectors provide a reliable directional reference for the Euler rotation model, making deflection angle calculations more accurate and thus guaranteeing the accuracy of local radiation pattern correction for array elements. This method solves the problem of polarization compensation failure caused by large errors in traditional normal vector estimation, ensuring effective compensation for polarization mismatch and significantly improving the calculation accuracy of the array radiation pattern, providing high-quality foundational data for subsequent radiation pattern optimization.

[0022] Furthermore, the Euler rotation model described in S3 adopts an external rotation order, which is a rotation about an ordered orthogonal axis of a fixed coordinate system, and its rotation matrix R = R x(γ)·R γ (β)·Rz(α), where α, β, and γ are the Euler angles of deflection about the corresponding fixed axes; based on the surface normal vector of the array element position, the local radiation pattern of the array element in the spherical coordinate system is converted into rectangular coordinates, and after rotation matrix operation, it is converted back to spherical coordinates to extract the principal polarization direction and obtain the polarization compensation phase. This provides a corrected array element pattern basis for calculating the initial array pattern and constructing the error function in S4.

[0023] A rigorous coordinate transformation mathematical framework was constructed using the ZYX external rotation order Euler rotation model to ensure precise and controllable transformation of the local radiation pattern of array elements to the global coordinate system. Through the transformation between spherical and rectangular coordinates and rotation matrix operations, accurate correction of the array element radiation patterns was achieved, effectively extracting the polarization compensation phase and fundamentally solving the polarization mismatch problem caused by varying element orientations in conformal arrays. The corrected array element radiation patterns provide high-quality foundational data for the initial radiation pattern calculation and error function construction of the S4 array, avoiding interference from polarization mismatch in radiation pattern optimization, ensuring the effectiveness of subsequent optimization steps, and significantly improving the overall electrical performance of the array.

[0024] Furthermore, the ideal radiation pattern described in S4 is the radiation pattern of a regular area array of the same aperture, and the numerical algorithm is the least squares algorithm, which ultimately compensates for the phase. It provides an optimized compensation phase basis for S5 controllable sparsity, supporting the simplification of array elements while ensuring array performance.

[0025] Using the radiation pattern of a regular area array of the same aperture as an ideal reference, an error function is constructed using the least squares algorithm. This accurately quantifies the deviation between the actual radiation pattern and the ideal state. Precise "refinement" of the radiation pattern is achieved by solving for the amplitude-phase weighted compensation value. The final compensated phase integrates polarization compensation and optimized phase correction, solving the polarization mismatch problem and effectively suppressing sidelobe rise, significantly improving the array's electrical performance. The optimized compensated phase provides a reliable basis for the controllable sparsity of the S5 array, ensuring that key performance indicators such as main lobe width and sidelobe level do not significantly deteriorate during element simplification. This achieves a balance between high performance and low cost, enhancing the engineering practicality of the technical solution.

[0026] Furthermore, the intelligent optimization algorithm described in S5 includes a genetic algorithm and / or a particle swarm optimization algorithm. The genetic algorithm has global search capabilities and can accurately screen the subset of shut-off array elements that meet performance requirements in a multi-solution space constrained by the sidelobe level, thus adapting to the multi-objective requirements of controllable sparsity. The particle swarm optimization algorithm has efficient convergence characteristics and can quickly lock the optimal solution of the subset of shut-off array elements while ensuring that the sidelobe level does not exceed the limit, thereby improving the implementation efficiency of controllable sparsity.

[0027] The combined application of genetic algorithms and particle swarm optimization (PSO) fully leverages the advantages of both algorithms. The global search capability of the genetic algorithm ensures accurate selection of a subset of shut-off array elements that satisfy sidelobe level constraints within a complex multi-solution space, avoiding performance degradation caused by local optima. The efficient convergence characteristics of the PSO algorithm significantly shorten optimization time and improve the efficiency of controllable sparsity implementation. This approach solves the problems of low search accuracy or poor efficiency in traditional sparsity algorithms. While strictly ensuring array performance, it significantly reduces the number of active array elements, effectively reducing system weight, power consumption, and cost, thus balancing technical performance and engineering economy, and possessing extremely high practical value.

[0028] A system for the arraying, polarization compensation, and optimization of complex curved surface conformal arrays includes at least one processor and at least one memory. The memory stores a computer program, a point cloud processing module, an arraying module, a polarization compensation module, a radiation pattern optimization module, and a sparsification module. The computer program is electrically connected to each module. The processor is used to read and execute the computer program in the memory. When the computer program is executed, it calls and coordinates the work of each module.

[0029] The point cloud processing module is used to acquire digital models of complex 3D carrier structures and discretize them into 3D point cloud data, then standardize and represent the point cloud data as a set Ω = {p n =(x n ,y n ,z n The data for distance calculation and orientation selection of the array module is based on the n = 1, 2, ..., N.

[0030] The array deployment module is used to receive the point cloud data, filter candidate points that meet the requirements of distance tolerance ≤ 2% × minimum array element spacing and angle tolerance ≤ 5° based on the hexagonal rule and minimum array element spacing constraint, and eliminate overlapping points by determining whether the distance between the new candidate point and the selected array element point is less than the minimum array element spacing minus the preset tolerance δ, and generate an array element deployment set to provide standardized array element position data for the polarization compensation module.

[0031] The polarization compensation module is used to receive the array set, estimate the surface normal vector of the array element position through the principal component analysis algorithm, and correct the local radiation pattern of the array element to the global coordinate system based on the Euler rotation model to achieve polarization mismatch compensation, and provide the corrected array data to the radiation pattern optimization module.

[0032] The pattern optimization module receives the polarization-compensated array data, constructs an error function with the pattern of a regular array of the same aperture as an ideal reference, solves the amplitude-phase weighted compensation value and minimizes the pattern error through the least squares algorithm, and provides the optimized compensation phase basis for the sparsification module.

[0033] The sparsification module receives the optimized results and uses a genetic algorithm and / or particle swarm optimization algorithm to select a subset of array elements that can be turned off, constrained by the sidelobe level, to achieve array sparsification.

[0034] The system seamlessly integrates 3D modeling, layout design, electromagnetic calculations, and optimization algorithms through the collaborative work of the processor and multiple modules, forming a complete automated design system. Each module has a clear division of labor and smooth data transfer, avoiding the inefficiencies and error accumulation caused by disconnected processes in traditional design, significantly improving the design efficiency and reliability of conformal arrays. The processor's execution of computer programs and module calls ensure the automated operation of the design process, reducing operational errors caused by manual intervention. Meanwhile, the unified hardware and software architecture guarantees the system's stability and scalability, adapting to the design requirements of conformal arrays with different complex curved surfaces, enhancing the system's versatility and practical value.

[0035] The point cloud processing module enables automated discretization and standardized representation of complex carrier digital models, eliminating the need for manual data preprocessing and significantly improving data processing efficiency. The standardized point cloud set provides a unified and accurate data foundation for the array deployment module, ensuring the accuracy of distance calculations and orientation selection, and avoiding computational errors caused by inconsistent data formats. This module is compatible with digital models from various sources, enhancing the system's compatibility with different carriers. It also simplifies the data reception and processing flow of subsequent modules, providing crucial data support for the efficient operation of the entire design system and improving its versatility and data processing reliability.

[0036] The array layout module, based on hexagonal rules and strict tolerance constraints, automates the generation of complex curved surface array element layouts without relying on surface analytical models, thus solving the problem of poor adaptability of traditional array layout methods. A 2% distance tolerance and a 5° angle tolerance, combined with an automatic overlap point removal mechanism, ensure that the generated array element set has uniform spacing and no conflicts, providing high-quality position data for the polarization compensation module. The automated operation of this module significantly shortens the array layout time and improves design efficiency. Meanwhile, the standardized array element layout ensures the accuracy of subsequent polarization compensation, laying the foundation for improved overall array performance and enhancing the system's practicality and reliability.

[0037] The polarization compensation module integrates principal component analysis algorithms and the Euler rotation model to construct an automated polarization mismatch compensation process, completing normal vector estimation and pattern correction without manual intervention. Accurate normal vector estimation and pattern transformation ensure effective compensation for polarization mismatch, resolving the problems of pattern distortion and gain loss in traditional conformal arrays, and providing high-quality corrected data for the pattern optimization module. The automated operation of this module improves compensation efficiency and accuracy, avoids errors caused by manual calculations, and its seamless integration with other modules ensures the continuity of the design process, significantly improving the overall system design performance and reliability.

[0038] The radiation pattern optimization module, using an ideal radiation pattern as a reference and incorporating a least-squares algorithm, achieves automated and precise optimization of the array radiation pattern, effectively suppressing sidelobe rise and improving array electrical performance. This module constructs an error function and minimizes the error to ensure the array radiation pattern approximates the ideal state, providing optimized compensation phase data for the sparsification module and guaranteeing the stability of array performance during subsequent sparsification. The automated optimization process significantly shortens the design cycle and improves optimization efficiency. Simultaneously, the accurate compensation phase data supports the efficient operation of the sparsification module, achieving a dual improvement in array performance and design efficiency, and enhancing the system's engineering practicality.

[0039] The sparsity module employs a genetic algorithm and a particle swarm optimization algorithm to achieve efficient and automated array sparsification while strictly controlling the sidelobe level. This module fully utilizes optimized compensated phase data to ensure that key array performance indicators do not significantly deteriorate during element simplification, effectively reducing the number of active elements and lowering system cost, weight, and power consumption. The application of these two intelligent algorithms balances search accuracy and efficiency, avoiding the performance-cost trade-off problem inherent in traditional sparsity designs. Simultaneously, the automated selection process significantly improves design efficiency and reduces manual operation costs, providing a cost-effective solution for the engineering application of conformal arrays and enhancing the system's market competitiveness.

[0040] Furthermore, the array module includes a built-in parameter configuration submodule and an overlap / conflict detection submodule. The parameter configuration submodule is electrically connected to the computer program and is used to support users in customizing the minimum spacing, distance tolerance, and angle tolerance of array elements, providing quantitative constraint standards for candidate point selection. The overlap / conflict detection submodule works in conjunction with the parameter configuration submodule to automatically eliminate overlapping points by determining whether the distance between a new candidate point and a selected array element point is less than the minimum array element spacing minus a preset tolerance δ, ensuring that the array element set meets the spacing constraint requirements.

[0041] The parameter configuration submodule supports user-defined key parameters, enhancing the system's flexibility and adaptability to meet the array deployment needs of different scenarios and providing personalized quantitative constraint standards for candidate point selection. The overlap and conflict detection submodule works in conjunction with the parameter configuration submodule to achieve automated and accurate removal of overlapping points, avoiding the tediousness and errors of manual detection and ensuring that the array element set strictly meets the spacing constraint requirements. This dual-module design improves the intelligence level of the array deployment module, satisfying diverse design needs while ensuring array quality, providing a reliable guarantee for the efficient operation of subsequent modules, and enhancing the system's practicality and ease of operation.

[0042] Furthermore, the polarization compensation module incorporates a normal vector estimation submodule and a radiation pattern correction submodule. The normal vector estimation submodule estimates the surface normal vector of the array element position using principal component analysis algorithms, including 3D interpolation encryption, nearest neighbor set centering, data matrix construction, and covariance matrix eigenvalue decomposition. The radiation pattern correction submodule is electrically connected to the normal vector estimation submodule. Based on the surface normal vector, it converts the local radiation pattern of the array element in the spherical coordinate system into rectangular coordinates using an external rotation sequence around an ordered orthogonal axis of a fixed coordinate system. After rotation matrix operations, it is converted back to spherical coordinates, and the principal polarization direction is extracted to generate the polarization compensation phase. Polarization mismatch compensation is achieved, providing corrected array data for the pattern optimization module.

[0043] The normal vector estimation submodule ensures high accuracy and reliability of array element normal vector estimation through a multi-step principal component analysis algorithm, providing precise basic data for polarization compensation. The pattern correction submodule, based on the accurate normal vectors, achieves automated and precise correction of the array element pattern through standardized coordinate transformations and rotation matrix operations, effectively generating polarization compensation phases. The two modules work together to construct a complete polarization compensation process, solving the problems of low accuracy and complex operation in traditional polarization compensation, ensuring a complete resolution of polarization mismatch, and providing high-quality data for the pattern optimization module. The automated processing improves compensation efficiency, reduces manual intervention, enhances system stability and reliability, and provides core support for high-performance array output.

[0044] The beneficial effects of this invention are as follows: This method accurately addresses three major challenges of traditional phased arrays in complex curved surface applications on modern platforms (stealth fighters, missiles, satellites, 5G / 6G automobiles, etc.): Point cloud discretization does not rely on surface analytical expressions, adapts to multi-source data such as CAD and 3D scanning, and, combined with hexagonal regular array layout, can automatically generate a uniform array element layout that meets the minimum spacing constraint on irregular curved surfaces, completely solving the problem of "difficult array layout"; The PCA algorithm accurately estimates the array element normal vectors, and, combined with the ZYX external rotation Euler rotation model, constructs a complete polarization compensation framework, effectively correcting the radiation pattern, compensating for gain loss, and overcoming the pain point of "polarization mismatch"; The least squares algorithm optimizes the radiation pattern, and the GA and PSO intelligent algorithms are combined to achieve sparsity, simplifying the optimization difficulty under irregular layouts and balancing performance and cost.

[0045] The system achieves automated design through multi-module collaboration, adapting to the conformal array requirements of fields such as national defense, aerospace, and civilian communications, significantly improving design efficiency and reliability, and meeting the practical and engineering application requirements of modern platforms for conformal arrays. Attached Figure Description

[0046] Figure 1 This is a flowchart illustrating the steps of the complex curved surface conformal array arrangement, polarization compensation, and optimization method of the present invention.

[0047] Figure 2 This is a flowchart of the array layout optimization method for the array module of the present invention.

[0048] Figure 3 This is a schematic diagram of the hexagonal point finding mechanism of the array module of the present invention.

[0049] Figure 4 This is a flowchart illustrating the steps of the polarization compensation module of the present invention;

[0050] Figure 5 This is a schematic diagram of the complex curved surface conformal array, polarization compensation and optimization system of the present invention.

[0051] Figure 6 This is a flowchart illustrating the specific steps of implementing the genetic algorithm (GA) of the present invention.

[0052] Figure 7 This is a flowchart of the processor execution process of the present invention;

[0053] Figure 8 This is a flowchart illustrating the steps involved in implementing the hexagonal rule of the present invention.

[0054] Figure 9 This is a flowchart of the candidate point screening and overlap removal steps of the present invention;

[0055] Figure 10This is a flowchart illustrating the steps of PCA normal vector estimation in this invention;

[0056] Figure 11 This is a flowchart illustrating the steps of Euler rotation and pattern correction in this invention.

[0057] Figure 12 A flowchart illustrating the steps of the parameter configuration submodule of this invention;

[0058] Figure 13 This is a flowchart of the overlapping collision detection submodule of the present invention;

[0059] Figure 14 This is a flowchart of the steps in the normal vector estimation submodule of the present invention;

[0060] Figure 15 This is a flowchart of the steps of the pattern correction submodule of the present invention.

[0061] The reference numerals in the attached figures include: 1. Processor; 2. Memory; 3. Computer program; 4. Point cloud processing module; 5. Arraying module; 6. Polarization compensation module; 7. Radiation pattern optimization module; 8. Sparsification module; 9. Parameter configuration submodule; 11. Overlap and collision detection submodule; 12. Normal vector estimation submodule; 13. Radiation pattern correction submodule. Detailed Implementation

[0062] To further illustrate the technical means and effects of the present invention in achieving its intended purpose, the following detailed description of the specific implementation methods, structures, features, and effects of the present invention, in conjunction with the accompanying drawings and preferred embodiments, is provided below.

[0063] Please see Figures 1 to 15 As shown, the method for arranging, polarization compensation, and optimizing complex curved surface conformal arrays of the present invention includes the following steps:

[0064] S1. Point cloud discretization: Obtain a digital model of a complex three-dimensional carrier structure and discretize it into three-dimensional point cloud data;

[0065] S2. Hexagonal regular array: With the preset minimum spacing of array elements as a constraint, the initial point and the reference point are selected from the point cloud data, and the array is recursively expanded outward according to the hexagonal geometric rules. Candidate points that meet the distance and angle tolerances are screened, and overlapping points are removed to form an array element set.

[0066] S3. Polarization Compensation: Estimate the surface normal vector at each element position, calculate the deflection angle between the element normal vector and the global principal axis direction of the array based on the Euler rotation model, and correct the local radiation pattern of the element to the global coordinate system through the rotation matrix to compensate for polarization mismatch.

[0067] S4. Pattern Optimization: Calculate the initial array pattern after polarization compensation, construct an error function with the ideal pattern as a reference, solve the amplitude and phase weighted compensation value through numerical algorithm, and minimize the pattern error;

[0068] S5. Controllable sparsity: Using the array set as the initial solution and the sidelobe level as a constraint, an intelligent optimization algorithm is used to select a subset of array elements that can be turned off to achieve array sparsity design;

[0069] First, a digital model of a complex 3D carrier (such as an aircraft fuselage or missile body) can be constructed using CAD design software (such as SolidWorks or UG), or a 3D laser scanner (such as the Faro Focus series) can be used to scan the solid carrier and obtain raw point cloud data. Then, a meshing tool (such as ANSYSICEM or MeshLab) can be used to discretize the digital model: point cloud density parameters can be set (typically, the point spacing ≤ 1 / 5 of the minimum element spacing to ensure sufficient candidate points for subsequent array placement), and a triangular or tetrahedral meshing algorithm can be used to discretize the model surface and interior into a 3D point cloud, with each point p... n of (x) n ,y n ,z n Coordinates can be directly output using the subdivision tool.

[0070] The discretized point cloud data can be sorted into sets Ω = {p n =(x n ,y n ,z n The data is formatted and stored in the format (e.g., .txt or .ply) of |n=1,2,...,N}, where N can be determined according to the carrier size (e.g., N≈40000 when the carrier is 1m×1m and the point spacing is 5mm). At the same time, the data can be optimized by point cloud denoising algorithms (e.g., statistical filtering, removing noise points that are more than 3 times the standard deviation from the mean) to provide a high-quality standardized point cloud foundation for subsequent steps. Those skilled in the art can complete the operation using the aforementioned commercial software and algorithms.

[0071] First, determine the minimum spacing d0 between array elements based on the array's operating wavelength λ (usually d0 ≤ λ / 2, e.g., d0 = 5cm when λ = 10cm). Initial point selection: Within the effective area of ​​the point cloud Ω (e.g., the radar antenna installation area), candidate initial points can be selected based on the condition that the distance from the edge of the carrier is ≥ d0, with priority given to the point p0 at the center of the area. Reference point p1 selection: Calculate the Euclidean distance between p0 and surrounding points. Points within the range of d0 ± 2% d0 (distance tolerance ≤ 2% d0) can be selected as reference points, anchoring the first target direction θ0 = 0°. Generate six target directions: With p0 as the center, generate θ at 60° intervals around the global coordinate system z-axis. k= k × 60° (k = 0, 1, ..., 5).

[0072] Candidate point selection: for each θ k Calculate the line connecting p0 to other points and θ. k The angle between the directions can be selected by choosing the angle θ. k Points within ±5° (angle tolerance ≤ 5°) and whose distance meets d0 ± 2%d0 are selected as candidate points. Recursive extension: Selected candidate points can be used as new centers, and the above steps of reference point selection, direction generation, and candidate point screening can be repeated; Overlap determination: Calculate the Euclidean distance between the new candidate point and all selected points. If the distance is < d0 - δ (δ can be 0.1d0, such as δ = 0.5cm when d0 = 5cm), it is determined to be an overlap. Overlapping points can be eliminated by traversing and comparing, and finally the array set Ω' is formed. Technicians can use MATLAB or Python's spatial geometry calculation library (such as scipy.spatial) to implement the above screening and determination.

[0073] The normal vector estimation uses the PCA algorithm: The first step involves three-dimensional interpolation densification of the array set Ω' (using Python's scipy.interpolate.griddata function, employing cubic interpolation, resulting in a point spacing ≤ 0.5δ, where δ is the radius of the nearest neighbor set); the second step involves processing each array element point q... m , with q m Centered on a point, we can select a set of neighboring points N within a radius δ = d0. m (ensure N) m The number of midpoints K ≥ 10; if insufficient, δ can be increased to 1.2d0); the third step is centering: calculate N. m mean Each point can be subtracted The centered vector is obtained; the fourth step is to construct a 3×K data matrix X. m (Each row corresponds to a centered vector in the x, y, and z directions), calculate the 3×3 covariance matrix C. m =1 / KX m X m ^T; The fifth step can use the numpy.linalg.eig function to process C. m Perform eigenvalue decomposition and take the eigenvector corresponding to the smallest eigenvalue as the normal vector n. m Euler's rotation model.

[0074] The global principal axis of the array can be set to the z0 axis, and n can be calculated. m The angle between z and z0 determines the Euler angles (α, β, γ) for the external rotation order of ZYX (α is the rotation angle about the z-axis, β is about the y-axis, and γ is about the x-axis, which can be calculated using the vector dot product and cross product: α = arctan2(n m y,nm x), β=arccos(n m z / ||n m ||), γ=0, because n m (Normalized); Rotation matrix R = R x (γ)R γ (β)Rz(α), where each matrix can be calculated using standard formulas. Pattern correction: The local pattern of the array elements f(θ,φ) can be calculated in spherical coordinates (e.g., cosine of a microstrip antenna). 2 The θ-direction pattern is decomposed into x, y, and z components to obtain E_xyz; multiplied by R on the left, E'_xyz is obtained; this can be achieved through coordinate transformation (r = √(x...). 2 +y 2 +z 2 ), θ=arccos(z / r), φ=arctan2(y,x)), transform back to spherical coordinates, extract the principal polarization components (such as the θ component), and calculate the polarization compensation phase. Technicians can obtain local radiation patterns using electromagnetic simulation software (such as HFSS) and perform compensation using matrix operations.

[0075] Initial radiation pattern calculation: The electromagnetic field vector superposition method can be used. Where w m It can be set as an initial uniform weighting (w) m =1), f m 'This is the corrected array element radiation pattern. θ and φ can traverse spatial angles in 1°×1° steps (-90°≤θ≤90°, 0°≤φ≤360°). Ideal radiation pattern F0 is obtained: A planar array of the same aperture (with the same coverage area as Ω') can be used as a reference. The array factor formula is used to calculate F0(θ,φ)=Σ[exp(j2π / λ(x...]). m sinθcosφ+y m sinθsinφ+z m cosθ))], where (x) m ,y m ,z m Let θ be the coordinates of the midpoint of Ω', and λ be the operating wavelength. The error function is constructed as: J = Σ[(θ,φ)|F(θ,φ)-F0(θ,φ)| 2 The summation range can cover the entire spatial angle.

[0076] Numerical algorithm solution: The least squares algorithm can be used, with amplitude and phase weights. a m For magnitude weighting, To correct the phase, as the optimization variable, constraint condition a can be set. m ∈[0,1]、 Solve using MATLAB's `lsqcurvefit` function or Python's `scipy.optimize.least_squares` function, with the objective of minimizing J. The solution yields... Final compensation phase Technicians can use the aforementioned optimization toolkit to solve the problem, and can also verify whether the error meets the requirements (e.g., J≤10) by drawing a radiation pattern. -4 ).

[0077] Using the array set Ω' (containing M elements) as the initial solution, the following constraints can be set: maximum sidelobe level ≤ -30dB (adjusted according to system requirements, such as radar systems typically requiring ≤ -25dB). The optimization objective can be to maximize the sparsity ρ = |Ω s | / M(Ω s To preserve a subset of array elements, a smart optimization algorithm can be used: Genetic Algorithm (GA): Step 1: Encoding: Construct an M-bit binary chromosome, where "1" in the gene indicates preserving array elements and "0" indicates disabling them; Step 2: Population initialization: The population size can be 80, and chromosomes can be randomly generated to ensure that ρ∈[0.3,0.7] in the initial population; Step 3: Fitness function: For each chromosome, calculate the corresponding array pattern. (Only retain the array element corresponding to "1"), extract the maximum level SL of the sidelobe region (|θ-θ0|>10°, θ0 is the direction of the main lobe). If SL≤-30dB, fitness=ρ; otherwise fitness=ρ-(SL+30) / 100 (penalize over-constrained individuals).

[0078] The fourth step is genetic operations: the selection operator can be tournament selection (tournament size = 3), the crossover operator can be single-point crossover (crossover probability = 0.8), and the mutation operator can be positional mutation (mutation probability = 0.01); the fifth step is iteration: the number of iterations can be 100. After each iteration, the individual with the highest fitness can be retained. After the iteration is completed, the subset of elements corresponding to the chromosome with the highest fitness can be selected as Ω. s Alternatively, Particle Swarm Optimization (PSO) can be used: Particle dimension = M, position vector is binary (0 / 1), velocity update can use inertia weight ω = 0.5 + 0.5 / (1 + exp(-t / 20)) (t is the number of iterations), learning factors c1 = c2 = 2, objective function is the same as GA. Technicians can implement the above algorithm through MATLAB's GA toolbox or Python's deap library. Finally, simulation can be used to verify whether the sidelobe level meets the constraints.

[0079] Specifically, the three-dimensional point cloud data described in S1 is denoted as set Ω = {p n =(x n ,y n ,z np | n = 1, 2, ..., N n Let N be the three-dimensional coordinates of the nth point and N be the total number of points in the cloud. This set-based definition enables the standardized representation of point cloud data, providing a data foundation for distance calculation, orientation screening, and quantization operations of candidate points in S2.

[0080] First, we can determine the storage format of the point cloud data, including the three-dimensional coordinates (x, y, z). n ,y n ,z n Press "nx" n y n z n The line format of "" is stored in a .txt file, which can be read and converted into a NumPy array using Python's pandas library to construct a numerical representation of the set Ω, ensuring that each p n The coordinate accuracy can be retained to 3 decimal places (e.g., mm-level accuracy, meeting the positioning requirements of array elements). Specific implementation of standardized representation: The coordinates of Ω can be normalized (optional; if the carrier size is too large, the coordinates can be divided by the maximum size of the carrier to make the coordinate range ∈ [0,1], simplifying subsequent calculations). At the same time, the mapping relationship between the original coordinates and the normalized coordinates can be recorded to facilitate subsequent reconstruction of the actual position.

[0081] Specific operations that provide the data foundation for S2: When calculating the distance between candidate points, the numpy linalg.norm function can be directly called to calculate the Euclidean distance between two points (e.g., ||p). k -p0||=linalg.norm(p k -p0)); When filtering by orientation, the angle between vectors can be calculated using NumPy's dot function (e.g., ∠(v0, p)). k -p0)=arccos(dot(v0,p k -p0) / (linalg.norm(v0)*linalg.norm(p k -p0)))) can convert the angle to degrees and compare it with the tolerance. In subsequent steps, such as the normal vector estimation in S3, the coordinates of neighboring points can be directly extracted from Ω to construct a data matrix without additional data format conversion. Technicians can use the above array operations and function calls to achieve the quantization calculation of standardized point clouds in each step.

[0082] Specifically, in S2, the hexagonal geometric rule generates six target directions at 60° intervals, centered on the initial point, with the reference point anchoring the orientation of the first target direction. When recursively expanding outward, the selected candidate points are used as new array element points, and the hexagonal rule is repeated to generate new target directions centered on these array element points. The selection of candidate points must meet the following requirements: the distance from the current central array element point must fall within the allowable error range of the minimum spacing; the angle between the line connecting the candidate point to the central array element point and the corresponding target direction must be within the tolerance range; the distance tolerance ≤ 2% × minimum spacing, and the angle tolerance ≤ 5°. When the distance between a new candidate point and a selected array element point is less than the minimum spacing minus the preset tolerance δ, it is determined to be an overlapping point and is removed, ultimately forming an array element set, which provides array element position data support for the calculation of array element normal vectors and polarization compensation in S3.

[0083] The specific implementation of generating six target directions: A local coordinate system can be established with the initial point p0 as the origin. The x-axis can be along the line connecting the reference points p1 and p0 (v0 = p1 - p0, the unit vector is v0 / ||v0||), and the z-axis can be consistent with the local normal vector of the carrier surface (initially set as the global z-axis, and subsequently corrected by S3). Rotating v0 around the z-axis at 60° intervals yields six target direction vectors: v k =Rz(k×60°)·v0 (k=0,1,...,5), where each v k That is, the corresponding θ k The unit vector of direction. The recursive expansion operation process: First, the 6 candidate points initially selected can be added to the selected set S; Second, each point q in S (except p0) can be traversed, q can be used as the new center, the distance between q and other points in S can be calculated, and the point with a distance of d0 ± 2%d0 from q can be selected as the new reference point to anchor the first target direction of q.

[0084] The third step generates six target direction vectors for q (using the same method as p0), and filters candidate points around q that meet the distance and angle tolerances. The fourth step is overlap determination: for each new candidate point q_new, calculate its distance to all points in S. If the distance is less than d0 - δ (δ can be 0.1d0, e.g., δ = 0.5cm when d0 = 5cm), then q_new can be removed; otherwise, q_new can be added to S, and the second step is repeated until S no longer adds points or covers the entire effective area of ​​the carrier. Finally, S is the array element set Ω', and the coordinate data of Ω' can be exported as a .csv file to provide input for S3: each array element point q in S3. m The coordinates can be directly read from Ω' and used for interpolation encryption, selection of neighboring point sets, and calculation of normal vectors to ensure that the polarization compensation array element position data is consistent with the actual array layout. Technicians can achieve recursive expansion through loop traversal and vector operations, and save the Ω' data using file read and write functions.

[0085] Specifically, in S3, the principal component analysis algorithm is used to estimate the normal vector of the array element. By performing three-dimensional interpolation and densification on the array set, the set of neighboring points of each array element is selected, and after centering, a data matrix is ​​constructed. The covariance matrix is ​​calculated and eigenvalue decomposition is performed. The eigenvector corresponding to the smallest eigenvalue is taken as the normal vector, which provides a directional reference for the subsequent calculation of the deflection angle and correction of the local radiation pattern of the array element by the Euler rotation model, and ensures the polarization mismatch compensation effect.

[0086] The specific operation of 3D interpolation densification: Using the array set Ω' as the original data points, the Python functions scipy.interpolate.Rbf (radial basis function interpolation) or griddata (cubic interpolation) can be used. The interpolation grid density can be set: uniform grids are generated in the x, y, and z directions of the carrier, with a grid step size of 0.2d0 (e.g., step size = 1cm when d0 = 5cm). Interpolation calculations are performed on the grid nodes to obtain a dense point set Ω_dense, ensuring that the spacing between points in Ω_dense is ≤0.5d0, providing sufficient points for selecting neighboring point sets. Neighboring point set selection: For each q m ∈Ω', with q m Centered on a spherical region with radius r = d0, an Ω_dense KD tree can be constructed using scipy.spatial.KDTree. The query_ball_point function can be called to quickly filter out all points within the spherical region, forming a neighbor set N. m If N m If the number of midpoints K < 8, r can be increased to 1.2d0 until K ≥ 8 (to ensure the stability of the PCA algorithm).

[0087] Centralized processing and data matrix construction: Calculating N m mean vector Each point q j ∈N m Can be subtracted Obtain the centered vector All q can j Stack the columns to construct a K×3 data matrix X m (Each row corresponds to a centralized point, and each column corresponds to the x, y, and z directions). Covariance matrix calculation and eigenvalue decomposition: Covariance matrix C m =np.cov(X m ,rowvar=False)(rowvar=False means each column is a variable), resulting in a 3×3 C m Call np.linalg.eig(C m The eigenvalue λ can be obtained. m1 ≤λ m2 ≤λ m3 and the corresponding feature vector vm1 v m2 v m3 Take v m1 As q m normal vector n m At the same time, it can be applied to n m Normalize (n) m =n m / ||n m ||). Provides a directional reference for Euler rotations: n m The coordinates are stored, and when calculating the deflection angle later, n can be used directly. m The Euler angles are solved by the vector relationship with the global principal axis z0 to ensure the accuracy of the rotation matrix. This allows for precise matching of the surface orientation when correcting the local orientation pattern of the array elements. Technicians can use the above interpolation tools and linear algebra operations to estimate the normal vector, ensuring the polarization compensation effect.

[0088] Specifically, the Euler rotation model described in S3 adopts an external rotation sequence, which is a rotation about an ordered orthogonal axis of a fixed coordinate system, and its rotation matrix R = R x (γ)·R γ (β)·Rz(α), where α, β, and γ are the Euler angles of deflection about the corresponding fixed axes; based on the surface normal vector of the array element position, the local radiation pattern of the array element in the spherical coordinate system is converted into rectangular coordinates, and after rotation matrix operation, it is converted back to spherical coordinates to extract the principal polarization direction and obtain the polarization compensation phase. This provides a corrected array element pattern basis for calculating the initial array pattern and constructing the error function in S4.

[0089] The specific definition of the external rotation sequence: The fixed coordinate system is the array global coordinate system O-xyz, and the z-axis is the global principal axis (z0). External rotation means that each rotation can be performed around the axis of the fixed coordinate system, and the sequence is Z→Y→X: first rotate around the z-axis by an angle α (Rz(α)), then rotate around the y-axis by an angle β (R γ (β)), and finally rotate around the x-axis by an angle γ (R). x (γ)), ​​the rotation matrix can be combined in right-multiplication order to form R = R x (γ)R γ (β)Rz(α). Calculation of Euler angles (α,β,γ): Given the normal vector n m =(n mx ,n mγ ,n m (z)(after normalization), the global principal axis z0 = (0,0,1), and α is n m The angle between the projection onto the xy-plane and the x-axis is α = np.arctan2(n mγ ,n mx (Range [-π,π]); β is n mThe angle with the z-axis, β = np.arccos(n m z)(range [0,π]); γ is n m The rotation angle around its own axis can be set to γ ​​= 0 since the polarization direction of the array element is usually perpendicular to the normal vector (simplified calculation; if adjustment is needed, it can be set according to the array element type, such as γ = 0 if the polarization direction of the microstrip antenna is along the x-axis).

[0090] Radiation pattern coordinate transformation: The local radiation pattern f(θ',φ') in spherical coordinates (where θ' is the local polar angle of the array element and φ' is the azimuth angle) can be converted to rectangular coordinates E_xyz: E x = f(θ',φ')sinθ'cosφ', E γ =f(θ',φ')sinθ'sinφ', E_z=f(θ',φ')cosθ', forming the column vector E_xyz=[E x E γ Multiplying by the rotation matrix R on the left yields E'_xyz = R·E_xyz, which is the corrected Cartesian coordinate pattern. Returning to spherical coordinates: r = √(E'_xyz)^T; x 2 +E' γ 2 +E'_z 2 ), θ=arccos(E'_z / r), φ=arctan2(E' γ ,E' x This yields the radiation pattern f'(θ,φ)=r in the global coordinate system. Extracting the principal polarization phase: The principal polarization direction can be set to the θ direction, and the principal polarization component can be E'_θ=f'(θ,φ)sinθcosφ (or the φ component can be selected according to system requirements). The principal polarization component of the original local radiation pattern is E_θ=f(θ',φ')sinθ'cosφ', and the polarization compensation phase... (Argument of a complex number). This provides the basis for S4: f'(θ,φ) and When storing and calculating the initial radiation pattern in S4, f'(θ,φ) can be directly called and substituted. Phase compensation is performed to ensure that the error function is constructed based on the corrected radiation pattern. Technicians can perform the above steps through complex number operations and coordinate transformation formulas to ensure the accuracy of the radiation pattern correction.

[0091] Specifically, the ideal radiation pattern described in S4 is the radiation pattern of a regular area array of the same aperture, and the numerical algorithm is the least squares algorithm, which ultimately compensates for the phase. It provides an optimized compensation phase basis for S5 controllable sparsity, supporting the simplification of array elements while ensuring array performance.

[0092] The specific generation of the ideal radiation pattern: The aperture of a regular surface array of the same diameter can be consistent with the projected area of ​​the array set Ω' in the xy plane (e.g., if the projection of Ω' is a 1m×1m rectangle, then the regular surface array can be a 1m×1m rectangular array). The element spacing can be d0, and the number of elements can be close to the number of elements M in Ω' (e.g., if M=100, then the regular surface array can be 10×10 elements). The ideal radiation pattern F0(θ,φ)=Σ[exp(j2π / λ(x...]) can be calculated using the array factor formula. n sinθcosφ+y n sinθsinφ))],where (x n ,y n ) represents the element coordinates (e.g., x) of a regular surface array. n =nd0, y n =md0, n = 0, 1, ..., N x -1, m = 0, 1, ..., N γ -1), λ is the operating wavelength, and the z-direction component can be ignored (because the regular array is planar, z...). n =0), F0(θ,φ) can be normalized (maximum value is 1).

[0093] Implementation of the least squares algorithm: The optimization variable can be defined as the phase correction. (M variables, range [-π, π]), magnitude weight a m It can be fixed to 1 (for simplification and optimization, or a can be set to 1). m As a variable); the array pattern model function can be: Error function The summation points can be selected from key regions of the radiation pattern (the main lobe and ±30° side lobes, approximately 1000 angle points). Initial values ​​can be set using Python's `scipy.optimize.least_squares` function. Given bounds = [(-np.pi, np.pi)] * M, find the minimum value of J to obtain the optimal corrected phase. Final compensation phase calculation: It can be stored as an array. This provides a basis for S5: when S5 filters elements that can be turned off, only the elements need to be retained. Used for radiation pattern calculation, this method ensures that the retained array elements can maintain their performance through phase compensation. Technicians can solve the problem by setting optimization variables, boundary conditions, and calling optimization functions. At the same time, the reduction in J after optimization (e.g., J is reduced by more than 50%) can be verified to ensure the effect of radiation pattern optimization.

[0094] Specifically, the intelligent optimization algorithm described in S5 includes a genetic algorithm and / or a particle swarm optimization algorithm. The genetic algorithm has global search capabilities and can accurately select a subset of shut-off array elements that meet performance requirements in a multi-solution space constrained by the sidelobe level, thus adapting to the multi-objective requirements of controllable sparsity. The particle swarm optimization algorithm has efficient convergence characteristics and can quickly lock the optimal solution of the subset of shut-off array elements while ensuring that the sidelobe level does not exceed the limit, thereby improving the implementation efficiency of controllable sparsity.

[0095] The specific implementation of the Genetic Algorithm (GA): ① Encoding: Binary encoding can be used, chromosome length = L = M (M is the number of Ω' array elements), and each gene position g m ∈{0,1}, g m =1 indicates that the m-th array element is retained, g m =0 indicates off; ② Population initialization: N_pop=80 chromosomes can be generated, each gene locus is randomly generated, and the number of 1s (reserved elements) of each chromosome can be ensured to be between 0.3M and 0.7M to avoid the initial population being too extreme; ③ Fitness calculation: For each chromosome G=[g1,g2,...,g_M], the index of the retained elements I={m|g m =1}, calculate the corresponding array pattern. The maximum amplitude value SL of the extractable sidelobe region (|θ-θ0|>θ1, θ0 is the main lobe pointing direction, θ1 is the main lobe half-power beamwidth, such as θ1=5°) is SL=max(|F_G(θ,φ)|)(dB value, SL=20log10(SL_linear)); if SL≤-30dB (constraint condition), fitness=len(I) / M (sparseness, maximizing the objective); otherwise fitness=len(I) / M-(SL+30) / 50 (penalty term, the larger the constraint SL, the lower the fitness).

[0096] ④ Genetic operations: The selection operator can use tournament selection, randomly selecting 3 chromosomes and retaining the one with the highest fitness to enter the next generation; the crossover operator can use single-point crossover, randomly selecting crossover point k and exchanging the gene positions after the two parent chromosomes k, with a crossover probability P_c = 0.8; the mutation operator can use positional mutation, flipping each gene position with a probability P_m = 0.01; ⑤ Iteration termination: The number of iterations N_gen = 100. The optimal chromosome can be recorded in each iteration. After the iteration ends, the I corresponding to the chromosome with the highest fitness can be selected as the retained matrix subset Ω. s .

[0097] The specific implementation of Particle Swarm Optimization (PSO): ① Particle encoding: Each particle's position vector X = [x1, x2, ..., x_M], x m ∈{0,1}, velocity vector V=[v1,v2,...,v_M], vm ∈[-v_max,v_max](v_max=0.5); ② Initialization: N_particle=50 particles can be generated, X is randomly generated (the number of 1s ∈[0.3M,0.7M]), V is initialized to 0; ③ Fitness calculation is the same as GA; ④ Velocity and position update: Inertia weight ω=0.9-0.4*(t / N_gen) (linearly decreasing, t is the current iteration number), learning factor c1=c2=2, individual best P_best is the best historical position of each particle, global best G_best is the best historical position of all particles; v m =ω*v m +c1*rand()*(P_best[m]-X[m])+c2*rand()*(G_best[m]-X[m]); The Sigmoid function can be used to convert v m Mapped to probability: p m =1 / (1+exp(-v) m If rand() < p m Then x m =1, otherwise x m =0; ⑤ Iteration termination is the same as GA. Technical personnel can implement the above algorithm using the deap library (GA) or the pyswarm library (PSO), and compare the convergence speed and optimization results of the two algorithms to select the optimal Ω. s This ensures that the sparsity is maximized under the sidelobe constraint, thereby improving implementation efficiency.

[0098] A system for the layout, polarization compensation, and optimization of a complex curved surface conformal array includes at least one processor 1 and at least one memory 2. The memory 2 stores a computer program 3, a point cloud processing module 4, a layout module 5, a polarization compensation module 6, a radiation pattern optimization module 7, and a sparsity reduction module 8. The computer program 3 is electrically connected to each module. The processor 1 is used to read and execute the computer program 3 in the memory 2. When the computer program 3 is executed, it calls and coordinates the work of each module.

[0099] Point cloud processing module 4 is used to acquire digital models of complex three-dimensional carrier structures and discretize them into three-dimensional point cloud data, and standardize and represent the point cloud data as a set Ω = {p n =(x n ,y n ,z n The data for distance calculation, orientation selection, and quantization calculation in the array module 5 is based on the n = 1, 2, ..., N.

[0100] The array module 5 is used to receive the point cloud data, filter candidate points that meet the requirements of distance tolerance ≤ 2% × minimum array element spacing and angle tolerance ≤ 5° based on the hexagonal rule and minimum array element spacing constraint, and eliminate overlapping points by determining whether the distance between the new candidate point and the selected array element point is less than the minimum array element spacing minus the preset tolerance δ, and generate an array element array set to provide standardized array element position data for the polarization compensation module 6.

[0101] The polarization compensation module 6 is used to receive the array set, estimate the surface normal vector of the array element position through the principal component analysis algorithm, and correct the local radiation pattern of the array element to the global coordinate system based on the Euler rotation model to achieve polarization mismatch compensation, and provide the corrected array data for the radiation pattern optimization module 7.

[0102] The pattern optimization module 7 is used to receive the array data after polarization compensation, construct an error function with the pattern of the same aperture regular area array as an ideal reference, solve the amplitude and phase weighted compensation value through the least squares algorithm and minimize the pattern error, and provide the optimized compensation phase basis for the sparsification module 8.

[0103] The sparsification module 8 is used to receive the optimized results and, with the sidelobe level as a constraint, uses a genetic algorithm and / or a particle swarm optimization algorithm to screen out a subset of array elements that can be turned off, thereby achieving array sparsification.

[0104] System Hardware Selection: Processor 1 can be an Intel Core i7-12700H or AMD Ryzen 76800H (meeting the requirements of multi-module parallel computing, with a main frequency ≥2.7GHz and ≥12 cores). Memory 2 can be 16GB DDR4 memory (ensuring data caching and avoiding computational lag) and a 1TB SSD (for storing digital models, point cloud data, and calculation results). A dedicated graphics card (such as an NVIDIA RTX 3060 to accelerate radiation pattern drawing and 3D visualization) can also be provided. Software Environment Configuration: The operating system can be Windows 10 / 11 or Ubuntu 20.04. The programming language can be Python 3.9 (equipped with numpy, scipy, pandas, and matplotlib libraries) and MATLAB R2022b (for the electromagnetic calculation and optimization toolbox). The computer program 3 can adopt modular programming, with each module encapsulated as a function (such as point_cloud_processing(), hexagonal_arrangement(), etc.). The main program main() calls the functions of each module to achieve collaborative work.

[0105] Processor 1 execution flow: ① The main program can read user input parameters (such as element spacing d0, operating wavelength λ, sidelobe constraint SL_max); ② It can call the point cloud processing module 4 function, input a digital model file (such as .stl format), and output the point cloud set Ω; ③ It can call the array layout module 5 function, input Ω and d0, and output the array layout set Ω'; ④ It can call the polarization compensation module 6 function, input Ω', and output the corrected radiation pattern f. m 'With polarization compensation phase ⑤ The function in the pattern optimization module 7 can be called, input f m '、 Based on the ideal radiation pattern parameters, output the final compensated phase. ⑥ You can call the sparsification module 8 function, and input Ω', With SL_max, output the sparse matrix subset Ω s ⑦ All results can be stored to SSD and plotted using matplotlib.

[0106] Data transfer between modules: Intermediate results (such as Ω, Ω') can be serialized and stored using Python's pickle library, or real-time data transfer can be achieved through a shared memory array (such as multiprocessing.Array) to avoid file read and write delays. Technicians can ensure that each module works together and complete the conformal array design by selecting the above hardware, configuring the software and programming.

[0107] Core module functions include: ① Digital model acquisition: The module can read the constructed carrier model (.sldprt format) by calling CAD software (such as SolidWorks API) through the API interface, or read the original point cloud file (.ply or .pcd format) generated by 3D scanning through the Open3D library. If the model is a curved mesh (.stl format), the Open3D read_triangle_mesh function can be called to read it, and then the sample_points_uniformly function can be used to uniformly sample the mesh to generate the point cloud.

[0108] ② Discretization: Sampling parameters can be set, and the number of sampling points N is determined based on the carrier surface area S and the point cloud density ρ (N = S × ρ, e.g., S = 1m). 2 ρ = 400 points / m 2 Then N=400), during sampling, non-array areas of the carrier (such as holes, edges) can be avoided, and points with x<0 or y>1m can be filtered out by coordinate range. ③ Standardized representation: The NumPy library can be used to convert the sampling point coordinates into an N×3 array, with each row corresponding to p n =(x n ,y n ,z nThe system can remove duplicate points (using the numpy.unique function, tolerance = 1e-6), generate an array representation of the set Ω, and save it as a .csv file (column names "x,y,z"). ④ Data preprocessing: The scipy.signal.medfilt function can be called to perform median filtering on the coordinates (window size = 3) to remove noise points; if the carrier coordinate range is too large (e.g., x∈[0,100m]), normalization can be performed: x' = x / x_max, y' = y / y_max, z' = z / z_max (x_max is the maximum coordinate in the x-direction), and the normalization parameters (x_max, y_max, z_max) can be saved for subsequent restoration.

[0109] This provides a foundation for subsequent modules: the array of Ω and its file path can be passed to the array module 5. The array module 5 can call numpy.linalg.norm to calculate the point spacing and numpy.dot to calculate the vector angle. No additional data format conversion is required. Technicians can implement the module's functions through the combination of Open3D and numpy functions, ensuring the standardization and high quality of point cloud data.

[0110] Module reception and initialization: Receive the Ω array (N×3) transmitted by the point cloud processing module 4, read the user-defined minimum element spacing d0 and tolerance parameters (distance tolerance ε_d=0.02d0, angle tolerance ε_θ=5°, δ=0.1d0), and construct the KD tree of Ω through scipy.spatial.KDTree for fast nearest neighbor search.

[0111] Hexagonal rule implementation: ① Initial point selection: Calculate the distance from all points in Ω to the edge of the carrier (using the distance formula from a point to a plane, where the plane is the fitted plane of the carrier edge). Points ≥ d0 from the edge and located in the center of the carrier can be selected as initial points p0 (if multiple candidate points exist, the point with the largest y-coordinate can be selected); ② Reference point selection: Call the query_ball_point function of KDTree to find points around p0 within the range [d0-ε_d, d0+ε_d]. The point with the largest x-coordinate among these points can be selected as the reference point p. 1. Calculate the reference vector v0 = p1 - p0, and normalize it to v0_unit = v0 / np.linalg.norm(v0); ③ Generate six directions: generate rotation angle θ_k = k × 60° (k = 0, 1, ..., 5). Rotate v0_unit around the z-axis by θ_k to obtain the direction vector v_k = rotate_vector(v0_unit, θ_k) (the rotate_vector function can be implemented through the rotation matrix: v_k = Rz(θ_k)·v0_unit).

[0112] Candidate point selection and overlap removal: ① Initialize the selected set S = [p0, p1]; ② For each θ_k (k = 1, ..., 5): calculate the target direction v_k, call KDTree's query_ball_point(p0, d0 + ε_d) to obtain the set of points Q around p0 with a distance ≤ d0 + ε_d; for each q ∈ Q, calculate the vector pq = q - p0, and the angle α = np.degrees(np.arccos(np.dot(pq / np.linalg.norm(pq), v_k))); if α ≤ ε_θ and np.linalg.norm(pq) ≥ d0 - ε_d, then q can be added to the candidate set C; ③ Overlap determination: for each q ∈ C, calculate the distance between q and all points in S. If all distances ≥ d0 - δ, then q can be added to S, and C is updated to empty.

[0113] ④ Recursive Expansion: For each point q_center in S except p0: Repeat steps ②-③, using q_center as the center, find its reference point (a point in S with a distance of [d0-ε_d, d0+ε_d] from q_center), generate six direction vectors, filter candidate points and remove overlaps, until C is empty or S covers the effective area of ​​the carrier; ⑤ Generate Array Set: S can be converted into an M×3 array (M is the number of points in S), which is Ω', saved as a .txt file, and passed to the polarization compensation module 6. Technicians can implement the module function through KD-tree nearest neighbor search, vector rotation, and distance comparison to ensure that the generated Ω' meets the spacing and tolerance constraints, providing standardized data for polarization compensation.

[0114] Attached Figure Figure 3 Analysis of Figures (a)-(b):

[0115] (a): Light green points are non-all sampling points, red points are the initial selected center points, green points are reference points, and purple points are the first layer of point search results that meet the hexagonal constraint conditions.

[0116] (b) is the overall result after the first round of point finding, with the adjacent spacing d as the unit, and the maximum error range of the spacing between each point does not exceed 2%.

[0117] (c) Using the blue dot as the center point of the second round of point search and the green dot as the reference point of the second round of point search, continue to expand outward to search for points.

[0118] (d) Schematic diagram of the results after the second round of point search.

[0119] Module Reception and Preprocessing: Receives the Ω' array (M×3) transmitted by array module 5, reads the local radiation pattern data of the array elements (such as the .txt format radiation pattern exported from HFSS, containing θ', φ', and f(θ',φ')), and can set the global principal axis direction z0 = (0,0,1). PCA Normal Vector Estimation: ① Three-dimensional interpolation refinement: The scipy.interpolate.griddata function can be called to generate a grid in the x, y, and z directions of the carrier with Ω' as the original point (step size = 0.2d0), and a dense point set Ω_dense is obtained by cubic interpolation; ② Neighbor selection: Constructs the KD tree of Ω_dense, and selects the nearest neighbor point set for each q m ∈Ω', call query_ball_point(q m ,d0) yields the neighbor set N m If len(N) m If ) < 10, the radius can be expanded to 1.2d0; ③ Centering and matrix operations: N m Calculate the mean after arraying Centralized matrix The covariance matrix C = np.cov(X, rowvar = False), the eigenvalues ​​λ and eigenvectors v = np.linalg.eig(C), and the v corresponding to the smallest λ is taken as the normal vector n. m After normalization, it can be stored.

[0120] Euler rotation and pattern correction: ① Euler angle calculation: for each n m ,α=np.degrees(np.arctan2(n m [1],n m [0])), β=np.degrees(np.arccos(n m[2])), γ=0; ② Rotation matrix calculation: Rz=[[np.cos(α_rad),-np.sin(α_rad),0],[np.sin(α_rad),np.cos(α_rad),0],[0,0,1]], Ry=[[np.cos(β_rad),0,n p.sin(β_rad)],[0,1,0],[-np.sin(β_rad),0,np.cos(β_rad)]], Rx=[[1,0,0],[0,np.cos(γ_rad),-np.sin(γ_rad)],[0,np.sin(γ_rad), np.cos(γ_rad)]],R=Rx@Ry@Rz(α_rad=np.radians(α), similarly β_rad、γ_rad); ③ Radiation pattern conversion: The local radiation pattern (θ',φ') can be converted to rectangular coordinates E_xyz=[np.sinθ'_rad*np.cosφ'_rad,np.sinθ'_rad*np.sinφ'_rad,np.cosθ'_rad]^T*f(θ',φ'), E'_xyz=R@E_xyz, converting back to spherical coordinates gives f'(θ,φ)=np.linalg.norm(E'_xyz); ④ Polarization compensation phase: (Calculate the argument by taking the x-component). Data output: The f'(θ,φ) array can be combined with... The array is packaged and passed to the radiation pattern optimization module 7. Technicians can implement the module's functions through linear algebra operations and coordinate transformations to ensure that polarization mismatch is accurately compensated.

[0121] Module reception and initialization: Receive the f'(θ,φ) array (M×K, K is the number of angle points) transmitted by polarization compensation module 6. Array (M×1), read the working wavelength λ, and parameters of the same aperture regular area array (such as the number of array elements N). x ×N γ (Spacing d0). Ideal pattern generation: ① Regular area matrix coordinates: x_n = n * d0 (n = 0,...,N) x -1), y_m=m*d0(m=0,...,N γ-1), which can generate a coordinate array (x_ideal, y_ideal, 0); ② Array factor calculation: For each angle point (θ, φ) (K points), calculate the phase factor k = 2π / λ, phase term = k * (x_ideal * np.sinθ * np.cosφ + y_ideal * np.sinθ * np.sinφ), ideal radiation pattern F0(θ, φ) = np.abs(np.sum(np.exp(1j * phase_term))), which can be normalized (F0 = F0 / max(F0)). Error function construction: initial radiation pattern Error function J = np.sum((F_initial-F0)**2).

[0122] Least squares solution: Define the optimization function The function `reshape(F_opt-F0,-1)` returns `np.reshape(F_opt-F0,-1)`. You can call `scipy.optimize.least_squares(fun,x0=np.zeros(M),bounds=(-np.pi,np.pi))` to get the optimal shape. Final compensation phase: It can be saved as a .npy file. This provides a basis for the sparsity module 8: it can... The optimized radiation pattern F_opt is passed to the sparsification module 8 to ensure the accuracy of the array element phase compensation parameters during the sparsification process. Technicians can optimize the radiation pattern through the above steps, and at the same time, they can draw a comparison of the radiation patterns before and after optimization to verify the sidelobe suppression effect.

[0123] Module reception and parameter settings: Receive pattern optimization module 7 transmits... The arrays are M×1 and f'(θ,φ) array (M×K). The sidelobe constraint SL_max = -30dB is set, and the optimization objective is to maximize the sparsity ratio ρ. Genetic algorithm implementation: ① Population initialization: 80 binary chromosomes (length M) can be generated, and gene positions are randomly generated to ensure that the initial ρ∈[0.3,0.7]; ② Fitness calculation: For each chromosome, the element index corresponding to "1" is extracted, and the sparse array pattern is calculated. Calculate the SL of the sidelobe region (|θ-θ0|>5°) as 20*np.log10(max(F_sparse[side_lobe_idx])); if SL≤SL_max, fitness=len(idx) / M; otherwise fitness=len(idx) / M-(SL-SL_max) / 10.

[0124] ③ Genetic operations: Roulette wheel selection (selection probability = fitness / sum(fitness)), two-point crossover (crossover probability 0.7), and random mutation (mutation probability 0.005) can be used; ④ Iteration termination: After 100 iterations, the chromosome with the highest fitness is selected as the optimal solution, and the corresponding idx is the subset Ω of retained elements. s .

[0125] Particle Swarm Optimization Implementation: ① Particle Initialization: 50 particles, position X is an M-dimensional binary vector, velocity V∈[-0.5,0.5]; ② Velocity Update: V=0.7*V+1.5*np.random.rand(M)*(P_best-X)+1.5*np.random.rand(M)*(G_best-X); ③ Position Update: X=np.where(np.random.rand(M)<1 / (1+np.exp(-V)),1,0); ④ Fitness Calculation is the same as GA, and the optimal Ω is output after 100 iterations. s Output result: Ω can be output. s The index, sparsity ρ, and sparse array pattern are used to verify that SL≤SL_max. Technicians can achieve sparsification through the above algorithm, and compare the optimization time and effect of different algorithms to select the optimal solution, thereby reducing system costs while ensuring array performance.

[0126] Specifically, the array module 5 has a built-in parameter configuration submodule 9 and an overlap and conflict detection submodule 11. The parameter configuration submodule 9 is electrically connected to the computer program 3 and is used to support users to customize the minimum spacing, distance tolerance, and angle tolerance of array elements, providing quantitative constraint standards for candidate point screening. The overlap and conflict detection submodule 11 works in conjunction with the parameter configuration submodule 9 to eliminate overlapping points by determining whether the distance between a new candidate point and a selected array element point is less than the minimum array element spacing minus the preset tolerance δ, ensuring that the array element set meets the spacing constraint requirements.

[0127] The parameter configuration submodule 9 implements the following: ① Interface design: A visual interface can be designed using Tkinter or PyQt, providing input boxes for users to set d0 (default λ / 2), distance tolerance ε_d (default 2% d0), angle tolerance ε_θ (default 5°), and δ (default 0.1d0). After setting, the settings can be saved as a .json configuration file for use by the array deployment module 5; ② Parameter verification: The submodule can automatically verify the rationality of the input parameters (such as d0>0, ε_d∈[0,5% d0], ε_θ∈[0,10°]). If the parameters are invalid, a prompt will pop up and the default values ​​will be reset.

[0128] Implementation of the overlapping conflict detection sub-module 11: ① Distance calculation: Receive d0 and δ passed by the parameter configuration sub-module 9. For the new candidate point q_new, the Euclidean distance dist = np.linalg.norm(q_new - S, axis = 1) between it and all points in the selected set S can be calculated; ② Conflict determination: If min(dist) < d0 - δ, it is determined as overlapping, marked as "conflict point" and removed; otherwise, it is determined as "valid point" and added to S; ③ Batch detection: Vectorized operation (np.linalg.norm(q_new[:, None] - S, axis = 2)) can be used to batch calculate the distances between multiple new candidate points and S, improving the detection efficiency.

[0129] Cooperation of the dual modules: After the parameter configuration sub-module 9 updates the parameters, they can be synchronized to the overlapping conflict detection sub-module 11 in real time to ensure consistent constraint standards; the detection sub-module can feedback the number of conflict points and the number of valid points to the interface of the configuration sub-module for the user to view the progress of the array layout. Technicians can customize parameters and perform overlapping detection through the above design, improving the flexibility and reliability of the array layout module 5.

[0130] Specifically, the polarization compensation module 6 internally includes a normal vector estimation sub-module 12 and a pattern correction sub-module 13. The normal vector estimation sub-module 12 is used to estimate the surface normal vector of the array element position through the principal component analysis algorithm of three-dimensional interpolation encryption, centering of the adjacent point set, construction of the data matrix, and eigenvalue decomposition of the covariance matrix; the pattern correction sub-module 13 is electrically connected to the normal vector estimation sub-module 12. Based on the surface normal vector, the local pattern of the array element in the spherical coordinate system is converted to the rectangular coordinate by the external rotation sequence around the ordered orthogonal axes of the fixed coordinate system, and then rotated back to the spherical coordinate through the rotation matrix operation, extracting the main polarization direction and generating the polarization compensation phase To achieve polarization mismatch compensation and provide corrected array data for the pattern optimization module 7.

[0131] Implementation of the normal vector estimation sub-module 12: ① Interpolation encryption: Receive the array layout set Ω', and call scipy.interpolate.Rbf(x = Ω'[:, 0], y = Ω'[:, 1], z = Ω'[:, 2], function ='multiquadric') to generate an interpolation function, generate a grid with a step size of 0.2d0 in the x, y, and z directions, and calculate to obtain Ω_dense; ② Selection of the adjacent point set: Construct KDTree(Ω_dense), for each q m ,it is possible to query the points N within a radius of d0 m If the quantity is insufficient, the radius is enlarged; ③ PCA calculation: For N mCentralize, construct the X matrix, calculate C = np.cov(XT), eigvals, eigvecs = np.linalg.eig(C), n m =eigvecs[:,np.argmin(eigvals)], which can be normalized and stored as a .npy file.

[0132] Implementation of pattern correction submodule 13: ① Euler angle calculation: Receive n m An array can be used to calculate α = np.arctan2(n m [:,1],n m [:,0]), β=np.arccos(n m [:,2]), γ=np.zeros(M); ② Rotation matrix: For each element, the Rz, Ry, and Rx matrices can be calculated and multiplied to obtain R; ③ Pattern conversion: Read the local pattern f_local(θ',φ') and convert it to E_local=[f_local*np.sinθ'*np.cosφ',f_local*np.sinθ'*np.sinφ',f_local*np.cosθ']; E_global=R@E_local; Convert back to spherical coordinates to obtain f_global=np.linalg.norm(E_global,axis=0); ④ Polarization phase: (x-component argument). Data output: f_global can be compared with... The vector is passed to the pattern optimization module 7. Technicians can use the above sub-modules to estimate the normal vector and correct the pattern, ensuring accurate polarization compensation. At the same time, the normal vector visualization results can be output to verify its fit with the surface.

[0133] The working principle of this invention is as follows: First, the digital model of the carrier is acquired and discretized into a standardized point cloud set Ω, eliminating the dependence on surface analysis and providing a unified data foundation for subsequent calculations. Then, with the minimum spacing between array elements as a constraint, initial and reference points are selected from the point cloud according to the hexagonal rule. Candidate points that meet the distance (tolerance ≤ 2% × minimum spacing) and angle (tolerance ≤ 5°) requirements are recursively expanded and screened, and overlapping points are eliminated to form the array set Ω'. Next, the PCA algorithm is used to estimate the array element normal vectors. Combined with the ZYX external rotation Euler rotation model, the local radiation pattern of the array elements is corrected to the global coordinate system through the rotation matrix to compensate for polarization mismatch. Subsequently, with the radiation pattern of the regular surface array of the same aperture as an ideal reference, an error function is constructed, and the amplitude and phase weighted compensation value is solved using the least squares algorithm to minimize the radiation pattern error. Finally, with Ω' as the initial solution and the sidelobe level as a constraint, array elements that can be turned off are screened through a genetic algorithm (binary encoding, population iteration) or a particle swarm optimization algorithm (binary position vector, velocity update) to achieve array sparsity.

[0134] At the system level, the processor 1, memory 2, and computer program 3 work together to support the operation of each module. After reading the program, the processor 1 sequentially calls the point cloud processing, array layout, polarization compensation, radiation pattern optimization, and sparsification modules 8. Each module receives the preceding output data (such as point cloud Ω and array set Ω') and executes the corresponding function. The hardware uses a high-performance processor 1 (such as Intel Core i7-12700H), large memory, and SSD to ensure computing efficiency. The software uses Python (with NumPy and SciPy libraries) and MATLAB to implement modular programming. The modules pass data through serialized storage or shared memory arrays to avoid delays, forming an automated process from data input to result output (array pattern and radiation pattern) without much manual intervention.

[0135] Key modules enhance functional accuracy and flexibility through built-in sub-modules: Arraying module 5 has a built-in parameter configuration sub-module 9, which supports user-defined parameters such as array element spacing and tolerance and automatically verifies their rationality. Combined with the overlap and conflict detection sub-module 11, it uses vectorized operations to batch detect the distance between candidate points and selected points, accurately eliminating overlapping points. Polarization compensation module 6 has a built-in normal vector estimation sub-module 12, which accurately extracts surface normal vectors through 3D interpolation encryption and PCA algorithm. Combined with the radiation pattern correction sub-module 13, it uses Euler angle calculation and rotation matrix operations to transform the local radiation pattern of the array elements to the global coordinate system and extract the polarization compensation phase, ensuring thorough compensation for polarization mismatch and providing high-quality data support for subsequent optimization.

[0136] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention in any way. Although the present invention has been disclosed above with reference to preferred embodiments, it is not intended to limit the present invention. Any person skilled in the art can make some modifications or alterations to the above-disclosed technical content to create equivalent embodiments without departing from the scope of the present invention. Any simple modifications, equivalent changes and alterations made to the above embodiments based on the technical essence of the present invention without departing from the scope of the present invention shall still fall within the scope of the present invention.

Claims

1. A method for the layout, polarization compensation, and optimization of conformal arrays of complex curved surfaces, characterized by: Includes the following steps: S1. Point cloud discretization: Obtain a digital model of a complex three-dimensional carrier structure and discretize it into three-dimensional point cloud data; S2. Hexagonal regular array: With the preset minimum spacing of array elements as a constraint, the initial point and the reference point are selected from the point cloud data, and the array is recursively expanded outward according to the hexagonal geometric rules. Candidate points that meet the distance and angle tolerances are screened, and overlapping points are removed to form an array element set. S3. Polarization Compensation: Estimate the surface normal vector at each element position, calculate the deflection angle between the element normal vector and the global principal axis direction of the array based on the Euler rotation model, and correct the local radiation pattern of the element to the global coordinate system through the rotation matrix to compensate for polarization mismatch. S4. Pattern Optimization: Calculate the initial array pattern after polarization compensation, construct an error function with the ideal pattern as a reference, solve the amplitude and phase weighted compensation value through numerical algorithm, and minimize the pattern error; S5. Controllable sparsity: Using the array set as the initial solution and the sidelobe level as a constraint, an intelligent optimization algorithm is used to select a subset of array elements that can be turned off, thereby realizing the array sparsity design.

2. The method for arranging, polarization compensation, and optimizing complex curved surface conformal arrays according to claim 1, characterized in that: The three-dimensional point cloud data described in S1 is denoted as set Ω = {pm = (x n ,yn,z n Let pn be the three-dimensional coordinates of the nth point and N be the total number of point clouds. This set-based definition enables the standardized representation of point cloud data, providing a data foundation for distance calculation, orientation screening, and quantization operations of candidate points in S2.

3. The method for arranging, polarization compensation, and optimizing complex curved surface conformal arrays according to claim 1, characterized in that: In S2, the hexagonal geometric rule generates six target directions at 60° intervals, centered on the initial point. The reference point anchors the orientation of the first target direction. When recursively expanding outward, the selected candidate points are used as new array element points. The hexagonal rule is repeated with these array element points as the center to generate new target directions. The selection of candidate points must meet the following requirements: the distance from the current central array element point must fall within the minimum spacing error range; the angle between the line connecting the candidate point to the central array element point and the corresponding target direction must be within the tolerance range; the distance tolerance ≤ 2% × minimum spacing, and the angle tolerance ≤ 5°. When the distance between a new candidate point and a selected array element point is less than the minimum spacing minus the preset tolerance δ, it is determined to be an overlapping point and is removed. Finally, an array element layout set is formed, providing array element position data support for the calculation of array element normal vectors and polarization compensation in S3.

4. The method for arranging, polarization compensation, and optimizing complex curved surface conformal arrays according to claim 1, characterized in that: In S3, the principal component analysis algorithm is used to estimate the normal vector of the array element. By performing three-dimensional interpolation and densification on the array set, the set of neighboring points of each array element is selected, and after centering, a data matrix is ​​constructed. The covariance matrix is ​​calculated and eigenvalue decomposition is performed. The eigenvector corresponding to the smallest eigenvalue is taken as the normal vector, which provides a directional reference for the subsequent calculation of the deflection angle and correction of the local radiation pattern of the array element by the Euler rotation model, and ensures the polarization mismatch compensation effect.

5. The method for arranging, polarization compensation, and optimizing complex curved surface conformal arrays according to claim 1 or 4, characterized in that: The Euler rotation model described in S3 uses an external rotation order, which is a rotation about an ordered orthogonal axis of a fixed coordinate system, with a rotation matrix R = R x (γ)·R γ (β)·Rz(α), where α, β, and γ are the Euler angles of deflection about the corresponding fixed axes; based on the surface normal vector of the array element position, the local radiation pattern of the array element in the spherical coordinate system is converted into rectangular coordinates, and after rotation matrix operation, it is converted back to spherical coordinates to extract the principal polarization direction and obtain the polarization compensation phase. This provides a corrected array element pattern basis for calculating the initial array pattern and constructing the error function in S4.

6. The method for arranging, polarization compensation, and optimizing complex curved surface conformal arrays according to claim 1, characterized in that: The ideal radiation pattern described in S4 is the radiation pattern of a regular area array of the same aperture. The numerical algorithm is the least squares algorithm, which ultimately compensates for the phase. It provides an optimized compensation phase basis for S5 controllable sparsity, supporting the simplification of array elements while ensuring array performance.

7. The method for arranging, polarization compensation, and optimizing complex curved surface conformal arrays according to claim 1, characterized in that: The intelligent optimization algorithm described in S5 includes a genetic algorithm and / or a particle swarm optimization algorithm. The genetic algorithm has global search capabilities and can accurately screen the subset of shut-off array elements that meet performance requirements in a multi-solution space constrained by the sidelobe level, thus adapting to the multi-objective requirements of controllable sparsity. The particle swarm optimization algorithm has efficient convergence characteristics and can quickly lock the optimal solution of the subset of shut-off array elements while ensuring that the sidelobe level does not exceed the limit, thereby improving the implementation efficiency of controllable sparsity.

8. A system for arranging, polarization compensation, and optimizing complex curved surface conformal arrays, employing the method for arranging, polarization compensation, and optimization of complex curved surface conformal arrays as described in any one of claims 1 to 7, characterized in that: It includes at least one processor (1) and at least one memory (2). The memory (2) stores a computer program (3), a point cloud processing module (4), an array module (5), a polarization compensation module (6), a radiation pattern optimization module (7), and a sparsification module (8). The computer program (3) is electrically connected to each module. The processor (1) is used to read and execute the computer program (3) in the memory (2). When the computer program (3) is executed, it calls and coordinates the work of each module. The point cloud processing module (4) is used to acquire the digital model of the complex three-dimensional carrier structure and discretize it into three-dimensional point cloud data, and to standardize and represent the point cloud data as a set Ω={pn=(x n ,yn,z n The data base for distance calculation and orientation selection of the array module (5) is provided by |n=1,2,...,N}. The array module (5) is used to receive the point cloud data, filter candidate points that meet the requirements of distance tolerance ≤ 2% × minimum array element spacing and angle tolerance ≤ 5° based on the hexagonal rule and minimum array element spacing constraint, and eliminate overlapping points by determining whether the distance between the new candidate point and the selected array element point is less than the minimum array element spacing minus the preset tolerance δ, and generate an array element array set to provide standardized array element position data for the polarization compensation module (6). The polarization compensation module (6) is used to receive the array set, estimate the surface normal vector of the array element position through the principal component analysis algorithm, and correct the local radiation pattern of the array element to the global coordinate system based on the Euler rotation model to realize polarization mismatch compensation, and provide the corrected array data for the radiation pattern optimization module (7). The pattern optimization module (7) is used to receive the array data after polarization compensation, construct the error function with the pattern of the regular array of the same aperture as the ideal reference, solve the amplitude and phase weighted compensation value and minimize the pattern error through the least squares algorithm, and provide the optimized compensation phase basis for the sparsification module (8). The sparsification module (8) is used to receive the optimized result, and uses the sidelobe level as a constraint to select the subset of array elements that can be turned off by using a genetic algorithm and / or a particle swarm optimization algorithm to achieve array sparsification.

9. The arraying, polarization compensation, and optimization system for complex curved surface conformal arrays according to claim 8, characterized in that: The array module (5) has a built-in parameter configuration submodule (9) and an overlap and conflict detection submodule (11). The parameter configuration submodule (9) is electrically connected to the computer program (3) and is used to support users to customize the minimum spacing, distance tolerance, and angle tolerance of array elements, providing quantitative constraint standards for candidate point screening. The overlap and conflict detection submodule (11) works in conjunction with the parameter configuration submodule (9) to automatically eliminate overlapping points by determining whether the distance between the new candidate point and the selected array element point is less than the minimum array element spacing minus the preset tolerance δ, ensuring that the array element array set meets the spacing constraint requirements.

10. The system for arranging, polarization compensation, and optimizing complex curved surface conformal arrays according to claim 8, characterized in that: The polarization compensation module (6) has a built-in normal vector estimation submodule (12) and a pattern correction submodule (13). The normal vector estimation submodule (12) is used to estimate the surface normal vector of the array element position through principal component analysis algorithms such as three-dimensional interpolation encryption, neighbor set centering, data matrix construction, and covariance matrix eigenvalue decomposition. The pattern correction submodule (13) is electrically connected to the normal vector estimation submodule (12). Based on the surface normal vector, the local pattern of the array element in the spherical coordinate system is converted into rectangular coordinates by an external rotation sequence around the ordered orthogonal axes of the fixed coordinate system. After rotation matrix operation, it is converted back to spherical coordinates, the main polarization direction is extracted, and the polarization compensation phase is generated. Polarization mismatch compensation is achieved, providing corrected array data for the pattern optimization module (7).

Images