@eturnity/eturnity_maths 8.10.1 → 8.16.1-SLD.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eturnity/eturnity_maths",
-  "version": "8.10.1",
+  "version": "8.16.1-SLD.0",
   "author": "Eturnity Team",
   "main": "src/index.js",
   "private": false,

package/src/geometry.js

@@ -413,6 +413,45 @@ export function getPointInsideOutline(vs, firstLevelHoles = []) {
   }
   return result
 }
+export function distanceTo2DPolyline(point, polyline) {
+  let minDistance = Infinity
+  if (polyline.length < 2) {
+    throw new Error('not enough points in polyline')
+  }
+  for (let i = 0; i < polyline.length - 1; i++) {
+    let A = polyline[i]
+    let B = polyline[i + 1]
+    const distance = distanceTo2DSegment(point, A, B)
+    if (distance < minDistance) {
+      minDistance = distance
+    }
+  }
+  return minDistance
+}
+export function distanceTo2DSegment(point, A, B) {
+  const vectorAB = { x: B.x - A.x, y: B.y - A.y }
+  const vectorAP = { x: point.x - A.x, y: point.y - A.y }
+  const lengthABSquared = vectorAB.x * vectorAB.x + vectorAB.y * vectorAB.y
+  if (lengthABSquared === 0) {
+    return Math.sqrt(vectorAP.x * vectorAP.x + vectorAP.y * vectorAP.y)
+  }
+  const t =
+    (vectorAP.x * vectorAB.x + vectorAP.y * vectorAB.y) / lengthABSquared
+  if (t < 0) {
+    return Math.sqrt(vectorAP.x * vectorAP.x + vectorAP.y * vectorAP.y)
+  }
+  if (t > 1) {
+    const vectorBP = { x: point.x - B.x, y: point.y - B.y }
+    return Math.sqrt(vectorBP.x * vectorBP.x + vectorBP.y * vectorBP.y)
+  }
+  const projection = {
+    x: A.x + t * vectorAB.x,
+    y: A.y + t * vectorAB.y,
+  }
+  const dx = point.x - projection.x
+  const dy = point.y - projection.y
+  return Math.sqrt(dx * dx + dy * dy)
+}
 
 export function distanceToEdge2D(M, A, B) {
   const pA = { x: A.x, y: A.y, z: 0 }
@@ -734,6 +773,18 @@ export function get3pointNotAlignedFromOutline(outline) {
   }
   return [A, B, C]
 }
