Revision: 18613
          http://sourceforge.net/p/jmol/code/18613
Author:   hansonr
Date:     2013-08-22 05:06:08 +0000 (Thu, 22 Aug 2013)
Log Message:
-----------
simpler expressions -- do check!

Modified Paths:
--------------
    trunk/Jmol/src/org/jmol/util/Tensor.java

Modified: trunk/Jmol/src/org/jmol/util/Tensor.java
===================================================================
--- trunk/Jmol/src/org/jmol/util/Tensor.java    2013-08-21 22:41:14 UTC (rev 
18612)
+++ trunk/Jmol/src/org/jmol/util/Tensor.java    2013-08-22 05:06:08 UTC (rev 
18613)
@@ -180,13 +180,13 @@
     case 5: // value
       return Float.valueOf(eigenValues[2]);
     case 6: // isotropy
-      return Float.valueOf(getIso());
+      return Float.valueOf(iso());
     case 7: // anisotropy
       // Anisotropy, defined as Vzz-(Vxx+Vyy)/2
-      return Float.valueOf(getAnisotropy()); 
+      return Float.valueOf(anisotropy()); 
     case 8: // asymmetry
       // Asymmetry, defined as (Vyy-Vxx)/(Vzz - Viso)
-      return Float.valueOf(getAsymmetry());
+      return Float.valueOf(asymmetry());
  
       
     case 9: // eulerzyz
@@ -209,43 +209,125 @@
       return id;
     
     case 16:
-      return Float.valueOf(getSpan());
+      return Float.valueOf(span());
     case 17:
-      return Float.valueOf(getSkew());
+      return Float.valueOf(skew());
     
     }
   }
 
-  public float getIso() {
+  //                |                  |        |
+  //                |                  |        |
+  //               e2                 e1       e0
+  //                               |
+  //                              iso
+    
+  /**
+   * isotropy = average of eigenvalues
+   * 
+   * @return isotropy
+   */
+  public float iso() {
     return (eigenValues[0] + eigenValues[1] + eigenValues[2]) / 3;
   }
 
-  public float getAnisotropy() {
-    return eigenValues[2] - (eigenValues[0] + eigenValues[1]) / 2;
+  //                |                  |        |
+  //                |                  |        |
+  //                e2                 e1       e0
+  //                |---------------------------|
+  //                            span      
+  //
+  // span = |e2 - e0|
+  //
+    
+  /**
+   * width of the signal; |e2 - e0|
+   * 
+   * @return unitless; >= 0
+   */
+  public float span() {
+    return Math.abs(eigenValues[2] - eigenValues[0]);  
   }
 
-  public float getAsymmetry() {
-    return eigenValues[0] == eigenValues[2] ? 0 : (eigenValues[1] - 
eigenValues[0])
-        / (eigenValues[2] - getIso());
-  }
+
   
-  public float getSpan() {
-    float red_aniso = eigenValues[2]-getIso();
-    float asymm = getAsymmetry();
+  //                |                  |        |
+  //                |                  |        |
+  //                e2              | e1       e0
+  //                               iso           
+  //                                     
+  //                |---------------------------|
+  //                            span      
+  //
+  // skew = 3 (e1 - iso) / span
+  //
+  //  or 0 if 0/0
     
-    if (red_aniso > 0.0)
-      return red_aniso*(3.0f+asymm)/2.0f;
+  /**
+   * a measure of asymmetry.
+   * 
+   * @return range [-1, 1]
+   */
+  public float skew() {
+    return (span() == 0 ? 0 : 3 * (eigenValues[1] - iso()) / span());
+  }
 
-    return -red_aniso*(3.0f+asymm)/2.0f;
+
+  // anistropy = e2 - (e1 + e0)/2
+  //
+  //                |                  |        |
+  //                |                  |        |
+  //               e2                 e1       e0
+  //                <----------------------|              
+  //                        anisotropy
+    
+  /**
+   * anisotropy = directed distance from (center of two closest) to (the 
furthest)
+   * @return unitless number
+   */
+  public float anisotropy() {
+    return eigenValues[2] - (eigenValues[0] + eigenValues[1]) / 2;
   }
-  
-  public float getSkew() {
-    float red_aniso = eigenValues[2]-getIso();
-    float asymm = getAsymmetry();
 
-    return -3.0f*red_aniso*(1.0f-asymm)/2.0f/getSpan();
+  //  reduced anisotropy = e2 - iso = anisotropy * 2/3
+  //
+  //                |                  |        |
+  //                |                  |        |
+  //                e2            iso  e1       e0
+  //                <----------------------|              
+  //                        anisotropy
+  //                <--------------|
+  //                  reduced anisotropy
+    
+  /**
+   * reduced anisotropy = largest difference from isotropy
+   * (may be negative)
+   * 
+   * @return unitless number
+   * 
+   */
+  public float redAniso() {
+    return anisotropy() * 2 / 3;  // = eigenValues[2]-iso();
   }
 
+  // asymmetry = d10/ra
+  //
+  //                |                  |        |
+  //                |                  |        |
+  //                e2            iso  e1       e0
+  //                <--------------|   <--------|
+  //                       ra              d10
+  //  or 0 when 0/0
+
+  /**
+   * asymmetry = deviation from a symmetric tensor
+   * 
+   * @return range [0,1]
+   */
+  public float asymmetry() {
+    return span() == 0 ? 0 : (eigenValues[1] - eigenValues[0]) / redAniso();
+  }
+
   public static Tensor copyTensor(Tensor t0) {
     Tensor t = new Tensor();
     t.setType(t0.type);

This was sent by the SourceForge.net collaborative development platform, the 
world's largest Open Source development site.


------------------------------------------------------------------------------
Introducing Performance Central, a new site from SourceForge and 
AppDynamics. Performance Central is your source for news, insights, 
analysis and resources for efficient Application Performance Management. 
Visit us today!
http://pubads.g.doubleclick.net/gampad/clk?id=48897511&iu=/4140/ostg.clktrk
_______________________________________________
Jmol-commits mailing list
Jmol-commits@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/jmol-commits

Reply via email to