Mountain wind power plant fan chain type layout data optimization calculation method

Abstract

The invention relates to the field of new energy development and construction, and discloses a mountain wind power plant fan chain type layout data optimization calculation method. Comprising the following steps of S1, ridge line extraction and elevation driving vector construction, S2, initial point determination and initial direction calibration, S3, chain type layout path planning, S4, fan coordinate calculation, S5, wake effect suppression algorithm application, and S6, fan screening, state marking and coordinate output. According to the method, the elevation driving vector rule is constructed, and the ridge line elevation vector is extracted based on DEM data, so that the fans are distributed in a chained manner along the dominant features of the terrain, the mountain fluctuating form is accurately adapted, and the wind energy loss caused by terrain shielding is avoided. Meanwhile, in combination with automatic chain planning, chain extension is performed from the starting point along the ridge line, and the three-dimensional coordinates of the fan are automatically calculated, so that the complex mountain data processing efficiency is improved by more than three times compared with a traditional manual method, the early-stage design period is greatly shortened, and the arrangement efficiency is remarkably optimized.

Description

Technical Field

[0001] This invention relates to the field of new energy development and construction, specifically to a method for optimizing and calculating data on the chain-like deployment of wind turbines in mountainous wind farms. Background Technology

[0002] Mountain wind farms are wind energy development projects built in mountainous environments with large topographic relief and complex elevation changes. The distribution of wind energy resources is significantly affected by factors such as topographic cutting, elevation gradient, and slope aspect. The layout of wind turbines must take into account both the effects of topographic shielding and wake effect in order to achieve efficient utilization of wind energy resources. This is a planning and design scenario with high requirements for topographic adaptability in the field of new energy development.

[0003] Existing technologies for wind turbine layout in mountainous wind farms have incorporated Geographic Information System (GIS) and Digital Elevation Model (DEM) for terrain analysis. By extracting terrain features such as ridgelines, wind turbines are laid out in combination with empirical rules. At the same time, some methods use wake propagation models to calculate the wake effects between wind turbines, providing a reference for spacing adjustments and improving the scientific nature of the layout to some extent.

[0004] The most critical shortcoming of existing technologies is that they fail to establish a linkage rule between the elevation change vector and the wake effect analysis, and cannot achieve dynamic coupling of "elevation-wake-deployment". This makes it difficult for wind turbines to adapt to the characteristics of mountainous terrain and form an efficient chain distribution, and it is difficult to take into account the synergistic optimization of terrain adaptability and wake suppression. In view of this, we propose a data optimization calculation method for chain deployment of wind turbines in mountainous wind farms. Summary of the Invention

[0005] To address the shortcomings of existing technologies, this invention provides a data optimization calculation method for chain-like deployment of wind turbines in mountainous wind farms, which solves the problem in existing technologies that fail to establish a linkage rule between elevation change vector and wake effect analysis.

[0006] To achieve the above objectives, the present invention provides the following technical solution: a method for optimizing and calculating data on the chain-like deployment of wind turbines in mountainous wind farms, comprising the following steps:

[0007] S1: Ridgeline extraction and elevation driving vector construction. Obtain digital elevation model data of the target area, extract ridgelines through watershed analysis, calculate the elevation gradient and aspect vector of each point along the ridgeline based on the three-dimensional coordinates of the ridgeline, and form an elevation driving vector field to provide terrain data support for S2.

[0008] S2: Determination of starting point and calibration of initial direction. Based on the ridgeline and elevation driving vector field obtained in S1, the point with the maximum elevation value within the ridgeline range is selected as the starting point. The initial direction is calibrated along the positive elevation vector of the ridgeline with the starting point as the origin, providing the starting reference for S3.

[0009] S3: Chain-like path planning. Based on the starting point and initial direction determined by S2, the main chain path is defined along the positive elevation vector of the ridgeline. When encountering abrupt changes in terrain, branch paths are generated along the elevation slope direction perpendicular to the main chain, providing path basis for S4.

[0010] S4: Wind turbine coordinate calculation. Starting from the starting point determined by S2, the coordinates of each wind turbine are calculated along the main chain and branch paths planned by S3, combined with the elevation gradient obtained by S1.

[0011] S5: Application of wake effect suppression algorithm. Based on the wind turbine coordinates obtained in S4, calculate the elevation difference and actual distance between adjacent wind turbines, adjust their positions according to the spacing rules of the downwind and leeward directions, and adopt a staggered arrangement.

[0012] S6: Fan screening, status marking and coordinate output. Based on the adjustment results of S5, the fan is screened and its status is marked. The three-dimensional coordinates of the fans that meet the conditions and the related list and layout diagram are output.

[0013] Preferably, in the S1 ridgeline extraction and elevation driving vector construction, when processing digital elevation model data, it is necessary to set the cell size and neighborhood search radius, construct a digital elevation model grid, calculate the slope and aspect of each point, and then apply watershed analysis to extract the ridgeline. The elevation driving vector field includes slope, aspect, and elevation gradient parameters.

[0014] Preferably, in the S1 ridgeline extraction and elevation driving vector construction, when extracting the ridgeline, the ridge point is determined by traversing the digital elevation model grid and judging whether the elevation of a certain point is greater than the elevation of its 8 neighboring points. Then, the ridge points are connected according to the elevation vector field to form a continuous ridgeline.

[0015] Preferably, in the determination of the starting point and the initial direction calibration in S2, the starting point is the point with the highest elevation within the ridgeline range, and its three-dimensional coordinates are X0, Y0, Z0. The initial direction calibration requires calculating the elevation gradient vector of the starting point, combined with the prevailing wind direction angle range of 0-360 degrees, with due north being 0 degrees, and increasing the adjustment clockwise so that the calibrated direction is not perpendicular to the prevailing wind direction.

[0016] Preferably, in the S3 chain-type layout path planning, the width of the main chain path is 3 times the diameter of the wind turbine impeller, the terrain change refers to an elevation difference > 50m, the branch paths are generated along the elevation gentle slope direction perpendicular to the main chain and the slope is < 15°, and the angle between the branch paths and the main chain is 30°~45°.

[0017] Preferably, in the S3 chain-like layout path planning, when generating the main chain path, the ridgeline points need to be sorted from high to low according to elevation, and the chain extends from the starting point along the ridgeline; when generating the branch path, the direction of the main chain at the branch point needs to be calculated first, and then multiple possible directions perpendicular to the main chain are generated, and the optimal direction is selected by evaluating the slope and direction consistency.

