add changing of color scale

guiapp/deploy.sh

@@ -18,7 +18,7 @@ cd ..
 #sed -i 's=[<]base href[=]//themes//custom//physics//mie-next// [>]==g' index.html
 cd ../..
 
-rsync -aue ssh --progress  dist/spa/ physics@physics.ifmo.ru:/var/www/html/physicsifmoru/web/themes/custom/physics/mie-next
+rsync -aue ssh --progress  dist/spa/ physics@physics.ifmo.ru:/var/www/html/physicsifmoru/web/themes/custom/physics/mie
 echo
 cat dist/spa/index.html
 echo

guiapp/quasar.conf.js

@@ -56,12 +56,14 @@ module.exports = configure(function (ctx) {
       publicPath: process.env.NODE_ENV === 'development'
           ? '/'
           : '/themes/custom/physics/mie-next/', //deploy path in Drupal setup at physics.ifmo.ru
+          // : '/themes/custom/physics/mie/', //deploy path in Drupal setup at physics.ifmo.ru
 
       env: {
         // copy publicPath from above build.publicPath to make it available from inside of the app.
         publicPath: ctx.dev
             ? '/'
             : '/themes/custom/physics/mie-next/' //deploy path in Drupal setup at physics.ifmo.ru
+            // : '/themes/custom/physics/mie/' //deploy path in Drupal setup at physics.ifmo.ru
       },
       // extendWebpack (cfg, { isServer, isClient }) {
       //   cfg.module.rules.push({

guiapp/src/components/GetNearFieldColorScale.vue

@@ -0,0 +1,93 @@
+<template>
+  <div class="row items-baseline">
+    <div class="col-xs-12 col-sm-auto text-center q-px-md q-py-sm">
+      <div :style="flexRowTitleStyle">
+        |&thinsp;𝐸&thinsp;|&emsp13;∕&emsp13;|&thinsp;𝐸𝜊&thinsp;| limits
+      </div>
+    </div>
+    <div class="col-xs-grow col-sm">
+      <div class="row justify-xs-center justify-sm-start items-center">
+
+        <div class="col-auto"><input-with-units
+            v-model:input-result="limitFrom"
+            v-model:is-showing-help="isShowingHelpForInputWithUnits"
+            :initial-expression="limitFrom.toString()"
+            title="from"
+            units=""
+        /></div>
+        <div class="col-auto"><input-with-units
+            v-model:input-result="limitTo"
+            v-model:is-showing-help="isShowingHelpForInputWithUnits"
+            :initial-expression="limitTo.toString()"
+            title="to"
+            units=""
+        /></div>
+        <div class="col-auto q-pa-xs"><q-btn
+            no-caps
+            flat
+            icon="restart_alt"
+            color="primary"
+            label="reset"
+            @click="resetLimits()"
+        /></div>
+     </div>
+    </div>
+  </div>
+
+</template>
+
+<script lang="ts">
+import {
+  defineComponent,
+  watch,
+  computed,
+  } from 'vue'
+import { useStore } from 'src/store'
+import InputWithUnits from 'components/InputWithUnits.vue'
+import { flexRowTitleStyle } from 'components/config'
+
+export default defineComponent({
+
+  name: 'GetNearFieldColorScale',
+  components: {InputWithUnits,},
+
+  setup() {
+    const $store = useStore()
+
+    const isShowingHelpForInputWithUnits = computed({
+      get: () => $store.state.guiRuntime.isShowingHelpForInputWithUnits,
+      set: val => $store.commit('guiRuntime/setIsShowingHelpForInputWithUnits', val)
+    })
+
+    const dataFrom = computed(()=>$store.state.plotRuntime.nearFieldDataFrom)
+    const dataTo = computed(()=>$store.state.plotRuntime.nearFieldDataTo)
+    const limitFrom = computed({
+      get: ()=>$store.state.plotRuntime.nearFieldLimitFrom,
+      set: val => $store.commit('plotRuntime/setNearFieldLimitFrom',val)
+    })
+    const limitTo = computed({
+      get: ()=>$store.state.plotRuntime.nearFieldLimitTo,
+      set: val => $store.commit('plotRuntime/setNearFieldLimitTo',val)
+    })
+
+    limitFrom.value = dataFrom.value
+    limitTo.value = dataTo.value
+
+    watch(dataFrom, ()=>{
+      if(dataFrom.value > limitFrom.value) limitFrom.value = dataFrom.value
+    })
+    watch(dataTo, ()=>{
+      if(dataTo.value < limitTo.value) limitTo.value = dataTo.value
+    })
+
+    return { isShowingHelpForInputWithUnits, flexRowTitleStyle,
+      limitFrom, limitTo,
+      resetLimits(){
+        limitTo.value = dataTo.value
+        limitFrom.value = dataFrom.value
+      }
+
+       }
+  },
+})
+</script>

guiapp/src/components/GetNearFieldSettings.vue

@@ -95,10 +95,10 @@ export default defineComponent({
       set: val => $store.commit('simulationSetup/setNearFieldRelativePlotSize', val)
     })
 
-    const maxComputeTime = computed({
-      get: () => $store.state.simulationSetup.gui.nearFieldSetup.maxComputeTime,
-      set: val => $store.commit('simulationSetup/setNearFieldMaxComputeTime', val)
-    })
+    // const maxComputeTime = computed({
+    //   get: () => $store.state.simulationSetup.gui.nearFieldSetup.maxComputeTime,
+    //   set: val => $store.commit('simulationSetup/setNearFieldMaxComputeTime', val)
+    // })
 
     const plotSideResolution = computed({
       get: () => $store.state.simulationSetup.gui.nearFieldSetup.plotSideResolution,
@@ -107,7 +107,9 @@ export default defineComponent({
     })
 
     return { crossSection, isShowingHelpForInputWithUnits, flexRowTitleStyle,
-    relativePlotSize, maxComputeTime, plotSideResolution, nearFieldPlane}
+      relativePlotSize,
+      // maxComputeTime,
+      plotSideResolution, nearFieldPlane}
   },
 })
 </script>

