git-svn-id: http://svn.code.sf.net/p/jmol/code/trunk/Jmol@20943 62be2…

…7d7-c70d-0410-b753-bb59b6ba1b27

unused/MOCalculationInterface.java

@@ -0,0 +1,35 @@
+package org.jmol.api;
+
+
+
+
+
+import javajs.util.Lst;
+import javajs.util.T3;
+
+import org.jmol.java.BS;
+
+
+public interface MOCalculationInterface {
+
+  public abstract boolean setupCalculation(VolumeDataInterface volumeData,
+                                           BS bsSelected, BS bsExclude,
+                                           BS[] bsMolecules,
+                                           String calculationType,
+                                           T3[] atomCoordAngstroms,
+                                           T3[] atoms,
+                                           int firstAtomOffset,
+                                           Lst<int[]> shells,
+                                           float[][] gaussians,
+                                           int[][] dfCoefMaps, Object slaters,
+                                           float[] moCoefficients,
+                                           float[] linearCombination,
+                                           boolean isSquaredLinear,
+                                           float[][] coefs,
+                                           float[] partialCharges,
+                                           boolean doNormalize, T3[] points,
+                                           float[] parameters, int testFlags);
+
+  public abstract void createCube();
+  public abstract float processPt(T3 pt);
+}

unused/MepCalculationInterface.java

@@ -0,0 +1,23 @@
+package org.jmol.api;
+
+
+
+import org.jmol.java.BS;
+import org.jmol.modelset.Atom;
+import org.jmol.viewer.Viewer;
+
+import javajs.util.P3;
+
+
+public interface MepCalculationInterface {
+
+  public abstract void calculate(VolumeDataInterface volumeData, BS bsSelected,
+                                 P3[] atomCoordAngstroms, float[] charges, int calcType);
+
+  public abstract void assignPotentials(Atom[] atoms, float[] potentials, BS bsAromatic, BS bsCarbonyl, BS bsIgnore, String data);
+
+  public abstract float valueFor(float x, float d2, int distanceMode);
+
+  public abstract void set(Viewer vwr);
+
+}

unused/MinimizerInterface.java

@@ -0,0 +1,25 @@
+package org.jmol.api;
+
+
+import org.jmol.java.BS;
+import org.jmol.modelset.Atom;
+import org.jmol.modelset.Bond;
+import org.jmol.thread.JmolThread;
+import org.jmol.viewer.JmolAsyncException;
+
+
+
+public interface MinimizerInterface {
+
+  public abstract boolean minimize(int steps, double crit, BS bsSelected, 
+                                   BS bsFixed, boolean haveFixed, 
+                                   boolean isSilent, String ff) throws Exception;
+  public abstract MinimizerInterface setProperty(String propertyName, Object propertyValue);
+  public abstract Object getProperty(String propertyName, int param);
+  public abstract void calculatePartialCharges(Bond[] bonds, int bondCount, Atom[] atoms, BS bsAtoms) throws JmolAsyncException;
+  public abstract boolean startMinimization();
+  public abstract boolean stepMinimization();
+  public abstract void endMinimization();
+  public abstract boolean minimizationOn();
+  public abstract JmolThread getThread();
+}

unused/QuantumPlaneCalculationInterface.java

@@ -0,0 +1,55 @@
+package org.jmol.api;
+
+/**
+ * Allows modification of the planes prior to isosurface creation
+ * Used by Noncovalent Interaction Calculation for progressive readers
+ */
+
+public interface QuantumPlaneCalculationInterface extends MOCalculationInterface {
+
+  /**
+   * Planes to use for holding raw file data. These will be managed by
+   * VolumeFileReader, but they will be needed by the calculation.
+   * 
+   * @param planes   a set of four planes that shifts as the progressive
+   *                 Marching Cubes process moves along
+   */
+  public abstract void setPlanes(float[][] planes);
+
+  /**
+   * Fill this plane with data based on the current set of raw data planes. 
+   * Really there are just two planes that are managed by VolumeFileReader
+   * and are interchanged as the Marching Cubes process moves along.
+   * @param x 
+   * 
+   * @param plane
+   */
+
+  public abstract void calcPlane(int x, float[] plane);
+
+  /**
+   * 
+   * Data mapping function to radically increase speed and reduce
+   * memory requirements of mapping data when the mapping comes from
+   * the same data set as the points, so isosurface creation and 
+   * data mapping can be carried out both in the first (and only) pass. 
+   * 
+   * 
+   * @param vA  absolute pointer to vertex A on grid 
+   * @param vB  absolute pointer to vertex B on grid
+   * @param f   fractional way from A to B
+   * @return    computed value
+   */
+  public abstract float process(int vA, int vB, float f);
+
+  /**
+   * Get that value that represents "no value" so that it can be
+   * disregarded in terms of recording and reporting the min/max/mean.
+   *         
+   * @return NO_VALUE
+   */
+  public abstract float getNoValue();
+
+  public abstract void getPlane(int x, float[] yzPlane);
+
+}

unused/VolumeDataInterface.java

@@ -0,0 +1,47 @@
+package org.jmol.api;
+
+
+import javajs.util.T3;
+import javajs.util.T3i;
+import javajs.util.P4;
+import javajs.util.V3;
+
+public interface VolumeDataInterface {
+
+  public abstract void setVoxelDataAsArray(float[][][] voxelData);
+
+  public abstract float[][][] getVoxelData();
+
+  public abstract int setVoxelCounts(int nPointsX, int nPointsY, int nPointsZ);
+
+  public abstract int[] getVoxelCounts();
+
+  public abstract void setVolumetricVector(int i, float x, float y, float z);
+
+  public abstract float[] getVolumetricVectorLengths();
+
+  public abstract void setVolumetricOrigin(float x, float y, float z);
+
+  public abstract float[] getOriginFloat();
+
+  public abstract void setDataDistanceToPlane(P4 plane);
+
+  public abstract void setPlaneParameters(P4 plane);
+
+  public abstract float calcVoxelPlaneDistance(int x, int y, int z);
+
+  public abstract float distancePointToPlane(T3 pt);
+
+  public abstract void transform(V3 v1, V3 v2);
+
+  public abstract void voxelPtToXYZ(int x, int y, int z, T3 pt);
+
+  public abstract void xyzToVoxelPt(float x, float y, float z, T3i pt3i);
+
+  public abstract float lookupInterpolatedVoxelValue(T3 point, boolean getSource);
+
+  public abstract void filterData(boolean isSquared, float invertCutoff);
+
+  public abstract void capData(P4 plane, float cutoff);
+
+}