NciCalculation
Date: 2019-10-22

org.jmol.quantum

## Class NciCalculation

- java.lang.Object
- - org.jmol.quantum.QuantumCalculation
  - - org.jmol.quantum.QuantumPlaneCalculation
    - - org.jmol.quantum.NciCalculation

-     public class NciCalculation
      extends QuantumPlaneCalculation

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `private javajs.util.BS` | `bsOK`
    `private static double` | `c`
    `private static double[]` | `coef1`
    `private static double[]` | `coef2`
    `private static double[]` | `coef3`
    `private boolean` | `dataIsReducedDensity`
    `private float` | `dataScaling`
    `private double` | `DEFAULT_RHOPARAM`
    `private double` | `DEFAULT_RHOPLOT_PRO`
    `private double` | `DEFAULT_RHOPLOT_SCF`
    `private static double[]` | `dMax`
    `private javajs.util.Eigen` | `eigen`
    `private float[]` | `eigenValues`
    `private double` | `grad`
    `private double` | `gxTemp`
    `private double` | `gxxTemp`
    `private double` | `gxyTemp`
    `private double` | `gxzTemp`
    `private double` | `gyTemp`
    `private double` | `gyyTemp`
    `private double` | `gyzTemp`
    `private double` | `gzTemp`
    `private double` | `gzzTemp`
    `private boolean` | `havePoints`
    `private double[][]` | `hess`
    `private boolean` | `isPromolecular`
    `private boolean` | `isReducedDensity`
    `private int` | `nMolecules`
    `private static double` | `NO_VALUE`
    `private boolean` | `noValuesAtAll`
    `private float[]` | `p0`
    `private float[]` | `p1`
    `private float[]` | `p2`
    `private double` | `rhoMin`
    `private double[]` | `rhoMolecules`
    `private double` | `rhoParam`
    `private double` | `rhoPlot`
    `private static double` | `rpower`
    `(package private) double` | `test1`
    `private int` | `type`
    `private static int` | `TYPE_ALL`
    `private static int` | `TYPE_INTER`
    `private static int` | `TYPE_INTRA`
    `private static int` | `TYPE_LIGAND`
    `private boolean` | `useAbsolute`
    `private int` | `yzCount`
    `private float[][]` | `yzPlanesRaw`
    `private float[][]` | `yzPlanesRho`
    `private static double[]` | `zeta1`
    `private static double[]` | `zeta2`
    `private static double[]` | `zeta3`

    - ### Fields inherited from class org.jmol.quantum.QuantumCalculation

      `atomIndex, bohr_per_angstrom, bsExcluded, countsXYZ, doDebug, firstAtomOffset, integration, nX, nY, nZ, originBohr, points, qmAtoms, rangeBohrOrAngstroms, stepBohr, thisAtom, unitFactor, volume, voxelData, voxelDataTemp, X, X2, xBohr, xMax, xMin, Y, Y2, yBohr, yMax, yMin, Z, Z2, zBohr, zMax, zMin`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `NciCalculation()`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `calcPlane(int x, float[] plane)` For reduced density only; coloring is done point by point.
    `void` | `createCube()`
    `private void` | `getBsOK()` grid-based discrete SCF calculation needs to know which atoms to consider inter and which intramolecular
    `float` | `getNoValue()` Get that value that represents "no value" so that it can be disregarded in terms of recording and reporting the min/max/mean.
    `private static double` | `getParameter(float[] parameters, int i, double def, java.lang.String name)`
    `void` | `getPlane(int ix, float[] yzPlane)`
    `private double` | `getPlaneValue(int vA)` We always have four raw planes in hand; we just need to know which three to use in any particular case.
    `private float` | `getValue(double rho, boolean isReducedDensity)`
    `private void` | `initializeEigen()`
    `protected void` | `initializeOnePoint()`
    `protected void` | `process()`
    `float` | `process(int vA, int vB, float f)` Passing the grid points of the two ends of an edge and a fraction to this method returns the value at a triangle point.
    `private double` | `processAtoms(int ix, int iy, int iz, int index)` At each grid point we need to calculate the sum of the atom-based promolecular data.
    `void` | `setPlanes(float[][] planes)` Raw file data planes are passed to us here from VolumeFileReader
    `boolean` | `setupCalculation(VolumeData volumeData, javajs.util.BS bsSelected, javajs.util.BS bsExcluded, javajs.util.BS[] bsMolecules, javajs.util.T3[] atomCoordAngstroms, int firstAtomOffset, boolean isReducedDensity, javajs.util.T3[] points, float[] parameters, int testFlags)`

    - ### Methods inherited from class org.jmol.quantum.QuantumCalculation

      `getIntegration, initialize, initialize0, initializeOnePointQC, processPoints, processPt, setMinMax, setupCoordinates, setXYZBohr`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### havePoints

          private boolean havePoints

    - #### isReducedDensity

          private boolean isReducedDensity

    - #### DEFAULT_RHOPLOT_SCF

          private double DEFAULT_RHOPLOT_SCF

    - #### DEFAULT_RHOPLOT_PRO

          private double DEFAULT_RHOPLOT_PRO

    - #### DEFAULT_RHOPARAM

          private double DEFAULT_RHOPARAM

    - #### rhoMin

          private double rhoMin

    - #### rhoPlot

          private double rhoPlot

    - #### rhoParam

          private double rhoParam

    - #### TYPE_ALL

          private static final int TYPE_ALL

      See Also:
        Constant Field Values

    - #### TYPE_INTRA

          private static final int TYPE_INTRA

      See Also:
        Constant Field Values

    - #### TYPE_INTER

          private static final int TYPE_INTER

      See Also:
        Constant Field Values

    - #### TYPE_LIGAND

          private static final int TYPE_LIGAND

      See Also:
        Constant Field Values

    - #### NO_VALUE

          private static final double NO_VALUE

      See Also:
        Constant Field Values

    - #### dataScaling

          private float dataScaling

    - #### dataIsReducedDensity

          private boolean dataIsReducedDensity

    - #### eigen

          private javajs.util.Eigen eigen

    - #### rhoMolecules

          private double[] rhoMolecules

    - #### type

          private int type

    - #### nMolecules

          private int nMolecules

    - #### isPromolecular

          private boolean isPromolecular

    - #### bsOK

          private javajs.util.BS bsOK

    - #### noValuesAtAll

          private boolean noValuesAtAll

    - #### useAbsolute

          private boolean useAbsolute

    - #### c

          private static double c

    - #### rpower

          private static double rpower

    - #### hess

          private double[][] hess

    - #### grad

          private double grad

    - #### gxTemp

          private double gxTemp

    - #### gyTemp

          private double gyTemp

    - #### gzTemp

          private double gzTemp

    - #### gxxTemp

          private double gxxTemp

    - #### gyyTemp

          private double gyyTemp

    - #### gzzTemp

          private double gzzTemp

    - #### gxyTemp

          private double gxyTemp

    - #### gyzTemp

          private double gyzTemp

    - #### gxzTemp

          private double gxzTemp

    - #### eigenValues

          private float[] eigenValues

    - #### test1

          double test1

    - #### yzPlanesRaw

          private float[][] yzPlanesRaw

    - #### yzCount

          private int yzCount

    - #### yzPlanesRho

          private float[][] yzPlanesRho

    - #### p0

          private float[] p0

    - #### p1

          private float[] p1

    - #### p2

          private float[] p2

    - #### coef1

          private static double[] coef1

    - #### coef2

          private static double[] coef2

    - #### coef3

          private static double[] coef3

    - #### zeta1

          private static double[] zeta1

    - #### zeta2

          private static double[] zeta2

    - #### zeta3

          private static double[] zeta3

    - #### dMax

          private static double[] dMax

  - ### Constructor Detail

    - #### NciCalculation

          public NciCalculation()

  - ### Method Detail

    - #### getNoValue

          public float getNoValue()

      Description copied from class: `QuantumPlaneCalculation`
      Get that value that represents "no value" so that it can be disregarded in terms of recording and reporting the min/max/mean.
      Specified by:
        `getNoValue` in class `QuantumPlaneCalculation`
      Returns:
        NO_VALUE

    - #### setupCalculation

          public boolean setupCalculation(VolumeData volumeData,
                                          javajs.util.BS bsSelected,
                                          javajs.util.BS bsExcluded,
                                          javajs.util.BS[] bsMolecules,
                                          javajs.util.T3[] atomCoordAngstroms,
                                          int firstAtomOffset,
                                          boolean isReducedDensity,
                                          javajs.util.T3[] points,
                                          float[] parameters,
                                          int testFlags)

    - #### getParameter

          private static double getParameter(float[] parameters,
                                             int i,
                                             double def,
                                             java.lang.String name)

    - #### getBsOK

          private void getBsOK()

      grid-based discrete SCF calculation needs to know which atoms to consider inter and which intramolecular

    - #### createCube

          public void createCube()

      Specified by:
        `createCube` in class `QuantumCalculation`

    - #### initializeOnePoint

          protected void initializeOnePoint()

      Overrides:
        `initializeOnePoint` in class `QuantumCalculation`

    - #### initializeEigen

          private void initializeEigen()

    - #### getPlane

          public void getPlane(int ix,
                               float[] yzPlane)

      Specified by:
        `getPlane` in class `QuantumPlaneCalculation`

    - #### process

          protected void process()

      Specified by:
        `process` in class `QuantumCalculation`

    - #### getValue

          private float getValue(double rho,
                                 boolean isReducedDensity)

    - #### processAtoms

          private double processAtoms(int ix,
                                      int iy,
                                      int iz,
                                      int index)

      At each grid point we need to calculate the sum of the atom-based promolecular data. We partition this calculation into molecular subsets if necessary, and we check for atoms that are too far away to make a difference before we waste time doing exponentiation. If index >= 0, then this is just a check for intra- vs. inter- molecularity based on promolecular density. This is needed for applying intra- and inter-molecular filters to SCF CUBE data.
      Parameters:
        `ix` -
        `iy` -
        `iz` -
        `index` -
      Returns:
        rho value or NO_VALUE

    - #### setPlanes

          public void setPlanes(float[][] planes)

      Raw file data planes are passed to us here from VolumeFileReader
      Specified by:
        `setPlanes` in class `QuantumPlaneCalculation`
      Parameters:
        `planes` -

    - #### calcPlane

          public void calcPlane(int x,
                                float[] plane)

      For reduced density only; coloring is done point by point.
      Specified by:
        `calcPlane` in class `QuantumPlaneCalculation`
      Parameters:
        `x` -
        `plane` - an OUTPUT plane, to be filled here and used by MarchingCubes

    - #### process

          public float process(int vA,
                               int vB,
                               float f)

      Passing the grid points of the two ends of an edge and a fraction to this method returns the value at a triangle point. This way we do not need to calculate this for EVERY point on the grid, only the ones that are part of the surface.
      Specified by:
        `process` in class `QuantumPlaneCalculation`
      Parameters:
        `vA` -
        `vB` -
        `f` -
      Returns:
        value at point f-way between vA and vB

    - #### getPlaneValue

          private double getPlaneValue(int vA)

      We always have four raw planes in hand; we just need to know which three to use in any particular case.
      Parameters:
        `vA` -
      Returns:
        value of sign(lambda2)*rho at this grid point