+export function getNormalVectorFromFlatOutline(outline) {
+  const ABC = get3pointNotAlignedFromOutline(outline)
+  if (!ABC) {
+    return null
+  }
+  let normalVector = getNormalVectorFrom3Points(...ABC)
+  if (normalVector.z < 0) {
+    normalVector = multiplyVector(-1, normalVector)
+  }
+  normalVector = normalizeVector(normalVector)
+  return normalVector
+}
 export function getNormalVectortoEdgeTowardPolygon(k, outline) {
   const A = outline[k]
   const B = outline[(k + 1) % outline.length]

package/src/index.js

@@ -9,6 +9,7 @@ export * from './objects'
 export * from './splitMergePolygons'
 export * from './miscellaneous'
 export * from './stats'
+export * from './irradiance'
 export * from './spherical'
 export * from './SHPSolver'
 export * from './panelFunctions'

package/src/irradiance.js

@@ -0,0 +1,77 @@
+import { dotProduct, inclineWithNormalVector, normalizeVector } from './index'
+export function ineichenDiffuseIrradiance(dni, dhi, plane_theta, cosAOI) {
+  //compute of Ineichen diffuse
+  const F = 1.0 - Math.pow(dhi / Math.max(dni * cosAOI + dhi, 1e-6), 2.0)
+  const diffusion_Ineichen =
+    dhi *
+    ((1.0 + Math.cos(plane_theta)) / 2.0) *
+    (1.0 + F * Math.pow(Math.sin(plane_theta / 2.0), 3.0)) *
+    (1.0 + F * Math.pow(cosAOI, 2.0) * Math.pow(Math.cos(plane_theta), 3.0))
+  return diffusion_Ineichen
+}
+export function getOptimizedGHI({ dataGrids, lat, lng }) {
+  // Compute normal vector for max DNI
+  let optimized_panel_tilt
+  if (Math.abs(lat) < 25) optimized_panel_tilt = Math.abs(lat) * 0.87
+  else if (Math.abs(lat) < 50) optimized_panel_tilt = Math.abs(lat) * 0.76 + 3.1
+  else optimized_panel_tilt = Math.abs(lat) * 0.76 + 3.1
+
+  const phi = 180
+  const theta = optimized_panel_tilt
+  const phiRad = (phi * Math.PI) / 180
+  const thetaRad = (theta * Math.PI) / 180
+  const optimizedNormalVector = {
+    x: Math.sin(thetaRad) * Math.sin(phiRad),
+    y: Math.sin(thetaRad) * Math.cos(phiRad),
+    z: Math.cos(thetaRad),
+  }
+  let { ghi } = getGHI({
+    dataGrids: dataGrids,
+    normalVector: optimizedNormalVector,
+  })
+  return ghi
+}
+export function getGHI({ dataGrids, normalVector }) {
+  // Compute highest GHI
+  normalVector = normalizeVector(normalVector)
+  let GHISum = 0
+  let DHISum = 0
+  let DNISum = 0
+  const resolution = {
+    x: 1 / dataGrids.dni_grid[0].length,
+    y: 1 / dataGrids.dni_grid.length,
+  }
+  for (let i = 0; i < dataGrids.dni_grid.length; i++) {
+    for (let j = 0; j < dataGrids.dni_grid[0].length; j++) {
+      const phi = j * resolution.x
+      const theta = i * resolution.y
+      const phiRad = phi * Math.PI * 2
+      const thetaRad = (theta * Math.PI) / 2
+      const sunDir = {
+        x: Math.sin(thetaRad) * Math.sin(phiRad),
+        y: Math.sin(thetaRad) * Math.cos(phiRad),
+        z: Math.cos(thetaRad),
+      }
+      const cosAngle = Math.max(dotProduct(normalVector, sunDir), 0)
+      const dni = dataGrids.dni_grid[i][j]
+      const dhi = dataGrids.dhi_grid[i][j]
+      const plane_theta = inclineWithNormalVector(normalVector)
+      const ineichen_dhi = ineichenDiffuseIrradiance(
+        dni,
+        dhi,
+        plane_theta,
+        cosAngle
+      )
+      const ghi = dni * cosAngle + ineichen_dhi
+      DHISum += ineichen_dhi
+      DNISum += dni
+      GHISum += ghi
+    }
+  }
+
+  return {
+    dhi: DHISum,
+    dni: DNISum,
+    ghi: GHISum,
+  }
+}

package/src/objects/Polygon.js

@@ -332,6 +332,8 @@ export class Polygon {
         row_spacing_mm: this.data.row_spacing_mm,
         is_row_spacing_automatic: this.data.is_row_spacing_automatic,
         offset_percent: this.data.offset_percent,
+        fitting_panel_area_m2: this.data.fitting_panel_area_m2,
+        has_fitting_panels: this.data.has_fitting_panels,
         panel_orientation: this.data.panel_orientation,
         panel_direction_degrees: this.data.panel_direction_degrees,
         component_id_pv_module: this.data.component_id_pv_module,

package/src/tests/geometry/distanceTo2DSegment.spec.js

@@ -0,0 +1,51 @@
+import { distanceTo2DSegment } from '../../index'
+
+describe('distanceTo2DSegment function', () => {
+  test('top middle', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: 5, y: 10, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(10, 4)
+  })
+  test('bottom', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: 5, y: -10, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(10, 4)
+  })
+  test('diagonal', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: -3, y: 4, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(5, 4)
+  })
+  test('point aligned with A and B', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: -10, y: 0, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(10, 4)
+  })
+  test('point aligned with A and B right', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: 20, y: 0, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(10, 4)
+  })
+  test('AB in diagonal', () => {
+    const A = { x: 0, y: 10, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: 0, y: 0, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(7.07106, 4)
+  })
+  test('point and A and A', () => {
+    const A = { x: 0, y: 10, z: 0 }
+    const point = { x: 0, y: 0, z: 0 }
+    expect(distanceTo2DSegment(point, A, A)).toBeCloseTo(10, 4)
+  })
+  test('point vertical to B', () => {
+    const A = { x: 0, y: 0, z: 0 }
+    const B = { x: 10, y: 0, z: 0 }
+    const point = { x: 10, y: 10, z: 0 }
+    expect(distanceTo2DSegment(point, A, B)).toBeCloseTo(10, 4)
+  })
+})