guiapp/src/components/PlotNearField.vue

@@ -16,7 +16,11 @@ import {
   watch
 } from 'vue'
 // import { flexRowTitleStyle } from 'components/config'
-import { toUnits } from 'components/utils'
+import { toUnits,
+  getMaxFromHeatmap,
+  getMinFromHeatmap,
+  limitMap
+} from 'components/utils'
 import { plotlyChart } from 'src/store/plot-runtime/state'
 import { PlotData, DataTitle } from 'plotly.js-dist-min'
 import {nearFieldPlane} from 'src/store/simulation-setup/state';
@@ -66,25 +70,37 @@ export default defineComponent({
       let x:number[] = []
       let y:number[] = []
       for (let i = 0; i< plotSideResolution.value; ++i) {
-          x.push(toUnits(-x0.value + i*dx.value, units.value))
-          y.push(toUnits(-x0.value + i*dx.value, units.value))
+        for (let j = 0; j< plotSideResolution.value; ++j) {
+          x.push(toUnits(-x0.value + j * dx.value, units.value))
+          y.push(toUnits(-x0.value + i * dx.value, units.value))
+        }
       }
       return {x:x, y:y}
     })
 
+    const limitFrom = computed( ()=>$store.state.plotRuntime.nearFieldLimitFrom )
+    const limitTo = computed(()=>$store.state.plotRuntime.nearFieldLimitTo )
+
     const nearFieldEk = computed( ()=>$store.state.plotRuntime.nearFieldEk)
     const nearFieldHk = computed( ()=>$store.state.plotRuntime.nearFieldHk)
     const nearFieldEH = computed( ()=>$store.state.plotRuntime.nearFieldEH)
