ModulationSet

java.lang.Object
- javajs.util.T3
- - javajs.util.V3
  - - org.jmol.util.Vibration
    - - org.jmol.util.ModulationSet

All Implemented Interfaces:

java.io.Serializable, javajs.api.JSONEncodable, JmolModulationSet
```
public class ModulationSet
extends Vibration
implements JmolModulationSet
```
A class to group a set of modulations for an atom as a "vibration" Extends V3 so that it will be a displacement, and its value will be an occupancy

Author:

Bob Hanson hansonr@stolaf.edu 8/9/2013

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`enabled`
`private javajs.util.M3`	`gammaE`
`private javajs.util.Matrix`	`gammaIinv`
`java.util.Map<java.lang.String,java.lang.Float>`	`htUij`
`(package private) java.lang.String`	`id`
`private int`	`iop`
`private boolean`	`isQ`
`private boolean`	`isSubsystem`
`private int`	`modDim`
`private javajs.util.List<Modulation>`	`mods`
`private ModulationSet`	`modTemp`
`(package private) javajs.util.P3`	`ptTemp`
`private javajs.util.P3`	`qtOffset`
`private javajs.util.P3`	`r0`
`private float`	`scale`
`private javajs.util.Matrix`	`sI`
`private javajs.util.Matrix`	`sigma`
`private java.lang.String`	`strop`
`private SymmetryInterface`	`symmetry`
`private javajs.util.Matrix`	`t`
`private javajs.util.Matrix`	`tau`
`private javajs.util.Matrix`	`tFactor`
`float`	`vOcc`
`float`	`vOcc0`

Fields inherited from class org.jmol.util.Vibration
twoPI

Fields inherited from class javajs.util.T3
x, y, z

Constructor Summary

Constructors
Constructor and Description

ModulationSet()

Constructors
Constructor and Description
`ModulationSet()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addTo(javajs.util.T3 a, float scale)`
`void`	`addUTens(java.lang.String utens, float v)`
`ModulationSet`	`calculate(javajs.util.T3 fracT, boolean isQ)` In general, we have, for Fourier: u_axis(x) = sum[A1 cos(theta) + B1 sin(theta)] where axis is x, y, or z, and theta = 2n pi x More generally, we have for a given rotation that is characterized by X {x4 x5 x6 ...} Gamma_E (R3 rotation) Gamma_I (X rotation) S_I (X translation) We allow here only up to x6, simply because we are using standard R3 rotation objects Matrix3f, P3, V3.
`void`	`getInfo(java.util.Map<java.lang.String,java.lang.Object> info)`
`private void`	`getModTemp()`
`java.lang.Object`	`getModulation(java.lang.String type, javajs.util.T3 t456)`
`float`	`getScale()`
`java.lang.String`	`getState()`
`SymmetryInterface`	`getUnitCell()`
`boolean`	`isEnabled()`
`ModulationSet`	`set(java.lang.String id, javajs.util.P3 r, int modDim, javajs.util.List<Modulation> mods, javajs.util.M3 gammaE, javajs.util.Matrix[] factors, int iop, SymmetryInterface symmetry)` A collection of modulations for a specific atom.
`void`	`setModTQ(javajs.util.T3 a, boolean isOn, javajs.util.T3 qtOffset, boolean isQ, float scale)` Set modulation "t" value, which sets which unit cell in sequence we are looking at; d=1 only.
`void`	`setTempPoint(javajs.util.T3 a, javajs.util.T3 t456, float vibScale, float scale)`

Methods inherited from class javajs.util.V3
angle, cross, new3, newV, newVsub

Methods inherited from class javajs.util.T3
add, add2, add3, ave, distance, distanceSquared, dot, equals, floatToIntBits0, hashCode, length, lengthSquared, normalize, scale, scaleAdd2, set, setA, setT, sub, sub2, toJSON, toString

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - vOcc
```
public float vOcc
```
  - htUij
```
public java.util.Map<java.lang.String,java.lang.Float> htUij
```
  - vOcc0
```
public float vOcc0
```
  - id
```
java.lang.String id
```
  - mods
```
private javajs.util.List<Modulation> mods
```
  - modDim
```
private int modDim
```
  - iop
```
private int iop
```
  - r0
```
private javajs.util.P3 r0
```
  - symmetry
```
private SymmetryInterface symmetry
```
  - gammaE
```
private javajs.util.M3 gammaE
```
  - gammaIinv
```
private javajs.util.Matrix gammaIinv
```
  - sigma
```
private javajs.util.Matrix sigma
```
  - sI
```
private javajs.util.Matrix sI
```
  - tau
```
private javajs.util.Matrix tau
```
  - enabled
```
private boolean enabled
```
  - scale
```
private float scale
```
  - qtOffset
```
private javajs.util.P3 qtOffset
```
  - isQ
```
private boolean isQ
```
  - t
```
private javajs.util.Matrix t
```
  - modTemp
```
private ModulationSet modTemp
```
  - strop
```
private java.lang.String strop
```
  - isSubsystem
```
private boolean isSubsystem
```
  - tFactor
```
private javajs.util.Matrix tFactor
```
  - ptTemp
```
javajs.util.P3 ptTemp
```
- Constructor Detail
  - ModulationSet
```
public ModulationSet()
```
- Method Detail
  - getScale
```
public float getScale()
```
    Specified by:
    
    getScale in interface JmolModulationSet
  - isEnabled
```
public boolean isEnabled()
```
    Specified by:
    
    isEnabled in interface JmolModulationSet
  - set