[0018] Preferably, in the S4 wind turbine coordinate calculation, the basic step length of the main chain path is 3D, where D is the diameter of the wind turbine impeller, and the basic step length of the branch path is 2D. When the slope is greater than 20°, the step length is increased by 20%. When calculating the coordinates, the step length is moved along the path from the starting point, and the actual distance is corrected by combining the elevation gradient. The forward direction is dynamically updated until the end of the path.

[0019] Preferably, in the application of the S5 wake effect suppression algorithm, the spacing between wind turbines in the downwind direction is ≥10 times the elevation difference, and the spacing between wind turbines in the leeward direction is ≥20 times the elevation difference. The elevation difference is the absolute value of the elevation difference between adjacent wind turbines, and the actual distance is the three-dimensional straight-line distance between adjacent wind turbines. If the spacing does not meet the requirements, the wind turbine positions are moved along the path direction until they meet the requirements.

[0020] Preferably, in the application of the S5 wake effect suppression algorithm, the cross-staggered arrangement applies a lateral offset of 0.5D to the branch fan by calculating a vector perpendicular to the branch direction, where D is the cross offset of the fan impeller diameter, and the offset directions of adjacent branch fans are opposite to form alternating positive and negative offsets.

[0021] Preferably, in the S6 wind turbine screening, status marking, and coordinate output, the screening marking rules are as follows: wind turbines with a spacing of less than 10 times the elevation difference in the windward direction are marked in red and removed; wind turbines with a spacing of less than 20 times the elevation difference in the leeward direction are marked in yellow and the spacing needs to be optimized; wind turbines that meet the spacing requirements are marked in green and retained; the coordinate output content includes the three-dimensional coordinates X, Y, Z of the green wind turbines, and a chain-like layout coordinate list, including the wind turbine number, coordinate value, elevation difference, and layout diagram.

[0022] This invention provides a method for optimizing the calculation of wind turbine chain deployment data in mountainous wind farms. It offers the following advantages:

[0023] 1. This invention constructs elevation-driven vector rules and extracts ridgeline elevation vectors from DEM data, enabling wind turbines to be distributed in a chain along the dominant terrain features, accurately adapting to the undulating terrain and avoiding wind energy loss caused by terrain obstruction. Simultaneously, combined with automated chain planning, it extends chain-like from the starting point along the ridgeline and automatically calculates the three-dimensional coordinates of the wind turbines, improving the efficiency of complex mountain data processing by more than three times compared to traditional manual methods, significantly shortening the initial design cycle and substantially optimizing deployment efficiency.

[0024] 2. This invention quantifies the correlation between the elevation difference and distance between wind turbines. Based on the 10x / 20x elevation difference rule, it dynamically optimizes the spacing and staggered angle of the chain arrangement using a wake propagation model, reducing the wake interference of upstream turbines on downstream turbines. The main chain and branch turbines are arranged in a staggered manner, further reducing the wake overlap area, which can reduce wake loss by more than 30% and improve the overall power generation efficiency of the wind farm by 5% to 7%.

[0025] 3. This invention integrates 3D visualization functionality via a web interface, displaying in real-time the wind turbine deployment location, elevation vector direction, and wake influence range. It supports user adjustments to deployment parameters, enhancing the feasibility of the plan. Simultaneously, through elevation-driven terrain-adaptive design, it improves wind energy resource utilization by 8%–12% compared to traditional empirical ridgeline deployment methods, providing a scientific deployment paradigm for complex mountain wind farms and promoting technological upgrades in mountain wind power development. Attached Figure Description

[0026] Figure 1 Flowchart of the data optimization calculation method for chain-type wind turbine deployment in this mountainous wind farm;

[0027] Figure 2 This is a schematic diagram of ridgeline extraction according to the present invention;

[0028] Figure 3 This is a schematic diagram of the chain-like deployment path planning of the present invention;

[0029] Figure 4 This is a schematic diagram of the wind turbine selection rules of the present invention;

[0030] Figure 5 This is a flowchart illustrating the technical process of the present invention. Detailed Implementation

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

[0032] Example:

[0033] Please see the appendix Figure 1 - Appendix Figure 5 This invention provides a method for optimizing the calculation of wind turbine chain deployment data in mountainous wind farms, comprising the following steps:

[0034] S1: Ridgeline extraction and elevation driving vector construction. Obtain digital elevation model data of the target area, extract ridgelines through watershed analysis, calculate the elevation gradient and aspect vector of each point along the ridgeline based on the three-dimensional coordinates of the ridgeline, and form an elevation driving vector field to provide terrain data support for S2.

[0035] In the extraction of the S1 ridgeline and the construction of the elevation driving vector, when processing the digital elevation model data, it is necessary to set the cell size and the neighborhood search radius. By constructing the digital elevation model grid, calculating the slope and aspect of each point, and then applying watershed analysis to extract the ridgeline, the elevation driving vector field includes slope, aspect, and elevation gradient parameters.

[0036] In the S1 ridgeline extraction and elevation driving vector construction, when extracting the ridgeline, the ridge point is determined by traversing the digital elevation model grid and judging whether the elevation of a certain point is greater than the elevations of its eight neighboring points. Then, the ridge points are connected according to the elevation vector field to form a continuous ridgeline. The algorithm includes the following:

[0037] /

[0038] Process DEM data, extract ridgelines and calculate elevation vector fields.

[0039] @param {Array} demData - An array of DEM data points in the format {x, y, z}.

[0040] @param {number} cellSize - DEM cell size (meters)

[0041] @param {number} searchRadius - Neighborhood search radius (used to calculate gradient)

[0042] @returns {Object} - The resulting object containing the ridgeline and elevation vector fields.

[0043] /

[0044] function processDEMAndExtractRidges(demData, cellSize = 10,searchRadius = 30) {

[0045] / / 1. Construct the DEM grid (if the data has not yet been gridded)

[0046] const demGrid = buildDEMGrid(demData, cellSize);

[0047] / / 2. Calculate the slope and aspect at each point.

[0048] const gradientField = calculateGradientField(demGrid, cellSize);

[0049] / / 3. Apply watershed analysis to extract ridgelines

[0050] const ridgeLines = extractRidgeLines(demGrid, gradientField,cellSize);

[0051] / / 4. Calculate the dominant extension direction of the ridgeline

[0052] const dominantDirection = calculateDominantDirection(ridgeLines);

[0053] / / 5. Optimize the ridgeline and elevation vector field based on the dominant direction.

[0054] const optimizedRidgeLines = optimizeRidgeLines(ridgeLines,dominantDirection);

[0055] const elevationVectorField = calculateElevationVectorField(optimizedRidgeLines, gradientField, searchRadius);

[0056] return {

[0057] demGrid,

[0058] gradientField,

[0059] ridgeLines: optimizedRidgeLines,

[0060] dominantDirection

[0061] elevationVectorField

[0062] };

[0063] }

