org.jmol.quantum
Class NciCalculation

java.lang.Object
  extended by org.jmol.quantum.QuantumCalculation
      extended by org.jmol.quantum.NciCalculation
All Implemented Interfaces:
QuantumCalculationInterface, QuantumPlaneCalculationInterface

public class NciCalculation
extends QuantumCalculation
implements QuantumPlaneCalculationInterface


Nested Class Summary
 
Nested classes/interfaces inherited from class org.jmol.quantum.QuantumCalculation
QuantumCalculation.QMAtom
 
Field Summary
private  java.util.BitSet 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  Eigen eigen
           
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, nX, nY, nZ, originBohr, points, qmAtoms, rangeBohrOrAngstroms, stepBohr, thisAtom, unitFactor, vd, volume, voxelData, X, X2, xBohr, xMax, xMin, Y, Y2, yBohr, yMax, yMin, Z, Z2, zBohr, zMax, zMin
 
Constructor Summary
NciCalculation()
           
 
Method Summary
 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(VolumeDataInterface volumeData, java.util.BitSet bsSelected, java.util.BitSet bsExcluded, java.util.BitSet[] bsMolecules, java.lang.String calculationType, javax.vecmath.Point3f[] atomCoordAngstroms, int firstAtomOffset, java.util.List<int[]> shells, float[][] gaussians, int[][] dfCoefMaps, java.lang.Object slaters, float[] moCoefficients, float[] linearCombination, float[][] coefs, float[] partialCharges, boolean isDensityOnly, javax.vecmath.Point3f[] points, float[] parameters, int testFlags)
           
 
Methods inherited from class org.jmol.quantum.QuantumCalculation
initialize, process, processPoints, setMinMax, setupCoordinates, setXYZBohr
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 
Methods inherited from interface org.jmol.api.QuantumCalculationInterface
process
 

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 Eigen eigen

rhoMolecules

private double[] rhoMolecules

type

private int type

nMolecules

private int nMolecules

isPromolecular

private boolean isPromolecular

bsOK

private java.util.BitSet 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

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 interface: QuantumPlaneCalculationInterface
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 interface QuantumPlaneCalculationInterface
Returns:
NO_VALUE

setupCalculation

public boolean setupCalculation(VolumeDataInterface volumeData,
                                java.util.BitSet bsSelected,
                                java.util.BitSet bsExcluded,
                                java.util.BitSet[] bsMolecules,
                                java.lang.String calculationType,
                                javax.vecmath.Point3f[] atomCoordAngstroms,
                                int firstAtomOffset,
                                java.util.List<int[]> shells,
                                float[][] gaussians,
                                int[][] dfCoefMaps,
                                java.lang.Object slaters,
                                float[] moCoefficients,
                                float[] linearCombination,
                                float[][] coefs,
                                float[] partialCharges,
                                boolean isDensityOnly,
                                javax.vecmath.Point3f[] points,
                                float[] parameters,
                                int testFlags)
Specified by:
setupCalculation in interface QuantumCalculationInterface

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 interface QuantumCalculationInterface

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 interface QuantumPlaneCalculationInterface

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 interface QuantumPlaneCalculationInterface
Parameters:
planes -

calcPlane

public void calcPlane(int x,
                      float[] plane)
For reduced density only; coloring is done point by point.

Specified by:
calcPlane in interface QuantumPlaneCalculationInterface
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 interface QuantumPlaneCalculationInterface
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