```
public ModulationSet set(java.lang.String id,
                         javajs.util.P3 r,
                         int modDim,
                         javajs.util.List<Modulation> mods,
                         javajs.util.M3 gammaE,
                         javajs.util.Matrix[] factors,
                         int iop,
                         SymmetryInterface symmetry)
```
    A collection of modulations for a specific atom. The set of cell wave vectors form the sigma (d x 3) array, one vector per row. Muliplying sigma by the atom vector r (3 x 1) gives us a (d x 1) column vector. This column vector is the set of coefficients of [x4, x5, x6...] that I will call X. Similarly, we express the x1' - xn' aspects of the operators as the matrices Gamma_I (d x d epsilons) and s_I (d x 1 shifts). In the case of subsystems, these are extracted from: {Rs_nu | Vs_nu} = W_nu {Rs|Vs} W_nu^-1 Then for X defined as [x4,x5,x6...] we have: X' = Gamma_I * X + S_I or X = (Gamma_I^-1)(X' - S_I) I call this array "tau". We can think of this as a distance along the asn axis, as in a t-plot. Ultimately we will need to add in a term allowing us to adjust the t-value: X = (Gamma_I^-1)(X' - S_I + t) X = tau + (Gamma_I^-1)(t) or, below: xt = gammaIinv.mul(t).add(tau) For subsystem nu, we need to use t_nu, which will be t_nu = (W_dd - sigma W_3d) t (van Smaalen, p. 101) t_nu = (tFactor) t so this becomes xt = gammaIinv.mul(tFactor.inverse().mul(t)).add(tau) Thus we have two subsystem-dependent modulation factors we need to bring in, sigma and tFactor, and two we need to compute, GammaIinv and tau.
    
    Parameters:
    
    id -
    
    r -
    
    modDim -
    
    mods -
    
    gammaE -
    
    factors - including sigma and tFactor
    
    iop -
    
    symmetry -
    
    Returns:
    
    this
  - getUnitCell
```
public SymmetryInterface getUnitCell()
```
    Overrides:
    
    getUnitCell in class Vibration
  - calculate
```
public ModulationSet calculate(javajs.util.T3 fracT,
                               boolean isQ)
```
    In general, we have, for Fourier: u_axis(x) = sum[A1 cos(theta) + B1 sin(theta)] where axis is x, y, or z, and theta = 2n pi x More generally, we have for a given rotation that is characterized by X {x4 x5 x6 ...} Gamma_E (R3 rotation) Gamma_I (X rotation) S_I (X translation) We allow here only up to x6, simply because we are using standard R3 rotation objects Matrix3f, P3, V3. We desire: u'(X') = Gamma_E u(X) which is defined as [private communication, Vaclav Petricek]: u'(X') = Gamma_E sum[ U_c cos(2 pi (n m).Gamma_I^-1{X - S_I}) + U_s sin(2 pi (n m).Gamma_I^-1{X - S_I}) ] where U_c and U_s are coefficients for cos and sin, respectively (will be a1 and a2 here) (n m) is an array of Fourier number coefficients, such as (1 0), (1 -1), or (0 2) In Jmol we precalculate Gamma_I^-1(X - S_I) as tau, but we still have to factor in Gamma_I^-1(t).
    
    Parameters:
    
    fracT -
    
    isQ -
    
    Returns:
    
    this
  - addUTens
```
public void addUTens(java.lang.String utens,
                     float v)
```
  - setModTQ
```
public void setModTQ(javajs.util.T3 a,
                     boolean isOn,
                     javajs.util.T3 qtOffset,
                     boolean isQ,
                     float scale)
```
    Set modulation "t" value, which sets which unit cell in sequence we are looking at; d=1 only.
    
    Specified by:
    
    setModTQ in interface JmolModulationSet
    
    Parameters:
    
    isOn -
    
    qtOffset -
    
    isQ -
    
    scale -
  - addTo
```
public void addTo(javajs.util.T3 a,
                  float scale)
```
    Specified by:
    
    addTo in interface JmolModulationSet
  - getState
```
public java.lang.String getState()
```
    Specified by:
    
    getState in interface JmolModulationSet
  - getModulation
```
public java.lang.Object getModulation(java.lang.String type,
                                      javajs.util.T3 t456)
```
    Specified by:
    
    getModulation in interface JmolModulationSet
  - setTempPoint
```
public void setTempPoint(javajs.util.T3 a,
                         javajs.util.T3 t456,
                         float vibScale,
                         float scale)
```
    Overrides:
    
    setTempPoint in class Vibration
  - getModTemp
```
private void getModTemp()
```
  - getInfo
```
public void getInfo(java.util.Map<java.lang.String,java.lang.Object> info)
```
    Overrides:
    
    getInfo in class Vibration

Class ModulationSet

Field Summary

Fields inherited from class org.jmol.util.Vibration

Fields inherited from class javajs.util.T3

Constructor Summary

Method Summary

Methods inherited from class javajs.util.V3

Methods inherited from class javajs.util.T3

Methods inherited from class java.lang.Object

Field Detail

vOcc

htUij

vOcc0

id

mods

modDim

iop

r0

symmetry

gammaE

gammaIinv

sigma

sI

tau

enabled

scale

qtOffset

isQ

t

modTemp

strop

isSubsystem

tFactor

ptTemp

Constructor Detail

ModulationSet

Method Detail

getScale

isEnabled

set

getUnitCell

calculate

addUTens

setModTQ

addTo

getState

getModulation

setTempPoint

getModTemp

getInfo