[0064] /

[0065] Extract ridge lines

[0066] /

[0067] function extractRidgeLines(demGrid, gradientField, cellSize) {

[0068] const { grid, width, height} = demGrid;

[0069] const ridgePoints = [];

[0070] / / Find local maxima (ridge points)

[0071] for (let row = 1; row < height - 1; row++) {

[0072] for (let col = 1; col < width - 1; col++) {

[0073] const currentHeight = grid[row][col];

[0074] const isPeak =

[0075] currentHeight >= grid[row-1][col] &&

[0076] currentHeight >= grid[row+1][col] &&

[0077] currentHeight >= grid[row][col-1] &&

[0078] currentHeight >= grid[row][col+1] &&

[0079] currentHeight >= grid[row-1][col-1] &&

[0080] currentHeight >= grid[row-1][col+1] &&

[0081] currentHeight >= grid[row+1][col-1] &&

[0082] currentHeight >= grid[row+1][col+1];

[0083] if (isPeak) {

[0084] ridgePoints.push({

[0085] x: col cellSize + demGrid.minX,

[0086] y: row cellSize + demGrid.minY,

[0087] z: currentHeight,

[0088] row,

[0089] col

[0090] });

[0091] }

[0092] }

[0093] }

[0094] / / Connecting ridge points forms a ridgeline

[0095] const ridgeLines = connectRidgePoints(ridgePoints, gradientField,demGrid);

[0096] return ridgeLines;

[0097] }

[0098] S2: Determination of starting point and calibration of initial direction. Based on the ridgeline and elevation driving vector field obtained in S1, the point with the maximum elevation value within the ridgeline range is selected as the starting point. The initial direction is calibrated along the positive elevation vector of the ridgeline with the starting point as the origin, providing the starting reference for S3.

[0099] In the determination of the S2 starting point and initial direction calibration, the starting point is the point with the highest elevation within the ridgeline area, and its three-dimensional coordinates are X0, Y0, Z0. Initial direction calibration requires calculating the elevation gradient vector of the starting point, combined with the prevailing wind direction angle range of 0-360 degrees, with due north as 0, and adjusting clockwise to ensure that the calibrated direction is not perpendicular to the prevailing wind direction. This includes the following algorithms:

[0100] /

[0101] Highest point identification and starting vector calibration algorithm

[0102] @param {Array} ridgePoints - A set of ridgeline points, in the format {x, y, z}.

[0103] @param {number} windDirection - Prevailing wind direction (angle, 0-360 degrees, 0 for due north, increasing clockwise)

[0104] @returns {Object} - An object containing the highest point and the calibrated starting vector.

[0105] / function identifyHighestPointAndCalibrateVector(ridgePoints,windDirection) {

[0106] / / 1. Highest point identification

[0107] const highestPoint = findHighestPoint(ridgePoints);

[0108] / / 2. Calculate the elevation gradient vector (aspect vector) of the highest point.

[0109] const slopeVector = calculateSlopeVector(ridgePoints,highestPoint);

[0110] / / 3. Calibrate the starting vector to avoid it being perpendicular to the prevailing wind direction.

[0111] const calibratedVector = calibrateVectorWithWindDirection(slopeVector, windDirection);

[0112] return {

[0113] highestPoint,

[0114] initialVector: calibratedVector

[0115] };}

[0116] /

[0117] Find the highest point in the point set.

[0118] @param {Array} points - A set of points, in the format {x, y, z}.

[0119] @returns {Object} - Highest point {x, y, z}

[0120] / function findHighestPoint(points) {

[0121] if (!points || points.length === 0) {

[0122] throw new Error("Point set cannot be empty");

[0123] }

[0124] Let highestPoint = points[0];

[0125] for (const point of points) {

[0126] if (point.z > highestPoint.z) {

[0127] highestPoint = point;

[0128] }

[0129] }

[0130] return highestPoint;}

[0131] /

[0132] Calculate the elevation gradient vector (aspect vector) at a specified point.

[0133] @param {Array} points - A set of points, in the format {x, y, z}.

[0134] @param {Object} targetPoint - The target point {x, y, z}

[0135] @param {number} searchRadius - Search radius (meters), used to determine the neighborhood range.

[0136] @returns {Object} - Gradient vector {x, y, magnitude}

[0137] / function calculateSlopeVector(points, targetPoint, searchRadius =50) {

[0138] / / Find points within a specified radius around the target point

[0139] const neighbors = points.filter(point => {

[0140] const dx = point.x - targetPoint.x;

[0141] const dy = point.y - targetPoint.y;

[0142] return Math.sqrt(dx × dx + dy × dy) <= searchRadius;

[0143] });

[0144] if (neighbors.length < 3) {

[0145] / / Too few points in the neighborhood to calculate the gradient

[0146] return { x: 0, y: 0, magnitude: 0};

[0147] }

[0148] / / Fit the plane using the least squares method and calculate the gradient vector.

[0149] let sumX = 0, sumY = 0, sumZ = 0;

[0150] let sumX2 = 0, sumXY = 0, sumYZ = 0, sumXZ = 0;

[0151] for (const point of neighbors) {

[0152] const x = point.x - targetPoint.x;

[0153] const y = point.y - targetPoint.y;

[0154] const z = point.z - targetPoint.z;

[0155] sumX += x;

[0156] sumY += y;

[0157] sumZ += z;

[0158] sumX2 += x × x;

[0159] sumXY += x × y;

[0160] sumYZ += y × z;

[0161] sumXZ += x × z;

[0162] }

[0163] const n = neighbors.length;

[0164] const denominator = sumX2 × n - sumX × sumX;

[0165] if (denominator === 0) {

[0166] / / Prevent division by zero error

[0167] return { x: 0, y: 0, magnitude: 0};

[0168] }

[0169] / / Calculate the coefficients a and b in the plane equation z = ax + by + c

[0170] const a = (sumXZ × n - sumX × sumZ) / denominator;

[0171] const b = (sumYZ - b × sumXY) / (sumY × sumY - n × sumXY);

[0172] / / The gradient vector is in the negative direction of (a, b) (pointing in the direction of increasing elevation).

[0173] const gradientX = -a;

[0174] const gradientY = -b;

[0175] const magnitude = Math.sqrt(gradientX × gradientX + gradientY ×gradientY);

[0176] / / Normalized vector

[0177] if (magnitude > 0) {

[0178] return {

[0179] x: gradientX / magnitude,

[0180] y: gradientY / magnitude

[0181] magnitude: magnitude

[0182] };

[0183] } else {

[0184] return { x: 0, y: 0, magnitude: 0};

[0185] }}

[0186] /

[0187] Calibrate the vector direction to avoid it being perpendicular to the prevailing wind direction.