-    watch([nearFieldEk, nearFieldHk, nearFieldEH, xy], ()=>{
+    const nearFieldProc = computed( ()=>{
+      let nearFieldStore = nearFieldEk.value
+      if (crossSection.value == nearFieldPlane.Hk) nearFieldStore = nearFieldHk.value
+      if (crossSection.value == nearFieldPlane.EH) nearFieldStore = nearFieldEH.value
+      if (!nearFieldStore) return nearFieldStore
+      $store.commit('plotRuntime/setNearFieldDataTo',getMaxFromHeatmap(nearFieldStore))
+      $store.commit('plotRuntime/setNearFieldDataFrom',getMinFromHeatmap(nearFieldStore))
+      return limitMap(nearFieldStore, limitFrom.value, limitTo.value)
+      // return nearFieldStore.map(x=>x>limitTo.value?limitTo.value:x)
+    })
+    watch([nearFieldProc, xy], ()=>{
       nearFieldPlot.data.length = 0
       const heatMapSettings: Partial<PlotData> = {type: 'heatmap',
-        colorscale: 'Jet', colorbar:{title:'|𝐸|∕|𝐸𝜊|'}
+        colorscale: 'Jet', colorbar:{title:'|𝐸|∕|𝐸𝜊|'},
+        z: nearFieldProc.value
       }
-      let heatMapData: Partial<PlotData> = {}
-      if (crossSection.value == nearFieldPlane.Ek) heatMapData  = { z: nearFieldEk.value}
-      if (crossSection.value == nearFieldPlane.Hk) heatMapData  = { z: nearFieldHk.value}
-      if (crossSection.value == nearFieldPlane.EH) heatMapData  = { z: nearFieldEH.value}
-      nearFieldPlot.data.push({...xy.value, ...heatMapData, ...heatMapSettings})
+      nearFieldPlot.data.push({...xy.value, ...heatMapSettings})
 
       if (nearFieldPlot.layout.shapes) {
         nearFieldPlot.layout.shapes.length = 0

guiapp/src/components/RunSimulationNearField.vue

@@ -100,9 +100,7 @@ export default defineComponent({
                 crossSection,
                 0, 0, 0, 1
             )
-            let Eabs_list = Array.from(nmie.GetFieldEabs())
-            const Eabs = [];
-            while (Eabs_list.length) Eabs.push(Eabs_list.splice(0, plotSideResolution));
+            const Eabs = nmie.GetFieldEabs()
             if (crossSection == nearFieldPlane.Ek) $store.commit('plotRuntime/setNearFieldEk', Eabs)
             if (crossSection == nearFieldPlane.Hk) $store.commit('plotRuntime/setNearFieldHk', Eabs)
             if (crossSection == nearFieldPlane.EH) $store.commit('plotRuntime/setNearFieldEH', Eabs)

guiapp/src/components/utils.ts

@@ -1,3 +1,31 @@
+export function limitMap(arr:Float64Array, minVal:number, maxVal:number) {
+    return arr.map(x=>x>maxVal?maxVal:x).map(x=>x<minVal?minVal:x)
+}
+
+// According to https://stackoverflow.com/questions/1669190/find-the-min-max-element-of-an-array-in-javascript
+// getting max and min element is non trivial for large arrays (e.g. 512x512 points heatmap)
+export function getMaxFromHeatmap(val:Float64Array|undefined) {
+    let max = -Infinity
+    if (!val) return max
+    for (let i = 0; i < val.length; ++i) {
+        if (val[i] > max) {
+            max = val[i]
+        }
+    }
+    return max
+}
+export function getMinFromHeatmap(val:Float64Array|undefined) {
+    let min = Infinity
+    if (!val) return min
+    for (let i = 0; i < val.length; ++i) {
+        if (val[i] < min) {
+            min = val[i]
+        }
+    }
+    return min
+}
+
+
 export function composeLabelFromPageData (val:string) {
     const shelfName = val.slice(0, val.indexOf('/')+1)
     return val.replace(shelfName, ''

guiapp/src/nmiejs.d.ts

@@ -25,7 +25,7 @@ export class nmie_class {
                                   at_x: number, at_y: number, at_z: number,
                                   isIgnoreAvailableNmax: number): void;
 
-    GetFieldEabs(): number[];
+    GetFieldEabs(): Float64Array;
     GetQsca(): number;
     GetQabs(): number;
     GetQext(): number;

guiapp/src/pages/Near-field.vue

@@ -10,6 +10,8 @@
     <RunSimulationNearField/>
     <div class="q-ma-xs"/>
     <PlotNearField/>
+    <div class="q-ma-xs"/>
+    <GetNearFieldColorScale/>
 <!--    <div class="col-auto">-->
 <!--      Input result: {{$store.state.simulationSetup.gui.nearFieldSetup.plotSideResolution}}-->
 <!--    </div>-->
@@ -32,6 +34,7 @@ import RunSimulationSpectrum from 'components/RunSimulationSpectrum.vue'
 import RunSimulationNearField from 'components/RunSimulationNearField.vue'
 import PlotNearField from 'components/PlotNearField.vue'
 import ShowNearFieldWarning from 'components/ShowNearFieldWarning.vue'
+import GetNearFieldColorScale from 'components/GetNearFieldColorScale.vue'
 
 // import { useStore } from 'src/store'
 
@@ -39,6 +42,7 @@ import ShowNearFieldWarning from 'components/ShowNearFieldWarning.vue'
 export default defineComponent({
   name: 'NearField',
   components: {
+    GetNearFieldColorScale,
     ShowNearFieldWarning,
     PlotNearField,
     RunSimulationNearField,

guiapp/src/store/plot-runtime/mutations.ts

@@ -6,9 +6,13 @@ import { getModeName, toUnits } from 'components/utils'
 
 
 const mutation: MutationTree<prsi> = {
-  setNearFieldEk (state: prsi, val: number[][]) {state.nearFieldEk = cloneDeep(val)},
-  setNearFieldHk (state: prsi, val: number[][]) {state.nearFieldHk = cloneDeep(val)},
-  setNearFieldEH (state: prsi, val: number[][]) {state.nearFieldEH = cloneDeep(val)},
+  setNearFieldEk (state: prsi, val: Float64Array) {state.nearFieldEk = cloneDeep(val)},
+  setNearFieldHk (state: prsi, val: Float64Array) {state.nearFieldHk = cloneDeep(val)},
+  setNearFieldEH (state: prsi, val: Float64Array) {state.nearFieldEH = cloneDeep(val)},
+  setNearFieldDataFrom (state: prsi, val: number) {state.nearFieldDataFrom = val},
+  setNearFieldDataTo (state: prsi, val: number) {state.nearFieldDataTo = val},
+  setNearFieldLimitFrom (state: prsi, val: number) {state.nearFieldLimitFrom = val},
+  setNearFieldLimitTo (state: prsi, val: number) {state.nearFieldLimitTo = val},
 
   setQ (state: prsi, val: spectraData) {
     state.WLs    = cloneDeep(val.WLs)

guiapp/src/store/plot-runtime/state.ts

@@ -18,9 +18,13 @@ export interface spectraData {
 
 export interface plotRuntimeStateInterface {
   // Near field
-  nearFieldEk:number[][]
-  nearFieldHk:number[][]
-  nearFieldEH:number[][]
+  nearFieldEk:Float64Array|undefined
+  nearFieldHk:Float64Array|undefined
+  nearFieldEH:Float64Array|undefined
+  nearFieldDataFrom: number
+  nearFieldDataTo: number
+  nearFieldLimitFrom: number
+  nearFieldLimitTo: number
   // Spectra plots
   WLs: number[]
   WLsInUnits: number[]
@@ -46,9 +50,14 @@ export interface plotRuntimeStateInterface {
 }
 
 function state(): plotRuntimeStateInterface {
-  const nearFieldEk:number[][] = [[], []]
-  const nearFieldEH:number[][] = [[], []]
-  const nearFieldHk:number[][] = [[], []]
+  const nearFieldEk = undefined
+  const nearFieldEH = undefined
+  const nearFieldHk = undefined
+  const nearFieldDataFrom = 0
+  const nearFieldDataTo = 1e300
+  const nearFieldLimitFrom = 0
+  const nearFieldLimitTo = 1e300
+
   const WLs:number[] = []
   const WLsInUnits:number[] = []
   const Qsca:number[] = [], Qabs:number[] = [], Qext:number[] = []
@@ -101,6 +110,8 @@ function state(): plotRuntimeStateInterface {
 
   return {
     nearFieldEk, nearFieldHk, nearFieldEH,
+    nearFieldDataFrom,  nearFieldDataTo,
+    nearFieldLimitFrom, nearFieldLimitTo,
     WLs, WLsInUnits,
     Qsca, Qabs, Qext, Qsca_n, Qabs_n, Qext_n,
     spectrumPlots,

guiapp/src/store/simulation-setup/mutations.ts

@@ -72,7 +72,7 @@ const mutation: MutationTree<sssi> = {
   setNearFieldRelativePlotSize   (state: sssi, val: number)         {state.gui.nearFieldSetup.relativePlotSize   = val},
   setNearFieldPlotSideResolution (state: sssi, val: number)         {state.gui.nearFieldSetup.plotSideResolution = val},
   setNearFieldCrossSection       (state: sssi, val: nearFieldPlane) {state.gui.nearFieldSetup.crossSection       = val},
-  setNearFieldMaxComputeTime     (state: sssi, val: number)         {state.gui.nearFieldSetup.maxComputeTime     = val},
+  // setNearFieldMaxComputeTime     (state: sssi, val: number)         {state.gui.nearFieldSetup.maxComputeTime     = val},
 
   setFarFieldWL    (state: sssi, val: number) { state.gui.farFieldWL  = val},
 

guiapp/src/store/simulation-setup/state.ts

@@ -30,7 +30,7 @@ export interface nearFieldSetup {
   relativePlotSize: number
   plotSideResolution: number
   crossSection: nearFieldPlane
-  maxComputeTime: number //in seconds
+  // maxComputeTime: number //in seconds
 }
 
 export interface simulationSetup {
@@ -75,7 +75,7 @@ function setupFactory(hostIndex = 1,
                         relativePlotSize: 2,
                         plotSideResolution: 64,
                         crossSection: nearFieldPlane.Ek,
-                        maxComputeTime: 5 //in seconds
+                        // maxComputeTime: 5 //in seconds
                       },
 
                       farFieldWL = 619,