@eturnity/eturnity_maths 8.16.0 → 8.16.1

package/package.json

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

package/src/geometry.js

@@ -734,6 +734,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,
+  }
+}