[0188] @param {Object} vector - Primitive vector {x, y, magnitude}

[0189] @param {number} windDirection - Prevailing wind direction (angle, 0-360 degrees)

[0190] @param {number} minAngle - Minimum permissible angle (degrees); the angle between the angle and the prevailing wind direction should be greater than this value.

[0191] @returns {Object} - The calibrated vector {x, y, magnitude}

[0192] / function calibrateVectorWithWindDirection(vector, windDirection,minAngle = 30) {

[0193] if (vector.magnitude === 0) {

[0194] / / If the vector is zero, return a vector based on the prevailing wind direction.

[0195] const windRad = (windDirection - 90) × Math.PI / 180; / / Convert to radians, adjust to 0 for true north.

[0196] return {

[0197] x: Math.cos(windRad),

[0198] y: Math.sin(windRad),

[0199] magnitude: 1

[0200] };

[0201] }

[0202] / / Calculate the vector direction angle (in radians)

[0203] const vectorAngle = Math.atan2(vector.y, vector.x);

[0204] / / Calculate the angle (in radians) with the prevailing wind direction.

[0205] const windRad = (windDirection - 90) × Math.PI / 180; / / Adjust to 0 for true north.

[0206] let angleDiff = Math.abs(vectorAngle - windRad);

[0207] / / Ensure the angle difference is within the range [0, π].

[0208] if (angleDiff > Math.PI) {

[0209] angleDiff = 2 × Math.PI - angleDiff;

[0210] }

[0211] / / Convert the smallest angle to radians

[0212] const minAngleRad = minAngle × Math.PI / 180;

[0213] / / If the angle difference is less than the minimum allowable angle, adjust the vector direction.

[0214] if (angleDiff < minAngleRad || Math.abs(angleDiff - Math.PI) <minAngleRad) {

[0215] / / Calculate two possible adjustment directions

[0216] const perpendicular1 = windRad + Math.PI / 2;

[0217] const perpendicular2 = windRad - Math.PI / 2;

[0218] / / Choose an adjustment direction that is closer to the original vector direction

[0219] const diff1 = Math.abs(vectorAngle - perpendicular1);

[0220] const diff2 = Math.abs(vectorAngle - perpendicular2);

[0221] const newAngle = diff1 < diff2 ? perpendicular1 : perpendicular2;

[0222] / / Return the adjusted vector

[0223] return {

[0224] x: Math.cos(newAngle),

[0225] y: Math.sin(newAngle),

[0226] magnitude: vector.magnitude

[0227] };

[0228] }

[0229] / / The angle difference meets the requirements; return the original vector.

[0230] return vector;}

[0231] S3: Chain-like path planning. Based on the starting point and initial direction determined by S2, the main chain path is defined along the positive elevation vector of the ridgeline. When encountering abrupt changes in terrain, branch paths are generated along the elevation slope direction perpendicular to the main chain, providing path basis for S4.

[0232] In the S3 chain-type deployment path planning, the width of the main chain path is 3 times the diameter of the wind turbine impeller, the terrain change refers to an elevation difference > 50m, the branch path is generated along the elevation gentle slope direction perpendicular to the main chain and the slope is < 15°, and the angle between the branch path and the main chain is 30°~45°.

[0233] In the S3 chain-like path planning, when generating the main chain path, the ridgeline points need to be sorted from high to low according to elevation, and the path extends in a chain from the starting point along the ridgeline. When generating the branch paths, the direction of the main chain at the branch points needs to be calculated first, and then multiple possible directions perpendicular to the main chain need to be generated. The optimal direction is selected by evaluating the slope and the consistency of direction, including the following algorithms:

[0234] /

[0235] Generate wind turbine deployment paths (main chain and branches).

[0236] @param {Array} ridgePoints - A set of ridgeline points, in the format {x, y, z}.

[0237] @param {number} turbineDiameter - Turbine impeller diameter (meters)

[0238] @returns {Object} - An object containing the main chain and branch paths.

[0239] / function generateTurbinePaths(ridgePoints, turbineDiameter) {

[0240] const pathWidth = turbineDiameter × 3; / / Path width is 3 times the impeller diameter

[0241] const elevationThreshold = 50; / / Elevation threshold (meters)

[0242] const slopeThreshold = 15; / / Maximum slope threshold (degrees)

[0243] const minBranchAngle = 30; / / Minimum branch angle (degrees)

[0244] const maxBranchAngle = 45; / / Maximum branch angle (degrees)

[0245] / / 1. Sort ridgeline points by elevation (optional, ensure processing from highest to lowest)

[0246] const sortedPoints = [...ridgePoints].sort((a, b) => bz - az);

[0247] / / 2. Generate the main chain path

[0248] const mainPath = generateMainPath(sortedPoints, pathWidth,elevationThreshold);

[0249] / / 3. Generate branch paths

[0250] const branchPaths = generateBranchPaths(mainPath, ridgePoints,pathWidth,

[0251] elevationThreshold, slopeThreshold, minBranchAngle, maxBranchAngle);

[0252] return {

[0253] mainPath,

[0254] branchPaths,

[0255] pathWidth

[0256] };}

[0257] /

[0258] Generate main chain path

[0259] @param {Array} ridgePoints - Ridge Point Set

[0260] @param {number} pathWidth - Path width (meters)

[0261] @param {number} elevationThreshold - Elevation threshold (meters)

[0262] @returns {Array} - Main chain path set

[0263] / function generateMainPath(ridgePoints, pathWidth,elevationThreshold) {

[0264] if (ridgePoints.length < 2) return [];

[0265] const mainPath = [ridgePoints[0]]; / / Start from the highest point

[0266] let currentPoint = ridgePoints[0];

[0267] let previousDirection = null;

[0268] for (let i = 1; i < ridgePoints.length; i++) {

[0269] const nextPoint = findNextMainPathPoint(currentPoint,ridgePoints, i,

[0270] pathWidth, elevationThreshold, previousDirection);

[0271] if (nextPoint) {

[0272] mainPath.push(nextPoint);

[0273] currentPoint = nextPoint

[0274] / / Update direction vector

[0275] if (mainPath.length >= 2) {

[0276] const prev = mainPath[mainPath.length - 2];

[0277] previousDirection = {

[0278] x: currentPoint.x - prev.x,

[0279] y: currentPoint.y - prev.y

[0280] };

[0281] / / Normalization

[0282] const magnitude = Math.sqrt(previousDirection.x

[0283] previousDirection.x +

[0284] previousDirection.ypreviousDirection.y);

[0285] if (magnitude > 0) {

[0286] previousDirection.x / = magnitude;

[0287] previousDirection.y / = magnitude;

[0288] }

[0289] }

[0290] }

[0291] }

[0292] return mainPath;

[0293] /

[0294] Find the next point on the main chain path.

[0295] @param {Object} currentPoint - Current point

[0296] @param {Array} ridgePoints - Ridge Point Set

[0297] @param {number} startIndex - The index to start the search

[0298] @param {number} pathWidth - Path width

[0299] @param {number} elevationThreshold - Elevation Threshold

[0300] @param {Object} previousDirection - Previous direction vector

[0301] @returns {Object|null} - Next point or null

[0302] / function findNextMainPathPoint(currentPoint, ridgePoints,startIndex,

[0303] pathWidth, elevationThreshold, previousDirection) {

[0304] / / Search range (meters)

[0305] const searchRadius = pathWidth × 2;

[0306] Let closestPoint = null;

[0307] Let minDistance = Infinity;

[0308] for (let i = startIndex; i < ridgePoints.length; i++) {

[0309] const point = ridgePoints[i];

[0310] / / Calculate distance

[0311] const dx = point.x - currentPoint.x;

[0312] const dy = point.y - currentPoint.y;

[0313] const distance = Math.sqrt(dx × dx + dy × dy);

[0314] / / Check distance and elevation difference

[0315] if (distance <= searchRadius &&

[0316] Math.abs(point.z - currentPoint.z) <= elevationThreshold) {

[0317] / / Check for consistency in direction (if there was a previous direction)

[0318] if (previousDirection && distance > 0) {

[0319] const currentDirection = { x: dx / distance, y: dy / distance};

[0320] const dotProduct = currentDirection.x × previousDirection.x+

[0321] currentDirection.y × previousDirection.y;

[0322] / / Ensure the directions are roughly the same (angle less than 60 degrees).

[0323] if (dotProduct < 0.5) continue;

[0324] }

[0325] if (distance < minDistance) {

[0326] minDistance = distance;

[0327] closestPoint = point;

[0328] }

[0329] }

[0330] }

[0331] return closestPoint;}

[0332] /

[0333] Generate branch paths

[0334] @param {Array} mainPath - Main path

[0335] @param {Array} ridgePoints - Ridge Point Set

[0336] @param {number} pathWidth - Path width

[0337] @param {number} elevationThreshold - Elevation Threshold

[0338] @param {number} slopeThreshold - Slope threshold (degrees)

[0339] @param {number} minBranchAngle - Minimum branch angle (degrees)

[0340] @param {number} maxBranchAngle - Maximum branch angle (degrees)

[0341] @returns {Array} - Array of branch paths

[0342] / function generateBranchPaths(mainPath, ridgePoints, pathWidth,

[0343] elevationThreshold, slopeThreshold,

[0344] minBranchAngle, maxBranchAngle) {

[0345] const branchPaths = [];

[0346] / / Traverse the main chain path and find branch points

[0347] for (let i = 1; i < mainPath.length - 1; i++) {

[0348] const currentPoint = mainPath[i];

[0349] const nextPoint = mainPath[i + 1];

[0350] / / Calculate elevation difference

[0351] const elevationDrop = Math.abs(nextPoint.z - currentPoint.z);

[0352] / / If the elevation difference exceeds the threshold, attempt to generate a branch.

[0353] if (elevationDrop > elevationThreshold) {

[0354] const branchPath = createBranchPath(currentPoint, mainPath,ridgePoints,

[0355] pathWidth, slopeThreshold

[0356] minBranchAngle,maxBranchAngle);

[0357] if (branchPath.length > 1) {

[0358] branchPaths.push(branchPath);

[0359] }

[0360] }

[0361] }

[0362] return branchPaths;

[0363] /

[0364] Create a single branch path

[0365] @param {Object} branchPoint - Branch start point

[0366] @param {Array} mainPath - Main path

[0367] @param {Array} ridgePoints - Ridge Point Set

[0368] @param {number} pathWidth - Path width

[0369] @param {number} slopeThreshold - Slope threshold (degrees)

[0370] @param {number} minBranchAngle - Minimum branch angle (degrees)

[0371] @param {number} maxBranchAngle - Maximum branch angle (degrees)

[0372] @returns {Array} - Branch path point set

[0373] / function createBranchPath(branchPoint, mainPath, ridgePoints,pathWidth,

[0374] slopeThreshold, minBranchAngle,maxBranchAngle) {

[0375] / / Calculate the main chain direction

[0376] const mainDirection = calculateMainDirection(branchPoint,mainPath);

[0377] / / Calculate the direction perpendicular to the main chain (two possible directions, left and right).

[0378] const perpendicularDirections = calculatePerpendicularDirections(mainDirection,

[0379] minBranchAngle,

[0380] maxBranchAngle);

[0381] / / Choose the optimal branch direction

[0382] const bestDirection = selectBestBranchDirection(branchPoint,

[0383] perpendicularDirections

[0384] ridgePoints,

[0385] slopeThreshold);

[0386] if (!bestDirection) return [];

[0387] / / Generate branch paths along this direction

[0388] const branchPath = [branchPoint];

[0389] let currentPoint = branchPoint;

[0390] let searchRadius = pathWidth;

[0391] for (let i = 0; i < 10; i++) { / / Limit branch length

[0392] const nextPoint = findNextBranchPoint(currentPoint,bestDirection,

[0393] ridgePoints, searchRadius,

[0394] slopeThreshold);

[0395] if (nextPoint) {

[0396] branchPath.push(nextPoint);

[0397] currentPoint = nextPoint

[0398] searchRadius = 1.2; / / Expand the search range

[0399] } else {

[0400] break; / / No suitable next point found

[0401] }

[0402] }

[0403] return branchPath;}

[0404] /

[0405] Calculate the direction of the main chain at the branch point

[0406] @param {Object} branchPoint - Branch point

[0407] @param {Array} mainPath - Main path

[0408] @returns {Object} - Direction vector {x, y}

[0409] / function calculateMainDirection(branchPoint, mainPath) {

[0410] / / Find the location of the branch point in the main chain

[0411] const index = mainPath.findIndex(p => p === branchPoint);

[0412] if (index < 0 || index >= mainPath.length - 1) {

[0413] return { x: 1, y: 0}; / / Default direction

[0414] }

[0415] const nextPoint = mainPath[index + 1];

[0416] const dx = nextPoint.x - branchPoint.x;

[0417] const dy = nextPoint.y - branchPoint.y;

[0418] / / Normalization

[0419] const magnitude = Math.sqrt(dx × dx + dy × dy);

[0420] if (magnitude > 0) {

[0421] return { x: dx / magnitude, y: dy / magnitude};

[0422] } else {

[0423] return { x: 1, y: 0};

[0424] }}

[0425] /

[0426] Calculate the possible directions perpendicular to the main chain (considering an angle of 30-45 degrees).

[0427] @param {Object} mainDirection - Main link direction vector

[0428] @param {number} minAngle - Minimum angle (degrees)

[0429] @param {number} maxAngle - Maximum angle (degrees)

[0430] @returns {Array} - An array of possible direction vectors

[0431] / function calculatePerpendicularDirections(mainDirection, minAngle,maxAngle) {

[0432] / / Calculate the vertical direction (90 degrees)

[0433] const perpendicular = {

[0434] x: -mainDirection.y,

[0435] y: mainDirection.x

[0436] };

[0437] / / Considering an angle of 30-45 degrees, generate multiple possible directions.

[0438] const directions = [];

[0439] const angles = [minAngle, (minAngle + maxAngle) / 2, maxAngle];

[0440] for (const angle of angles) {

[0441] const angleRad = angle × Math.PI / 180;

[0442] / / Clockwise and counterclockwise directions

[0443] for (const sign of [-1, 1]) {

[0444] / / Rotate the principal direction vector

[0445] const rotatedX = mainDirection.x × Math.cos(sign × angleRad)-

[0446] mainDirection.y × Math.sin(sign × angleRad);

[0447] const rotatedY = mainDirection.x × Math.sin(sign × angleRad)+

[0448] mainDirection.y × Math.cos(sign × angleRad);

[0449] directions.push({ x: rotatedX, y: rotatedY});

[0450] }

[0451] }

[0452] / / Normalize all directions

[0453] return directions.map(dir => {

[0454] const magnitude = Math.sqrt(dir.x × dir.x + dir.y × dir.y);

[0455] return { x: dir.x / magnitude, y: dir.y / magnitude};

[0456] });}

[0457] /

[0458] Choose the optimal branch direction

[0459] @param {Object} branchPoint - Branch point

[0460] @param {Array} directions - Array of candidate directions

[0461] @param {Array} ridgePoints - Ridge Point Set

[0462] @param {number} slopeThreshold - Slope threshold (degrees)

[0463] @returns {Object|null} - Optimal direction or null

[0464] / function selectBestBranchDirection(branchPoint, directions,ridgePoints, slopeThreshold) {

[0465] let bestDirection = null;

[0466] Let bestScore = -Infinity;

[0467] for (const direction of directions) {

[0468] / / Evaluate the score in this direction

[0469] const score = evaluateDirection(branchPoint, direction,ridgePoints, slopeThreshold);

[0470] if (score > bestScore) {

[0471] bestScore = score;

[0472] bestDirection = direction;

[0473] }

[0474] }

[0475] return bestDirection;}

[0476] /

[0477] Score for evaluating branch direction

[0478] @param {Object} branchPoint - Branch point

[0479] @param {Object} direction - Direction vector

[0480] @param {Array} ridgePoints - Ridge Point Set

[0481] @param {number} slopeThreshold - Slope threshold (degrees)

[0482] @returns {number} - Score

[0483] / function evaluateDirection(branchPoint, direction, ridgePoints,slopeThreshold) {

[0484] const searchRadius = 100; / / Search radius (meters)

[0485] const pointsInDirection = [];

[0486] / / Find the point in this direction

[0487] for (const point of ridgePoints) {

[0488] const dx = point.x - branchPoint.x;

[0489] const dy = point.y - branchPoint.y;

[0490] const distance = Math.sqrt(dx × dx + dy × dy);

[0491] if (distance > 0 && distance <= searchRadius) {

[0492] / / Calculate the cosine of the angle between the point and the direction.

[0493] const dotProduct = (dx / distance) × direction.x + (dy / distance) × direction.y;

[0494] / / Only consider points with an angle less than 60 degrees

[0495] if (dotProduct > 0.5) {

[0496] pointsInDirection.push({ point, distance, dotProduct});

[0497] }

[0498] }

[0499] }

[0500] if (pointsInDirection.length === 0) return -Infinity;

[0501] / / Calculate the average slope

[0502] let totalSlope = 0;

[0503] let validPoints = 0;

[0504] for (const item of pointsInDirection) {

[0505] const slope = calculateSlope(branchPoint, item.point);

[0506] if (slope <= slopeThreshold) {

[0507] totalSlope += slope;

[0508] validPoints++;

[0509] }

[0510] }

[0511] if (validPoints === 0) return -Infinity;

[0512] const avgSlope = totalSlope / validPoints;

[0513] / / Score calculation: The smaller the slope, the better; the better the consistency of direction.

[0514] return validPoints × (1 - avgSlope / slopeThreshold);}

[0515] /

[0516] Calculate the slope (in degrees) between two points.

[0517] @param {Object} p1 - dot 1

[0518] @param {Object} p2 - point 2

[0519] @returns {number} - Slope (degrees)

[0520] / function calculateSlope(p1, p2) {

[0521] const dx = p2.x - p1.x;

[0522] const dy = p2.y - p1.y;

[0523] const horizontalDistance = Math.sqrt(dx × dx + dy × dy);

[0524] const verticalDistance = Math.abs(p2.z - p1.z);

[0525] return Math.atan2(verticalDistance, horizontalDistance) × 180 / Math.PI;}

[0526] /

[0527] Find the next point on the branch path

[0528] @param {Object} currentPoint - Current point

[0529] @param {Object} direction - Direction vector

[0530] @param {Array} ridgePoints - Ridge Point Set

[0531] @param {number} searchRadius - Search radius

[0532] @param {number} slopeThreshold - Slope threshold

[0533] @returns {Object|null} - Next point or null

[0534] / function findNextBranchPoint(currentPoint, direction, ridgePoints,searchRadius, slopeThreshold) {

[0535] let bestPoint = null;

[0536] Let bestScore = -Infinity;

[0537] for (const point of ridgePoints) {

[0538] const dx = point.x - currentPoint.x;

[0539] const dy = point.y - currentPoint.y;

[0540] const distance = Math.sqrt(dx × dx + dy × dy);

[0541] if (distance > 0 && distance <= searchRadius) {

[0542] / / Consistency of calculation and direction

[0543] const dirConsistency = (dx / distance) × direction.x + (dy / distance) × direction.y;

[0544] / / Calculate slope

[0545] const slope = calculateSlope(currentPoint, point);

[0546] / / Check if the slope meets the requirements

[0547] if (slope <= slopeThreshold) {

[0548] / / Calculate the score: the greater the distance, the better; the more consistent the directions, the better.

[0549] const score = distance × dirConsistency;

[0550] if (score > bestScore) {

[0551] bestScore = score;

[0552] bestPoint = point;

[0553] }

[0554] }

[0555] }

[0556] }

[0557] return bestPoint;}

[0558] S4: Wind turbine coordinate calculation. Starting from the starting point determined by S2, the coordinates of each wind turbine are calculated along the main chain and branch paths planned by S3, combined with the elevation gradient obtained by S1.

[0559] In the S4 wind turbine coordinate calculation, the basic step length of the main chain path is 3D, where D is the diameter of the wind turbine impeller. The basic step length of the branch path is 2D. When the slope is greater than 20°, the step length is increased by 20%. When calculating the coordinates, the step length is moved along the path from the starting point. The actual distance is corrected by combining the elevation gradient, and the forward direction is dynamically updated until the end of the path.

[0560] Branch coordinate calculation: Starting from the turning point of the main chain path, calculate the branch wind turbine coordinates according to the branch path rules to form a chain network of "main chain + branch";

[0561] The main logic of the algorithm is as follows:

[0562] Calculation of main chain fan location:

[0563] 1. Use 3D as the basic step size;

[0564] 2. Adjust the actual step length according to the local slope (increase by 20% when the slope is > 20°);

[0565] 3. Position correction theory based on ridgeline point set;

[0566] 4. Dynamically update the direction of travel;

[0567] Branch fan location calculation:

[0568] 5. Start from the main chain branch point;

[0569] 6. Use 2D as the basic step size;

[0570] 7. Extend along a direction perpendicular to the main chain;

[0571] 8. The slope of branch paths is limited to no more than 15°;

[0572] Directional control:

[0573] 9. The main chain direction is automatically adjusted based on local terrain features;

[0574] 10. The branch direction forms a 30-45 degree angle with the main chain;

[0575] 11. Ensure that the wind turbine arrangement direction matches the distribution of wind energy resources.

[0576] In the application of the S5 wake effect suppression algorithm, the spacing between wind turbines in the downwind direction is ≥10 times the elevation difference, and the spacing between wind turbines in the leeward direction is ≥20 times the elevation difference. The elevation difference is the absolute value of the elevation difference between adjacent wind turbines, and the actual distance is the three-dimensional straight-line distance between adjacent wind turbines. If the spacing does not meet the requirements, the wind turbine positions are moved along the path direction until they meet the requirements.

[0577] In the application of the S5 wake effect suppression algorithm, the staggered arrangement applies a lateral offset of 0.5D to the branch fans by calculating a vector perpendicular to the branch direction, where D is the staggered offset of the fan impeller diameter. The offset directions of adjacent branch fans are opposite, forming alternating positive and negative offsets. The algorithm includes the following:

[0578] /

[0579] Application of misaligned layout optimization

[0580] @param {Array} mainTurbines - Main Turbines location

[0581] @param {Array} branchTurbines - Branch fan locations

[0582] @param {number} turbineDiameter - Turbine impeller diameter (meters)

[0583] / function applyStaggeredLayout(mainTurbines, branchTurbines,turbineDiameter) {

[0584] const offset = turbineDiameter × 0.5; / / Lateral offset

[0585] / / Group by branch

[0586] const branchGroups = groupBranchTurbines(branchTurbines);

[0587] / / Apply misaligned layout to each branch

[0588] for (let i = 0; i < branchGroups.length; i++) {

[0589] const branch = branchGroups[i];

[0590] / / Determine the branch direction (relative to the main chain)

[0591] const branchDirection = getBranchDirection(branch[0],mainTurbines);

[0592] / / Calculate the vector perpendicular to the branch direction

[0593] const perpendicularVector = {

[0594] x: -branchDirection.y,

[0595] y: branchDirection.x

[0596] };

[0597] / / Normalization

[0598] const magnitude = Math.sqrt(perpendicularVector.x ×perpendicularVector.x +

[0599] perpendicularVector.y ×perpendicularVector.y);

[0600] perpendicularVector.x / = magnitude;

[0601] perpendicularVector.y / = magnitude;

[0602] / / Apply interleaved offset

[0603] for (let j = 0; j < branch.length; j++) {

[0604] / / Alternating positive and negative offsets

[0605] const sign = j % 2 === 0 ? 1 : -1;

[0606] const offsetX = perpendicularVector.x × offset × sign;

[0607] const offsetY = perpendicularVector.y × offset × sign;

[0608] / / Find the index of the fan in the original array and adjust

[0609] const index = branchTurbines.findIndex(t => t === branch[j]);

[0610] if (index !== -1) {

[0611] branchTurbines[index] = {

[0612] ...branch[j],

[0613] x: branch[j].x + offsetX,

[0614] y: branch[j].y + offsetY

[0615] };

[0616] }

[0617] }

[0618] }}

[0619] S5: Application of wake effect suppression algorithm. Based on the wind turbine coordinates obtained in S4, calculate the elevation difference and actual distance between adjacent wind turbines, adjust their positions according to the spacing rules of the downwind and leeward directions, and adopt a staggered arrangement.

[0620] S6: Fan screening, status marking and coordinate output. Based on the adjustment results of S5, the fan is screened and its status is marked. The three-dimensional coordinates of the fans that meet the conditions and the related list and layout diagram are output.

[0621] In the S6 wind turbine screening, status marking, and coordinate output, the screening and marking rules are as follows: wind turbines with a spacing of less than 10 times the elevation difference in the windward direction are marked in red and removed; wind turbines with a spacing of less than 20 times the elevation difference in the leeward direction are marked in yellow and require spacing optimization; wind turbines that meet the spacing requirements are marked in green and retained. The coordinate output includes the three-dimensional coordinates (X, Y, Z) of green wind turbines and a chained layout coordinate list, including the wind turbine number, coordinate values, elevation difference, and layout diagram. The wind turbine screening and status display algorithm is as follows:

[0622] /

[0623] Fan screening and status marking

[0624] @param {Array} turbines - turbine location data

[0625] @param {number} windDirection - Prevailing wind direction (angle)

[0626] @returns {Array} - Tagged wind turbine data

[0627] / function filterAndMarkTurbines(turbines, windDirection) {

[0628] return turbines.map((turbine, index) => {

[0629] if (index === 0) return { ...turbine, status: 'green'}; / / The first turbine passes by default.

[0630] const prevTurbine = turbines[index - 1];

[0631] const distance = calculateDistance(turbine, prevTurbine);

[0632] const elevationDiff = Math.abs(turbine.z - prevTurbine.z);

[0633] / / Calculate the angle between the fan connection line and the prevailing wind direction.

[0634] const angle = calculateAngleWithWindDirection(turbine,prevTurbine, windDirection);

[0635] const isDownwind = angle < 90; / / Determine the downwind direction

[0636] / / Apply filtering rules

[0637] let status;

[0638] if (isDownwind && distance < 10 × elevationDiff) {

[0639] status = 'red'; / / Downwind but not close enough, discard

[0640] } else if (!isDownwind && distance < 20 × elevationDiff) {

[0641] status = 'yellow'; / / Insufficient leeward distance, needs optimization.

[0642] } else {

[0643] status = 'green'; / / Meets requirements

[0644] }

[0645] return { ...turbine, status, distance, elevationDiff, isDownwind};

[0646] });}

[0647] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A method for optimizing the calculation of wind turbine chain layout data in mountain wind farms, characterized in that, Includes the following steps: S1: Ridgeline extraction and elevation driving vector construction. Obtain digital elevation model data of the target area, extract ridgelines through watershed analysis, calculate the elevation gradient and aspect vector of each point along the ridgeline based on the three-dimensional coordinates of the ridgeline, and form an elevation driving vector field to provide terrain data support for S2. S2: Determination of starting point and calibration of initial direction. Based on the ridgeline and elevation driving vector field obtained in S1, the point with the maximum elevation value within the ridgeline range is selected as the starting point. The initial direction is calibrated along the positive elevation vector of the ridgeline with the starting point as the origin, providing the starting reference for S3. S3: Chain-like path planning. Based on the starting point and initial direction determined by S2, the main chain path is defined along the positive elevation vector of the ridgeline. When encountering abrupt changes in terrain, branch paths are generated along the elevation slope direction perpendicular to the main chain, providing path basis for S4. S4: Wind turbine coordinate calculation. Starting from the starting point determined by S2, the coordinates of each wind turbine are calculated along the main chain and branch paths planned by S3, combined with the elevation gradient obtained by S1. S5: Application of wake effect suppression algorithm. Based on the wind turbine coordinates obtained in S4, calculate the elevation difference and actual distance between adjacent wind turbines, adjust their positions according to the spacing rules of the downwind and leeward directions, and adopt a staggered arrangement. S6: Fan screening, status marking and coordinate output. Based on the adjustment results of S5, the fan is screened and its status is marked. The three-dimensional coordinates of the fans that meet the conditions and the related list and layout diagram are output.

2. The method for optimizing and calculating data of chain-type wind turbine deployment in mountain wind farms according to claim 1, characterized in that, In the extraction of the S1 ridgeline and the construction of the elevation driving vector, when processing the digital elevation model data, it is necessary to set the cell size and the neighborhood search radius. By constructing the digital elevation model grid, calculating the slope and aspect of each point, and then applying watershed analysis to extract the ridgeline, the elevation driving vector field includes slope, aspect, and elevation gradient parameters.

3. The method for optimizing and calculating data of chain-type wind turbine deployment in mountain wind farms according to claim 1, characterized in that, In the S1 ridgeline extraction and elevation driving vector construction, when extracting the ridgeline, the ridge point is determined by traversing the digital elevation model grid and judging whether the elevation of a certain point is greater than the elevation of its 8 neighboring points. Then, the ridge points are connected according to the elevation vector field to form a continuous ridgeline.

4. The method for optimizing and calculating data of chain-type wind turbine deployment in mountain wind farms according to claim 1, characterized in that, In the determination of the starting point and the initial direction calibration of S2, the starting point is the point with the highest elevation within the ridgeline range, and its three-dimensional coordinates are X0, Y0, Z0. The initial direction calibration requires calculating the elevation gradient vector of the starting point, combined with the prevailing wind direction angle range of 0-360 degrees, with due north being 0 degrees, and increasing the adjustment clockwise so that the calibrated direction is not perpendicular to the prevailing wind direction.

5. The method for optimizing and calculating data of chain-type wind turbine deployment in mountain wind farms according to claim 1, characterized in that, In the S3 chain-type deployment path planning, the width of the main chain path is 3 times the diameter of the wind turbine impeller, the terrain change refers to an elevation difference of >50m, the branch path is generated along the elevation gentle slope direction perpendicular to the main chain and the slope is <15°, and the angle between the branch path and the main chain is 30°~45°.

6. The method for optimizing and calculating data of chain-type wind turbine deployment in mountain wind farms according to claim 1, characterized in that, In the S3 chain-like layout path planning, when generating the main chain path, the ridgeline points need to be sorted from high to low according to elevation, and the chain extends from the starting point along the ridgeline. When generating the branch path, the direction of the main chain at the branch point needs to be calculated first, and then multiple possible directions perpendicular to the main chain are generated. The optimal direction is selected by evaluating the slope and the consistency of direction.

7. The method for optimizing and calculating data of chain-type wind turbine deployment in mountain wind farms according to claim 1, characterized in that, In the S4 wind turbine coordinate calculation, the basic step length of the main chain path is 3D, where D is the diameter of the wind turbine impeller. The basic step length of the branch path is 2D. When the slope is greater than 20°, the step length is increased by 20%. When calculating the coordinates, the step length is moved along the path from the starting point. The actual distance is corrected by combining the elevation gradient, and the forward direction is dynamically updated until the end of the path.

8. The method for optimizing and calculating data of chain-type wind turbine deployment in mountain wind farms according to claim 1, characterized in that, In the application of the S5 wake effect suppression algorithm, the distance between wind turbines in the downwind direction is ≥10 times the elevation difference, and the distance between wind turbines in the leeward direction is ≥20 times the elevation difference. The elevation difference is the absolute value of the elevation difference between adjacent wind turbines, and the actual distance is the three-dimensional straight-line distance between adjacent wind turbines. If the spacing does not meet the requirements, move the fan position along the path until it meets the requirements.

9. The method for optimizing and calculating data of chain-type wind turbine deployment in a mountain wind farm according to claim 1, characterized in that, In the application of the S5 wake effect suppression algorithm, the cross-staggered arrangement applies a lateral offset of 0.5D to the branch fan by calculating a vector perpendicular to the branch direction, where D is the staggered offset of the fan impeller diameter. The offset directions of adjacent branch fans are opposite, forming alternating positive and negative offsets.

10. The method for optimizing and calculating data of chain-type wind turbine deployment in a mountain wind farm according to claim 1, characterized in that, In the S6 wind turbine screening, status marking, and coordinate output, the screening marking rules are as follows: wind turbines with a spacing of less than 10 times the elevation difference in the windward direction are marked in red and removed; wind turbines with a spacing of less than 20 times the elevation difference in the leeward direction are marked in yellow and their spacing needs to be optimized; wind turbines that meet the spacing requirements are marked in green and retained; the coordinate output includes the three-dimensional coordinates X, Y, Z of the green wind turbines, a chain-like layout coordinate list, including the wind turbine number, coordinate value, elevation difference, and layout diagram.

Images