public static double Corr(Vector bfactor1, Vector bfactor2, bool ignore_nan = false)
{
double hcorr = HMath.HCorr(bfactor1, bfactor2, ignore_nan);
if (HDebug.IsDebuggerAttached)
{
double corr = double.NaN;
using (new Matlab.NamedLock("CORR"))
{
Matlab.Clear("CORR");
Matlab.PutVector("CORR.bfactor1", bfactor1);
Matlab.PutVector("CORR.bfactor2", bfactor2);
if (ignore_nan)
{
Matlab.Execute("CORR.idxnan = isnan(CORR.bfactor1) | isnan(CORR.bfactor2);");
Matlab.Execute("CORR.bfactor1 = CORR.bfactor1(~CORR.idxnan);");
Matlab.Execute("CORR.bfactor2 = CORR.bfactor2(~CORR.idxnan);");
}
if (Matlab.GetValueInt("min(size(CORR.bfactor1))") != 0)
{
corr = Matlab.GetValue("corr(CORR.bfactor1, CORR.bfactor2)");
}
Matlab.Clear("CORR");
}
if ((double.IsNaN(hcorr) && double.IsNaN(corr)) == false)
{
HDebug.AssertTolerance(0.00000001, hcorr - corr);
}
//HDebug.ToDo("use HMath.HCorr(...) instead");
}
return(hcorr);
}
/// <summary>
/// Performs Spectral Peak Tracking on a recording
/// Returns a matrix derived from the sonogram
/// </summary>
/// <param name="sonogram">the sonogram</param>
/// <param name="intensityThreshold">Intensity threshold in decibels above backgorund</param>
/// <param name="smallLengthThreshold">remove event swhose length is less than this threshold</param>
/// <returns></returns>
public static Tuple <double[, ]> doSPT(BaseSonogram sonogram, double intensityThreshold, int smallLengthThreshold)
{
// Sonograms in Matlab (which F# AED was modelled on) are orientated the opposite way
var m = MatrixModule.transpose(MatrixModule.ofArray2D(sonogram.Data));
//Log.WriteLine("Wiener filter start");
var w = Matlab.wiener2(7, m);
//Log.WriteLine("Wiener filter end");
//Log.WriteLine("Remove subband mode intensities start");
var s = AcousticEventDetection.removeSubbandModeIntensities(w);
//Log.WriteLine("Remove subband mode intensities end");
Log.WriteLine("SPT start");
int nh = 3;
var p = SpectralPeakTrack.spt(s, intensityThreshold, nh, smallLengthThreshold);
Log.WriteLine("SPT finished");
var r = MatrixModule.toArray2D(MatrixModule.transpose(p));
return(Tuple.Create(r));
}
static public void MV(HessMatrixSparse M, Vector V, Vector mv, Vector bvec, Vector bmv)
{
HDebug.Exception(V.Size == M.RowSize);
HDebug.Exception(mv.Size == M.ColSize); //Vector mv = new double[M.ColSize];
HDebug.Exception(bvec.Size == 3); //Vector bvec = new double[3];
HDebug.Exception(bmv.Size == 3); //Vector bmv = new double[3];
foreach (ValueTuple <int, int, MatrixByArr> bc_br_bval in M.EnumBlocks())
{
int bc = bc_br_bval.Item1;
int br = bc_br_bval.Item2;
var bmat = bc_br_bval.Item3;
bvec[0] = V[br * 3 + 0];
bvec[1] = V[br * 3 + 1];
bvec[2] = V[br * 3 + 2];
HTLib2.LinAlg.MV(bmat, bvec, bmv);
mv[bc * 3 + 0] += bmv[0];
mv[bc * 3 + 1] += bmv[1];
mv[bc * 3 + 2] += bmv[2];
}
if (HDebug.Selftest())
{
Matlab.Clear();
Matlab.PutSparseMatrix("M", M.GetMatrixSparse(), 3, 3);
Matlab.PutVector("V", V);
Matlab.Execute("MV = M*V;");
Matlab.PutVector("MV1", mv);
Vector err = Matlab.GetVector("MV-MV1");
double err_max = err.ToArray().HAbs().Max();
HDebug.Assert(err_max < 0.00000001);
}
}
private double[] CalcWeist(List <CircleImage> img, List <double> distance)
{
double[] result = new double[img[0].Circles.Count];
for (int circleId = 0; circleId < result.Length; circleId++)
{
try
{
double[] radius = new double[img.Count];
for (int imgId = 0; imgId < radius.Length; imgId++)
{
radius[imgId] = img[imgId].Circles[circleId].Radius * 5.5;
}
string output = "";
for (int i = 0; i < radius.Length; i++)
{
output += radius[i].ToString("F2") + ",";
}
if (output.Length > 0)
{
output = output.Substring(0, output.Length - 1);
}
_log.Debug($"Circle{circleId} radius: {output}");
result[circleId] = Matlab.CalcWeist2(radius, distance.ToArray());
}
catch (Exception ex)
{
result[circleId] = double.NaN;
_log.Error($"Failed to calcute weist for {circleId}", ex);
}
}
return(result.ToList().Select(x => x / 10).ToArray());
}
public static CTesthess Testhess
(string testhesspath
, Tinker.Xyz xyz
, Tinker.Prm prm
, string tempbase //=null
, string[] keys
, Dictionary <string, string[]> optOutSource // =null
, Func <int, int, HessMatrix> HessMatrixZeros // =null
)
{
var tmpdir = HDirectory.CreateTempDirectory(tempbase);
string currpath = HEnvironment.CurrentDirectory;
CTesthess testhess;
{
HEnvironment.CurrentDirectory = tmpdir.FullName;
if (testhesspath == null)
{
string resbase = "HTLib2.Bioinfo.HTLib2.Bioinfo.External.Tinker.Resources.tinker_6_2_01.";
HResource.CopyResourceTo <Tinker>(resbase + "testhess.exe", "testhess.exe");
testhesspath = "testhess.exe";
}
xyz.ToFile("test.xyz", false);
prm.ToFile("test.prm");
string keypath = null;
if ((keys != null) && (keys.Length > 0))
{
keypath = "test.key";
HFile.WriteAllLines(keypath, keys);
}
testhess = Testhess(testhesspath, "test.xyz", "test.prm", keypath, optOutSource, HessMatrixZeros);
testhess.xyz = xyz;
testhess.prm = prm;
}
HEnvironment.CurrentDirectory = currpath;
try{ tmpdir.Delete(true); } catch {}
string test_eig = "true";
if (test_eig == "false")
{
Vector D;
using (new Matlab.NamedLock(""))
{
Matlab.PutSparseMatrix("testeig.H", testhess.hess.GetMatrixSparse(), 3, 3);
Matlab.Execute("testeig.H = (testeig.H + testeig.H')/2;");
Matlab.Execute("[testeig.V, testeig.D] = eig(full(testeig.H));");
Matlab.Execute("testeig.D = diag(testeig.D);");
D = Matlab.GetVector("testeig.D");
Matlab.Execute("clear testeig;");
}
}
return(testhess);
}
public static void Compute(Matrix x, Vector y, int wind,
out double[] minSQ,
out double[] TQ,
out int[] Indices,
VectorType vtype = VectorType.Column)
{
if (x == null || y == null)
{
throw new ArgumentException("");
}
int row = x.RowCount;
int col = x.ColumnCount;
int scount = vtype == VectorType.Row ? row : col;
int valCount = vtype == VectorType.Row ? col : row;
if (valCount != y.Count)
{
throw new ArgumentException("x,y的长度不一致");
}
var SQm = new DenseMatrix(row, col);
var TQm = new DenseVector(scount);
for (int k = 0; k < scount; k++)
{
Vector tSQ;
double tTQ;
Vector x1;
x1 = (Vector)(vtype == VectorType.Row ? x.Row(k) : x.Column(k));
Compute(x1, y, wind, out tSQ, out tTQ);
if (vtype == VectorType.Row)
{
SQm.SetRow(k, tSQ);
}
else
{
SQm.SetColumn(k, tSQ);
}
TQm[k] = tTQ;
}
TQ = Matlab.SortDesc(TQm, out Indices).ToArray();
double[] mSQ;
int[] mSQidx;
Matlab.Min(SQm, out mSQ, out mSQidx, vtype);
minSQ = new double[scount];
for (int i = 0; i < scount; i++)
{
minSQ[i] = mSQ[Indices[i]];
}
}
private void 二值化ToolStripMenuItem1_Click(object sender, EventArgs e)
{
if (getCurrentImage())
{
var bm = new Bitmap(curBitmap);
var t = Matlab.GetThreshold(bm);
bm = Matlab.Thresh(bm, iw, ih, t);
pictureBox.Refresh();
pictureBox.Image = bm;
}
}
public static void Init(int[] volSize, int[] volRes, float hbar, float dt) // vol_size::NTuple{ 3}, vol_res::NTuple{3}, hbar, dt)
{
properties = new SpaceProperties(volSize, volRes, hbar, dt);
ISFKernels.Init(properties);
psi1 = new CudaDeviceVariable <cuFloatComplex>(properties.num);
psi2 = new CudaDeviceVariable <cuFloatComplex>(properties.num);
FFT.init(properties.resx, properties.resy, properties.resz);
_ix = Enumerable.Range(0, properties.resx).ToArray();
_iy = Enumerable.Range(0, properties.resy).ToArray();
_iz = Enumerable.Range(0, properties.resz).ToArray();
var ii = Matlab.ndgrid(_ix, _iy, _iz);
_iix = ii.x;
_iiy = ii.y;
_iiz = ii.z;
properties.px = new float[_iix.GetLength(0), _iix.GetLength(1), _iix.GetLength(2)];
properties.py = new float[_iiy.GetLength(0), _iiy.GetLength(1), _iiy.GetLength(2)];
properties.pz = new float[_iiz.GetLength(0), _iiz.GetLength(1), _iiz.GetLength(2)];
for (int i = 0; i < properties.resx; i++)
{
for (int j = 0; j < properties.resy; j++)
{
for (int k = 0; k < properties.resz; k++)
{
properties.px[i, j, k] = (_iix[i, j, k]) * properties.dx;
properties.py[i, j, k] = (_iiy[i, j, k]) * properties.dy;
properties.pz[i, j, k] = (_iiz[i, j, k]) * properties.dz;
}
}
}
_sx = _iix.Select3D((e, i, j, k) => (float)Math.Sin((float)Math.PI * e / properties.resx) / properties.dx);
_sy = _iiy.Select3D((e, i, j, k) => (float)Math.Sin((float)Math.PI * e / properties.resy) / properties.dy);
_sz = _iiz.Select3D((e, i, j, k) => (float)Math.Sin((float)Math.PI * e / properties.resz) / properties.dz);
cuFloatComplex[,,] tmpFac = _iix.Select3D((e, i, j, k) =>
{
return(new cuFloatComplex((float)(-0.25 / (Math.Pow(_sx[i, j, k], 2) + Math.Pow(_sy[i, j, k], 2) + Math.Pow(_sz[i, j, k], 2))), 0));
});
tmpFac[0, 0, 0] = new cuFloatComplex(0, 0);
_fac = new CudaDeviceVariable <cuFloatComplex>(properties.num);
_fac.CopyToDevice(tmpFac);
var tmpMask = new cuFloatComplex[properties.resx, properties.resy, properties.resz];
build_schroedinger(tmpMask);
_mask = new CudaDeviceVariable <cuFloatComplex>(properties.num);
_mask.CopyToDevice(tmpMask);
}
public static Mode[] GetModesFromHess(Matrix hess, ILinAlg la)
{
List <Mode> modes;
{
Matrix V;
Vector D;
switch (la)
{
case null:
using (new Matlab.NamedLock(""))
{
Matlab.PutMatrix("H", hess, true);
Matlab.Execute("H = (H + H')/2;");
Matlab.Execute("[V,D] = eig(H);");
Matlab.Execute("D = diag(D);");
V = Matlab.GetMatrix("V", true);
D = Matlab.GetVector("D", true);
}
break;
default:
{
var H = la.ToILMat(hess);
H = (H + H.Tr) / 2;
var VD = la.EigSymm(H);
V = VD.Item1.ToMatrix();
D = VD.Item2;
H.Dispose();
VD.Item1.Dispose();
}
break;
}
int[] idxs = D.ToArray().HAbs().HIdxSorted();
modes = new List <Mode>(idxs.Length);
//foreach(int idx in idxs)
for (int th = 0; th < idxs.Length; th++)
{
int idx = idxs[th];
Mode mode = new Mode
{
th = (th + 1),
eigval = D[idx],
eigvec = V.GetColVector(idx)
};
modes.Add(mode);
}
}
System.GC.Collect();
return(modes.ToArray());
}
/// Score = nwalign(Seq1,Seq2)
/// [Score, Alignment] = nwalign(Seq1,Seq2)
/// [Score, Alignment, Start] = nwalign(Seq1,Seq2)
///
/// Example:
/// [Score, Alignment, Start] = nwalign('VSPAGMASGYD','IPGKASYD')
///
/// Score = 7.3333
/// Alignment = 3x11 char
/// ['VSPAGMASGYD']
/// [': | | || ||']
/// ['I-P-GKAS-YD']
/// Start = 2x1 double
/// [1]
/// [1]
public static NwalignInfo Nwalign(string Seq1, string Seq2)
{
Seq1 = Seq1.Trim();
Seq2 = Seq2.Trim();
double Score = Matlab.GetValue(string.Format("nwalign('{0}', '{1}')", Seq1, Seq2));
return(new NwalignInfo
{
Seq1 = Seq1,
Seq2 = Seq2,
Score = Score
});
}
public string ToScript()
{
var builder = new StringBuilder();
builder.AppendLine(Matlab.CommentLine("Setting controller " + Name + " parameters."));
builder.AppendLine(UIModel.SetParameterCommand(this, ControllerProperties.Attack, Attack.ToStringValue()));
builder.AppendLine(UIModel.SetParameterCommand(this, ControllerProperties.AttackMode, Mode.ToStringValue()));
builder.AppendLine(UIModel.SetParameterCommand(this, ControllerProperties.IntegrityAtackValue, IntegrityAttackValue.ToString(new NumberFormatInfo {
NumberDecimalSeparator = "."
})));
builder.AppendLine(UIModel.SetParameterCommand(this, ControllerProperties.Start, Start));
builder.AppendLine(UIModel.SetParameterCommand(this, ControllerProperties.Duration, Duration));
return(builder.ToString());
}
public static double[] GetRotAngles(Universe univ
, Vector[] coords
, Vector[] dcoords
, MatrixByArr J = null
, Graph <Universe.Atom[], Universe.Bond> univ_flexgraph = null
, List <Universe.RotableInfo> univ_rotinfos = null
, Vector[] dcoordsRotated = null
)
{
if (J == null)
{
if (univ_rotinfos == null)
{
if (univ_flexgraph == null)
{
univ_flexgraph = univ.BuildFlexibilityGraph();
}
univ_rotinfos = univ.GetRotableInfo(univ_flexgraph);
}
J = TNM.GetJ(univ, coords, univ_rotinfos);
}
double[] dangles;
using (new Matlab.NamedLock("TEST"))
{
Matlab.Clear("TEST");
Matlab.PutVector("TEST.R", Vector.FromBlockvector(dcoords));
Matlab.PutMatrix("TEST.J", J.ToArray(), true);
Matlab.PutVector("TEST.M", univ.GetMasses(3));
Matlab.Execute("TEST.M = diag(TEST.M);");
Matlab.Execute("TEST.invJMJ = inv(TEST.J' * TEST.M * TEST.J);");
Matlab.Execute("TEST.A = TEST.invJMJ * TEST.J' * TEST.M * TEST.R;"); // (6) of TNM paper
dangles = Matlab.GetVector("TEST.A");
if (dcoordsRotated != null)
{
HDebug.Assert(dcoordsRotated.Length == dcoords.Length);
Matlab.Execute("TEST.dR = TEST.J * TEST.A;");
Vector ldcoordsRotated = Matlab.GetVector("TEST.dR");
HDebug.Assert(ldcoordsRotated.Size == dcoordsRotated.Length * 3);
for (int i = 0; i < dcoordsRotated.Length; i++)
{
int i3 = i * 3;
dcoordsRotated[i] = new double[] { ldcoordsRotated[i3 + 0], ldcoordsRotated[i3 + 1], ldcoordsRotated[i3 + 2] };
}
}
Matlab.Clear("TEST");
}
return(dangles);
}
string IMatlabScript.ToScript()
{
var builder = new StringBuilder();
builder.AppendLine(Matlab.BlockLine("Setting " +
typeof(T).Name.Substring(0, typeof(T).Name
.IndexOf("Controller", System.StringComparison.Ordinal)).ToLower()) +
" controllers parameters");
builder.AppendLine();
foreach (var controller in this)
{
builder.AppendLine(((IMatlabScript)controller).ToScript());
}
return(builder.ToString());
}
public static double[] GetBFactor(Mode[] modes, double[] mass = null)
{
if (HDebug.Selftest())
#region selftest
{
using (new Matlab.NamedLock("SELFTEST"))
{
Matlab.Clear("SELFTEST");
Matlab.Execute("SELFTEST.hess = rand(30);");
Matlab.Execute("SELFTEST.hess = SELFTEST.hess + SELFTEST.hess';");
Matlab.Execute("SELFTEST.invhess = inv(SELFTEST.hess);");
Matlab.Execute("SELFTEST.bfactor3 = diag(SELFTEST.invhess);");
Matlab.Execute("SELFTEST.bfactor = SELFTEST.bfactor3(1:3:end) + SELFTEST.bfactor3(2:3:end) + SELFTEST.bfactor3(3:3:end);");
MatrixByArr selftest_hess = Matlab.GetMatrix("SELFTEST.hess");
Mode[] selftest_mode = Hess.GetModesFromHess(selftest_hess);
Vector selftest_bfactor = BFactor.GetBFactor(selftest_mode);
Vector selftest_check = Matlab.GetVector("SELFTEST.bfactor");
Vector selftest_diff = selftest_bfactor - selftest_check;
HDebug.AssertTolerance(0.00000001, selftest_diff);
Matlab.Clear("SELFTEST");
}
}
#endregion
int size = modes[0].size;
if (mass != null)
{
HDebug.Assert(size == mass.Length);
}
double[] bfactor = new double[size];
for (int i = 0; i < size; i++)
{
foreach (Mode mode in modes)
{
bfactor[i] += mode.eigvec[i * 3 + 0] * mode.eigvec[i * 3 + 0] / mode.eigval;
bfactor[i] += mode.eigvec[i * 3 + 1] * mode.eigvec[i * 3 + 1] / mode.eigval;
bfactor[i] += mode.eigvec[i * 3 + 2] * mode.eigvec[i * 3 + 2] / mode.eigval;
}
if (mass != null)
{
bfactor[i] /= mass[i];
}
}
return(bfactor);
}
public static Matrix GetCorrMatrixMatlab(this IList <Mode> modes)
{
if (HDebug.Selftest())
{
HDebug.Assert(GetCorrMatrix_SelfTest(modes, GetCorrMatrixMatlab));
}
// Dii = zeros(n, 1);
// For[i=1, i<=nmodes, i++,
// Dii = Dii + Table[Dot[vec,vec],{vec,modei}]/eigvi;
// ];
// Dij = zeros(n, n);
// For[i=1, i<=nmodes, i++,
// Dijx = Dijx + modei_x.Transpose[modei_x] / eigvi;
// Dijy = Dijy + modei_y.Transpose[modei_y] / eigvi;
// Dijz = Dijz + modei_z.Transpose[modei_z] / eigvi;
// Dii = Dii + Table[Dot[vec,vec],{vec,modei}]/eigvi;
// ];
// Dij = Dij / nmodes;
// Dii = Dii / nmodes;
// Cij = Dij / Sqrt[Transpose[{Dii}].{Dii}];
// corr = Cij;
Matrix MD = modes.ListEigvec().ToMatrix();
Vector EV = modes.ListEigval().ToArray();
Matrix corrmat;
using (new Matlab.NamedLock(""))
{
Matlab.Clear();
Matlab.PutMatrix("MD", MD, true);
Matlab.PutVector("EV", EV);
Matlab.Execute("nmodes = length(EV);");
Matlab.Execute("iEV = diag(1 ./ EV);");
Matlab.Execute("Dijx = MD(1:3:end,:); Dijx = Dijx*iEV*Dijx'; Dij= Dijx; clear Dijx;");
Matlab.Execute("Dijy = MD(2:3:end,:); Dijy = Dijy*iEV*Dijy'; Dij=Dij+Dijy; clear Dijy;");
Matlab.Execute("Dijz = MD(3:3:end,:); Dijz = Dijz*iEV*Dijz'; Dij=Dij+Dijz; clear Dijz;");
Matlab.Execute("clear MD; clear EV; clear iEV;");
Matlab.Execute("Dij = Dij / nmodes;");
Matlab.Execute("Dii = diag(Dij);");
Matlab.Execute("Dij = Dij ./ sqrt(Dii*Dii');");
corrmat = Matlab.GetMatrix("Dij", true);
}
return(corrmat);
}
/// <summary>
/// private constuctor of a singleton
/// </summary>
private MeshParameterization()
{
this.SelectedMethod = Method.Barycentric;
this.AngleToAreaRatio = 1f;
this.P1Index = 153;
this.P2Index = 19;
this.P1UV = new Vector2(0.5f, 0);
this.P2UV = new Vector2(0.5f, 1);
#if MATLAB
/// initalizes a MALAB session connected to this C# program
/// if you want to see it in your MATLAB window,
/// (1) first, start MABLAB *before* starting this program
/// (2) call in MATLAB: enableservice('AutomationServer',true); (two times?)
/// (3) start this program, then you can push matrices to MATLAB, see examples below
Matlab.InitMATLAB(true);
#endif
}
public Mode[] GetAllModes()
{
if (_allmodes == null)
{
Mode[] rtbmodes = GetRtbModes();
Matrix M = rtbmodes.ListEigvecAsMatrix();
if (HDebug.IsDebuggerAttached)
#region check if each colume of M is same to its corresponding eigvector
{
for (int r = 0; r < M.RowSize; r++)
{
Vector colvec_r = M.GetColVector(r);
double err = (colvec_r - rtbmodes[r].eigvec).ToArray().HAbs().Max();
HDebug.Assert(err == 0);
}
}
#endregion
Matrix PM = null;
using (new Matlab.NamedLock(""))
{
Matlab.PutMatrix("P", P, true);
Matlab.PutMatrix("M", M, true);
PM = Matlab.GetMatrix("P*M", true);
}
_allmodes = new Mode[rtbmodes.Length];
for (int i = 0; i < rtbmodes.Length; i++)
{
_allmodes[i] = new Mode
{
th = rtbmodes[i].th,
eigval = rtbmodes[i].eigval,
eigvec = PM.GetColVector(i),
};
// mass-weighted, mass-reduced is already handled in GetRtbModes() using "PMP" and "PMPih".
// HDebug.ToDo("check if each mode should be devided by masses (or not)");
// //for(int j=0; j<_allmodes[i].eigvec.Size; j++)
// // _allmodes[i].eigvec[j] = _allmodes[i].eigvec[j] / masses[j/3];
}
}
return(_allmodes);
}
public static double SimFluc(IList <Mode> modes1, IList <Mode> modes2)
{
/// need to confirm again...
///
Matrix M1 = modes1.ToModeMatrix();
Vector V1 = modes1.ToArray().ListEigval();
Matrix M2 = modes2.ToModeMatrix();
Vector V2 = modes2.ToArray().ListEigval();
using (new Matlab.NamedLock("SimFluc"))
{
Matlab.Execute("");
Matlab.Execute("clear");
Matlab.PutMatrix("MM1", M1); Matlab.PutVector("VV1", V1);
Matlab.PutMatrix("MM2", M2); Matlab.PutVector("VV2", V2);
Matlab.Execute("[U2,S2,V2] = svd(MM2);");
Matlab.Execute("U2 = U2(:, 1:length(VV2));");
Matlab.Execute("S2 = S2(1:length(VV2), :);");
Matlab.Execute("invSV2 = diag(1./diag(S2))*V2';");
// covariance of mode2
Matlab.Execute("C2 = invSV2*diag(1./VV2)*invSV2';");
Matlab.Execute("C2 = (C2 + C2')/2;");
// covariance of mode 1 projected onto U2
Matlab.Execute("C1 = U2'*(MM1*diag(VV1)*MM1')*U2;");
Matlab.Execute("C1 = pinv((C1 + C1')/2);");
Matlab.Execute("C1 = (C1 + C1')/2;");
// compute the fluctuation similarity
Matlab.Execute("detInvC1 = det(inv(C1));");
Matlab.Execute("detInvC2 = det(inv(C2));");
Matlab.Execute("detInvC1InvC2 = det((inv(C1)+inv(C2))/2);");
Matlab.Execute("simfluc0 = ((detInvC1*detInvC2)^0.25);");
Matlab.Execute("simfluc1 = (detInvC1InvC2)^0.5;");
Matlab.Execute("simfluc = simfluc0 / simfluc1;");
double simfluc = Matlab.GetValue("simfluc");
Matlab.Execute("clear");
return(simfluc);
}
}
protected override Vector Process(Vector v, DenseVector xMean = null, DenseVector xScale = null)
{
var idx = new DenseVector(this.M);
for (int i = 0; i < this.M; i++)
{
idx[i] = i - (this.M - 1) / 2;
}
var s = Matlab.Flip(Matlab.Vander(idx));
var S = s.SubMatrix(0, s.RowCount, 0, this.K + 1);
var D1 = S.Transpose() * S;
var D2 = D1.Inverse();
var D = D2 * S.Transpose();
var mm = (this.M + 1) / 2;
var mmm = (this.M - 1) / 2;
var pp = 1;
for (int i = 1; i < this.P + 1; i++)
{
pp = pp * i;
}
var d = new DenseVector(v.Count);
for (int i = mm; i < v.Count - mmm + 1; i++)
{
var xx = v.SubVector(i - mmm - 1, 2 * mmm + 1);
var A = D * xx;
d[i - 1] = A[this.P] * pp;
}
return(d);
}
public static Anisou[] FromHessian(MatrixByArr hessMassWeighted, double[] mass, double scale = 10000 *1000
, string cachepath = null
)
{
/// Estimation of "anisotropic temperature factors" (ANISOU)
///
/// delta = hess^-1 * force
/// = (0 + V7*V7'/L7 + V8*V8'/L8 + V9*V9'/L9 + ...) * force (* assume that 1-6 eigvecs/eigvals are ignored, because rot,trans *)
///
/// Assume that force[i] follows gaussian distributions N(0,1). Here, if there are 1000 samples, let denote i-th force as fi, and its j-th element as fi[j]
/// Then, $V7' * fi = si7, V8' * fi = si8, ...$ follows gaussian distribution N(0,1), too.
/// Its moved position by k-th eigen component is determined then, as
/// dik = (Vk * Vk' / Lk) * Fi
/// = Vk / Lk * (Vk' * Fi)
/// = Vk / Lk * Sik.
/// Additionally, the moved position j-th atom is:
/// dik[j] = Vk[j] / Lk[j] * Sik.
/// and its correlation matrix is written as (because its mean position is 0 !!!):
/// Cik[j] = dik[j] * dik[j]'
/// = [dik[j]_x * dik[j]_x dik[j]_x * dik[j]_y dik[j]_x * dik[j]_z]
/// [dik[j]_y * dik[j]_x dik[j]_y * dik[j]_y dik[j]_y * dik[j]_z]
/// [dik[j]_z * dik[j]_x dik[j]_z * dik[j]_y dik[j]_z * dik[j]_z]
/// = (Vk[j] * Vk[j]') / (Lk[j]*Lk[j]) * (Sik*Sik).
///
/// Note that Sik*Sik follows the chi-square distribution, because Sik follows the gaussian distribution N(0,1).
/// Additionally, note that the thermal fluctuation is (not one projection toward k-th eigen component with only i-th force, but) the results of 1..i.. forced movements and 1..k.. eigen components.
/// Therefore, for j-th atom, the accumulation of the correlation over all forces (1..i..) with all eigen components (1..k..) is:
/// C[j] = sum_{i,k} {(Vk[j] * Vk[j]') / (Lk[j]*Lk[j]) * (Sik*Sik)}.
///
/// Here, Sik is normal distribution independent to i and k. Therefore, the mean of C[j] is
/// E(C[j]) = E( sum_{i,k} {(Vk[j] * Vk[j]') / (Lk[j]*Lk[j]) * (Sik*Sik)} )
/// = sum_{i,k} E( (Vk[j] * Vk[j]') / (Lk[j]*Lk[j]) * (Sik*Sik) )
/// = sum_{i,k} { (Vk[j] * Vk[j]') / (Lk[j]*Lk[j]) * E(Sik*Sik) }
/// = sum_{i,k} { (Vk[j] * Vk[j]') / (Lk[j]*Lk[j]) * 1 } (* because mean of E(x*x)=1 where x~N(0,1) *)
/// = sum_{k} { (Vk[j] * Vk[j]') / (Lk[j]*Lk[j]) }
///
/// Note that E(C[j]) is same to the j-th diagonal component of inverse hessian matrix (except, the eigenvalues are squared).
///
/// Fixation: Gromacx generate the ensemble X by
/// X[j] = sum_{k} {Vk / sqrt(Lk[j]) / sqrt(mass[j]) * x_k},
/// where x~N(0,1). However, the above is assumed as
/// X[j] = sum_{k} {Vk / Lk[j] * x_k}.
/// In order to apply the assumption by the Gromacs ensemble, The equation should be fixed as
/// E(C[j]) = sum_{k} { (Vk[j] * Vk[j]') / (sqrt(Lk[j])*sqrt(Lk[j])) }
/// = sum_{k} { (Vk[j] * Vk[j]') / Lk[j] / mass[j] }
///
int size = mass.Length;
HDebug.Assert(hessMassWeighted.RowSize == size * 3, hessMassWeighted.ColSize == size * 3);
Anisou[] anisous = new Anisou[size];
if (cachepath != null && HFile.Exists(cachepath))
{
List <Anisou> lstanisou;
HDebug.Verify(HSerialize.Deserialize <List <Anisou> >(cachepath, null, out lstanisou));
anisous = lstanisou.ToArray();
return(anisous);
}
// anisotropic temperature factors
using (new Matlab.NamedLock("ANISOU"))
{
Matlab.Clear("ANISOU");
Matlab.PutMatrix("ANISOU.H", hessMassWeighted);
Matlab.Execute("[ANISOU.V,ANISOU.D] = eig(ANISOU.H);");
Matlab.Execute("ANISOU.D = diag(ANISOU.D);"); // get diagonal
{
Matlab.Execute("[ANISOU.sortD, ANISOU.sortIdxD] = sort(abs(ANISOU.D));"); // sorted index of abs(D)
Matlab.Execute("ANISOU.D(ANISOU.sortIdxD(1:6)) = 0;"); // set the 6 smallest eigenvalues as zero
//Matlab.Execute("ANISOU.D(ANISOU.D < 0) = 0;"); // set negative eigenvalues as zero
}
//{
// Matlab.Execute("ANISOU.D(1:6) = 0;");
//}
Matlab.Execute("ANISOU.invD = 1 ./ ANISOU.D;"); // set invD
Matlab.Execute("ANISOU.invD(ANISOU.D == 0) = 0;"); // set Inf (by divided by zero) as zero
//Matlab.Execute("ANISOU.D = ANISOU.D .^ 2;"); // assume the gromacs ensemble condition
Matlab.Execute("ANISOU.invH = ANISOU.V * diag(ANISOU.invD) * ANISOU.V';");
for (int i = 0; i < size; i++)
{
string idx = string.Format("{0}:{1}", i * 3 + 1, i * 3 + 3);
MatrixByArr U = Matlab.GetMatrix("ANISOU.invH(" + idx + "," + idx + ")");
U *= (scale / mass[i]);
anisous[i] = Anisou.FromMatrix(U);
}
Matlab.Clear("ANISOU");
}
if (cachepath != null)
{
HSerialize.Serialize(cachepath, null, new List <Anisou>(anisous));
}
return(anisous);
}
public static ValueTuple <HessMatrix, Vector> Get_BInvDC_BInvDG_Simple
(HessMatrix CC
, HessMatrix DD
, Vector GG
, bool process_disp_console
, double?thld_BinvDC = null
, bool parallel = false
)
{
HessMatrix BB_invDD_CC;
Vector BB_invDD_GG;
using (new Matlab.NamedLock(""))
{
Matlab.Execute("clear;"); if (process_disp_console)
{
System.Console.Write("matlab(");
}
Matlab.PutMatrix("C", CC); if (process_disp_console)
{
System.Console.Write("C"); //Matlab.PutSparseMatrix("C", C.GetMatrixSparse(), 3, 3);
}
Matlab.PutMatrix("D", DD); if (process_disp_console)
{
System.Console.Write("D");
}
Matlab.PutVector("G", GG); if (process_disp_console)
{
System.Console.Write("G");
}
// Matlab.Execute("BinvDC = C' * inv(D) * C;");
{
Matlab.Execute("BinvDC = C' * inv(D);");
Matlab.Execute("BinvD_G = BinvDC * G;");
Matlab.Execute("BinvDC = BinvDC * C;");
}
BB_invDD_GG = Matlab.GetVector("BinvD_G");
//Matrix BBinvDDCC = Matlab.GetMatrix("BinvDC", true);
if (thld_BinvDC != null)
{
Matlab.Execute("BinvDC(find(abs(BinvDC) < " + thld_BinvDC.ToString() + ")) = 0;");
}
Func <int, int, HessMatrix> Zeros = delegate(int colsize, int rowsize)
{
return(HessMatrixDense.ZerosDense(colsize, rowsize));
};
BB_invDD_CC = Matlab.GetMatrix("BinvDC", Zeros, true);
if (process_disp_console)
{
System.Console.Write("Y), ");
}
Matlab.Execute("clear;");
}
//GC.Collect(0);
return(new ValueTuple <HessMatrix, Vector>
(BB_invDD_CC
, BB_invDD_GG
));
}
private static HessMatrix GetHessCoarseResiIterImpl_Matlab_IterLowerTri_Get_BInvDC
(HessMatrix A
, HessMatrix C
, HessMatrix D
, bool process_disp_console
, string[] options
, double?thld_BinvDC = null
, bool parallel = false
)
{
if (options == null)
{
options = new string[0];
}
HessMatrix B_invD_C;
Dictionary <int, int> Cbr_CCbr = new Dictionary <int, int>();
List <int> CCbr_Cbr = new List <int>();
foreach (ValueTuple <int, int, MatrixByArr> bc_br_bval in C.EnumBlocks())
{
int Cbr = bc_br_bval.Item2;
if (Cbr_CCbr.ContainsKey(Cbr) == false)
{
HDebug.Assert(Cbr_CCbr.Count == CCbr_Cbr.Count);
int CCbr = Cbr_CCbr.Count;
Cbr_CCbr.Add(Cbr, CCbr);
CCbr_Cbr.Add(Cbr);
HDebug.Assert(CCbr_Cbr[CCbr] == Cbr);
}
}
HessMatrix CC = C.Zeros(C.ColSize, Cbr_CCbr.Count * 3);
{
Action <ValueTuple <int, int, MatrixByArr> > func = delegate(ValueTuple <int, int, MatrixByArr> bc_br_bval)
{
int Cbc = bc_br_bval.Item1; int CCbc = Cbc;
int Cbr = bc_br_bval.Item2; int CCbr = Cbr_CCbr[Cbr];
var bval = bc_br_bval.Item3;
lock (CC)
CC.SetBlock(CCbc, CCbr, bval);
};
if (parallel)
{
Parallel.ForEach(C.EnumBlocks(), func);
}
else
{
foreach (var bc_br_bval in C.EnumBlocks())
{
func(bc_br_bval);
}
}
}
if (process_disp_console)
{
System.Console.Write("squeezeC({0,6}->{1,6} blk), ", C.RowBlockSize, CC.RowBlockSize);
}
{
/// If a diagonal element of D is null, that row and column should be empty.
/// This assume that the atom is removed. In this case, the removed diagonal block
/// is replace as the 3x3 identity matrix.
///
/// [B1 0] [ A 0 ]^-1 [C1 C2 C3] = [B1 0] [ A^-1 0 ] [C1 C2 C3]
/// [B2 0] [ 0 I ] [ 0 0 0] [B2 0] [ 0 I^-1 ] [ 0 0 0]
/// [B3 0] [B3 0]
/// = [B1.invA 0] [C1 C2 C3]
/// [B2.invA 0] [ 0 0 0]
/// [B3.invA 0]
/// = [B1.invA.C1 B1.invA.C2 B1.invA.C3]
/// [B2.invA.C1 B2.invA.C2 B2.invA.C3]
/// [B3.invA.C1 B3.invA.C2 B3.invA.C3]
///
{
//HDebug.Exception(D.ColBlockSize == D.RowBlockSize);
for (int bi = 0; bi < D.ColBlockSize; bi++)
{
if (D.HasBlock(bi, bi) == true)
{
continue;
}
//for(int bc=0; bc< D.ColBlockSize; bc++) HDebug.Exception( D.HasBlock(bc, bi) == false);
//for(int br=0; br< D.RowBlockSize; br++) HDebug.Exception( D.HasBlock(bi, br) == false);
//for(int br=0; br<CC.RowBlockSize; br++) HDebug.Exception(CC.HasBlock(bi, br) == false);
D.SetBlock(bi, bi, new double[3, 3] {
{ 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
});
}
}
HessMatrix BB_invDD_CC;
using (new Matlab.NamedLock(""))
{
Matlab.Execute("clear;"); if (process_disp_console)
{
System.Console.Write("matlab(");
}
Matlab.PutMatrix("C", CC); if (process_disp_console)
{
System.Console.Write("C"); //Matlab.PutSparseMatrix("C", CC.GetMatrixSparse(), 3, 3);
}
Matlab.PutMatrix("D", D); if (process_disp_console)
{
System.Console.Write("D");
}
// Matlab.Execute("BinvDC = (C' / D) * C;");
{
if (options.Contains("pinv(D)"))
{
Matlab.Execute("BinvDC = C' * pinv(D) * C;");
}
if (options.Contains("/D -> pinv(D)"))
{
string msg = Matlab.Execute("BinvDC = (C' / D) * C;", true);
if (msg != "")
{
Matlab.Execute("BinvDC = C' * pinv(D) * C;");
}
}
else if (options.Contains("/D"))
{
Matlab.Execute("BinvDC = (C' / D) * C;");
}
else
{
Matlab.Execute("BinvDC = (C' / D) * C;");
}
}
if (process_disp_console)
{
System.Console.Write("X");
}
//Matrix BBinvDDCC = Matlab.GetMatrix("BinvDC", true);
if (thld_BinvDC != null)
{
Matlab.Execute("BinvDC(find(BinvDC < " + thld_BinvDC.ToString() + ")) = 0;");
}
if (Matlab.GetValue("nnz(BinvDC)/numel(BinvDC)") > 0.5 || HDebug.True)
{
Func <int, int, HessMatrix> Zeros = delegate(int colsize, int rowsize)
{
return(HessMatrixDense.ZerosDense(colsize, rowsize));
};
BB_invDD_CC = Matlab.GetMatrix("BinvDC", Zeros, true);
if (process_disp_console)
{
System.Console.Write("Y), ");
}
}
else
{
Matlab.Execute("[i,j,s] = find(sparse(BinvDC));");
TVector <int> listi = Matlab.GetVectorLargeInt("i", true);
TVector <int> listj = Matlab.GetVectorLargeInt("j", true);
TVector <double> lists = Matlab.GetVectorLarge("s", true);
int colsize = Matlab.GetValueInt("size(BinvDC,1)");
int rowsize = Matlab.GetValueInt("size(BinvDC,2)");
Dictionary <ValueTuple <int, int>, MatrixByArr> lst_bc_br_bval = new Dictionary <ValueTuple <int, int>, MatrixByArr>();
for (long i = 0; i < listi.SizeLong; i++)
{
int c = listi[i] - 1; int bc = c / 3; int ic = c % 3;
int r = listj[i] - 1; int br = r / 3; int ir = r % 3;
double v = lists[i];
ValueTuple <int, int> bc_br = new ValueTuple <int, int>(bc, br);
if (lst_bc_br_bval.ContainsKey(bc_br) == false)
{
lst_bc_br_bval.Add(bc_br, new double[3, 3]);
}
lst_bc_br_bval[bc_br][ic, ir] = v;
}
// Matrix BBinvDDCC = Matrix.Zeros(colsize, rowsize);
// for(int i=0; i<listi.Length; i++)
// BBinvDDCC[listi[i]-1, listj[i]-1] = lists[i];
// //GC.Collect(0);
BB_invDD_CC = D.Zeros(colsize, rowsize);
foreach (var bc_br_bval in lst_bc_br_bval)
{
int bc = bc_br_bval.Key.Item1;
int br = bc_br_bval.Key.Item2;
var bval = bc_br_bval.Value;
BB_invDD_CC.SetBlock(bc, br, bval);
}
if (process_disp_console)
{
System.Console.Write("Z), ");
}
if (HDebug.IsDebuggerAttached)
{
for (int i = 0; i < listi.Size; i++)
{
int c = listi[i] - 1;
int r = listj[i] - 1;
double v = lists[i];
HDebug.Assert(BB_invDD_CC[c, r] == v);
}
}
}
Matlab.Execute("clear;");
}
//GC.Collect(0);
B_invD_C = A.Zeros(C.RowSize, C.RowSize);
{
// for(int bcc=0; bcc<CCbr_Cbr.Count; bcc++)
// {
// int bc = CCbr_Cbr[bcc];
// for(int brr=0; brr<CCbr_Cbr.Count; brr++)
// {
// int br = CCbr_Cbr[brr];
// HDebug.Assert(B_invD_C.HasBlock(bc, br) == false);
// if(BB_invDD_CC.HasBlock(bcc, brr) == false)
// continue;
// var bval = BB_invDD_CC.GetBlock(bcc, brr);
// B_invD_C.SetBlock(bc, br, bval);
// HDebug.Exception(A.HasBlock(bc, bc));
// HDebug.Exception(A.HasBlock(br, br));
// }
// }
Action <ValueTuple <int, int, MatrixByArr> > func = delegate(ValueTuple <int, int, MatrixByArr> bcc_brr_bval)
{
int bcc = bcc_brr_bval.Item1;
int brr = bcc_brr_bval.Item2;
var bval = bcc_brr_bval.Item3;
int bc = CCbr_Cbr[bcc];
int br = CCbr_Cbr[brr];
//lock(B_invD_C)
B_invD_C.SetBlockLock(bc, br, bval);
};
if (parallel)
{
Parallel.ForEach(BB_invDD_CC.EnumBlocks(), func);
}
else
{
foreach (var bcc_brr_bval in BB_invDD_CC.EnumBlocks())
{
func(bcc_brr_bval);
}
}
}
}
GC.Collect(0);
return(B_invD_C);
}
public static double[] GetRotAngles(Universe univ
, Vector[] coords
, MatrixByArr hessian
, Vector[] forces
, MatrixByArr J = null
, Graph <Universe.Atom[], Universe.Bond> univ_flexgraph = null
, List <Universe.RotableInfo> univ_rotinfos = null
, Vector[] forceProjectedByTorsional = null
, HPack <Vector> optEigvalOfTorHessian = null
)
{
Vector mass = univ.GetMasses();
//Vector[] dcoords = new Vector[univ.size];
//double t2 = t*t;
//for(int i=0; i<univ.size; i++)
// dcoords[i] = forces[i] * (0.5*t2/mass[i]);
if (J == null)
{
if (univ_rotinfos == null)
{
if (univ_flexgraph == null)
{
univ_flexgraph = univ.BuildFlexibilityGraph();
}
univ_rotinfos = univ.GetRotableInfo(univ_flexgraph);
}
J = TNM.GetJ(univ, coords, univ_rotinfos);
}
double[] dangles;
using (new Matlab.NamedLock("TEST"))
{
Matlab.Clear("TEST");
Matlab.PutVector("TEST.F", Vector.FromBlockvector(forces));
Matlab.PutMatrix("TEST.J", J);
Matlab.PutMatrix("TEST.H", hessian);
Matlab.PutVector("TEST.M", univ.GetMasses(3));
Matlab.Execute("TEST.M = diag(TEST.M);");
Matlab.Execute("TEST.JHJ = TEST.J' * TEST.H * TEST.J;");
Matlab.Execute("TEST.JMJ = TEST.J' * TEST.M * TEST.J;");
// (J' H J) tor = J' F
// (V' D V) tor = J' F <= (V,D) are (eigvec,eigval) of generalized eigenvalue problem with (A = JHJ, B = JMJ)
// tor = inv(V' D V) J' F
Matlab.Execute("[TEST.V, TEST.D] = eig(TEST.JHJ, TEST.JMJ);");
if (optEigvalOfTorHessian != null)
{
optEigvalOfTorHessian.value = Matlab.GetVector("diag(TEST.D)");
}
{
Matlab.Execute("TEST.D = diag(TEST.D);");
Matlab.Execute("TEST.D(abs(TEST.D)<1) = 0;"); // remove "eigenvalue < 1" because they will increase
// the magnitude of force term too big !!!
Matlab.Execute("TEST.D = diag(TEST.D);");
}
Matlab.Execute("TEST.invJHJ = TEST.V * pinv(TEST.D) * TEST.V';");
Matlab.Execute("TEST.dtor = TEST.invJHJ * TEST.J' * TEST.F;");
/// f = m a
/// d = 1/2 a t^2
/// = 0.5 a : assuming t=1
/// = 0.5 f/m
/// f = m a
/// = 2 m d t^-2
/// = 2 m d : assuming t=1
///
/// coord change
/// dr = 0.5 a t^2
/// = 0.5 f/m : assuming t=1
/// = 0.5 M^-1 F : M is mass matrix, F is the net force of each atom
///
/// torsional angle change
/// dtor = (J' M J)^-1 J' M * dr : (6) of TNM paper
/// = (J' M J)^-1 J' M * 0.5 M^-1 F
/// = 0.5 (J' M J)^-1 J' F
///
/// force filtered by torsional ...
/// F_tor = ma
/// = 2 M (J dtor)
/// = 2 M J 0.5 (J' M J)^-1 J' F
/// = M J (J' M J)^-1 J' F
///
/// H J dtor = F
/// = F_tor : update force as the torsional filtered force
/// = M J (J' M J)^-1 J' F
/// (J' H J) dtor = (J' M J) (J' M J)^-1 J' F
/// (V D V') dtor = (J' M J) (J' M J)^-1 J' F : eigen decomposition of (J' H J) using
/// generalized eigenvalue problem with (J' M J)
/// dtor = (V D^-1 V') (J' M J) (J' M J)^-1 J' F : (J' M J) (J' M J)^-1 = I. However, it has
/// the projection effect of J'F into (J' M J)
/// vector space(?). The projection will be taken
/// care by (V D^-1 V')
/// = (V D^-1 V') J' F
///
dangles = Matlab.GetVector("TEST.dtor");
if (forceProjectedByTorsional != null)
{
HDebug.Assert(forceProjectedByTorsional.Length == forces.Length);
Matlab.Execute("TEST.F_tor = TEST.M * TEST.J * pinv(TEST.JMJ) * TEST.J' * TEST.F;");
Vector lforceProjectedByTorsional = Matlab.GetVector("TEST.F_tor");
HDebug.Assert(lforceProjectedByTorsional.Size == forceProjectedByTorsional.Length * 3);
for (int i = 0; i < forceProjectedByTorsional.Length; i++)
{
int i3 = i * 3;
forceProjectedByTorsional[i] = new double[] { lforceProjectedByTorsional[i3 + 0],
lforceProjectedByTorsional[i3 + 1],
lforceProjectedByTorsional[i3 + 2], };
}
}
Matlab.Clear("TEST");
}
return(dangles);
}
public static double[] GetRotAngles(Universe univ
, Vector[] coords
, Vector[] forces
, double t // 0.1
, MatrixByArr J = null
, Graph <Universe.Atom[], Universe.Bond> univ_flexgraph = null
, List <Universe.RotableInfo> univ_rotinfos = null
, HPack <Vector[]> forcesProjectedByTorsional = null
, HPack <Vector[]> dcoordsProjectedByTorsional = null
)
{
Vector mass = univ.GetMasses();
//Vector[] dcoords = new Vector[univ.size];
double t2 = t * t;
//for(int i=0; i<univ.size; i++)
// dcoords[i] = forces[i] * (0.5*t2/mass[i]);
if (J == null)
{
if (univ_rotinfos == null)
{
if (univ_flexgraph == null)
{
univ_flexgraph = univ.BuildFlexibilityGraph();
}
univ_rotinfos = univ.GetRotableInfo(univ_flexgraph);
}
J = TNM.GetJ(univ, coords, univ_rotinfos);
}
double[] dangles;
using (new Matlab.NamedLock("TEST"))
{
Matlab.Clear("TEST");
Matlab.PutVector("TEST.F", Vector.FromBlockvector(forces));
Matlab.PutValue("TEST.t2", t2);
//Matlab.PutVector("TEST.R", Vector.FromBlockvector(dcoords));
Matlab.PutMatrix("TEST.J", J);
Matlab.PutVector("TEST.M", univ.GetMasses(3));
Matlab.Execute("TEST.M = diag(TEST.M);");
/// f = m a
/// d = 1/2 a t^2
/// = 0.5 f/m t^2
/// f = m a
/// = 2 m d t^-2
///
/// coord change
/// dcoord = 0.5 a t^2
/// = (0.5 t^2) f/m
/// = (0.5 t^2) M^-1 F : M is mass matrix, F is the net force of each atom
///
/// torsional angle change
/// dtor = (J' M J)^-1 J' M * dcoord : (6) of TNM paper
/// = (J' M J)^-1 J' M * (0.5 t^2) M^-1 F
/// = (0.5 t^2) (J' M J)^-1 J' F
/// = (0.5 t^2) (J' M J)^-1 J' F
/// = (0.5 t2) invJMJ JF
///
/// force filtered by torsional ...
/// F_tor = m a
/// = 2 m d t^-2
/// = 2 M (J * dtor) t^-2
/// = 2 M (J * (0.5 t^2) (J' M J)^-1 J' F) t^-2
/// = M J (J' M J)^-1 J' F
/// = MJ invJMJ JF
///
/// coord change filtered by torsional
/// R_tor = (0.5 t^2) M^-1 * F_tor
/// = (0.5 t^2) J (J' M J)^-1 J' F
/// = (0.5 t2) J invJMJ JF
Matlab.Execute("TEST.JMJ = TEST.J' * TEST.M * TEST.J;");
Matlab.Execute("TEST.invJMJ = inv(TEST.JMJ);");
Matlab.Execute("TEST.MJ = TEST.M * TEST.J;");
Matlab.Execute("TEST.JF = TEST.J' * TEST.F;");
Matlab.Execute("TEST.dtor = (0.5 * TEST.t2) * TEST.invJMJ * TEST.JF;"); // (6) of TNM paper
Matlab.Execute("TEST.F_tor = TEST.MJ * TEST.invJMJ * TEST.JF;");
Matlab.Execute("TEST.R_tor = (0.5 * TEST.t2) * TEST.J * TEST.invJMJ * TEST.JF;");
dangles = Matlab.GetVector("TEST.dtor");
if (forcesProjectedByTorsional != null)
{
Vector F_tor = Matlab.GetVector("TEST.F_tor");
HDebug.Assert(F_tor.Size == forces.Length * 3);
forcesProjectedByTorsional.value = new Vector[forces.Length];
for (int i = 0; i < forces.Length; i++)
{
int i3 = i * 3;
forcesProjectedByTorsional.value[i] = new double[] { F_tor[i3 + 0], F_tor[i3 + 1], F_tor[i3 + 2] };
}
}
if (dcoordsProjectedByTorsional != null)
{
Vector R_tor = Matlab.GetVector("TEST.R_tor");
HDebug.Assert(R_tor.Size == coords.Length * 3);
dcoordsProjectedByTorsional.value = new Vector[coords.Length];
for (int i = 0; i < coords.Length; i++)
{
int i3 = i * 3;
dcoordsProjectedByTorsional.value[i] = new double[] { R_tor[i3 + 0], R_tor[i3 + 1], R_tor[i3 + 2] };
}
}
Matlab.Clear("TEST");
}
return(dangles);
}
public void __MinimizeTNM(List <ForceField.IForceField> frcflds)
{
HDebug.Assert(false);
// do not use this, because not finished yet
Graph <Universe.Atom[], Universe.Bond> univ_flexgraph = this.BuildFlexibilityGraph();
List <Universe.RotableInfo> univ_rotinfos = this.GetRotableInfo(univ_flexgraph);
Vector[] coords = this.GetCoords();
double tor_normInf = double.PositiveInfinity;
//double maxRotAngle = 0.1;
Vector[] forces = null;
MatrixByArr hessian = null;
double forces_normsInf = 1;
int iter = 0;
double scale = 1;
this._SaveCoordsToPdb(iter.ToString("0000") + ".pdb", coords);
while (true)
{
iter++;
forces = this.GetVectorsZero();
hessian = new double[size * 3, size *3];
Dictionary <string, object> cache = new Dictionary <string, object>();
double energy = this.GetPotential(frcflds, coords, ref forces, ref hessian, cache);
forces_normsInf = (new Vectors(forces)).NormsInf().ToArray().Max();
//System.Console.WriteLine("iter {0:###}: frcnrminf {1}, energy {2}, scale {3}", iter, forces_normsInf, energy, scale);
//if(forces_normsInf < 0.001)
//{
// break;
//}
Vector torz = null;
double maxcarz = 1;
Vector car = null;
//double
using (new Matlab.NamedLock("TEST"))
{
MatrixByArr H = hessian;
MatrixByArr J = Paper.TNM.GetJ(this, this.GetCoords(), univ_rotinfos);
Vector m = this.GetMasses(3);
Matlab.PutVector("TEST.F", Vector.FromBlockvector(forces));
Matlab.PutMatrix("TEST.J", J);
Matlab.PutMatrix("TEST.H", H);
Matlab.PutVector("TEST.M", m);
Matlab.Execute("TEST.M = diag(TEST.M);");
Matlab.Execute("TEST.JMJ = TEST.J' * TEST.M * TEST.J;");
Matlab.Execute("TEST.JHJ = TEST.J' * TEST.H * TEST.J;");
// (J' H J) tor = J' F
// (V' D V) tor = J' F <= (V,D) are (eigvec,eigval) of generalized eigenvalue problem with (A = JHJ, B = JMJ)
// tor = inv(V' D V) J' F
Matlab.Execute("[TEST.V, TEST.D] = eig(TEST.JHJ, TEST.JMJ);");
//Matlab.Execute("TEST.zidx = 3:end;");
Matlab.Execute("TEST.invJHJ = TEST.V * pinv(TEST.D ) * TEST.V';");
Matlab.Execute("TEST.tor = TEST.invJHJ * TEST.J' * TEST.F;");
Matlab.Execute("TEST.car = TEST.J * TEST.tor;");
car = Matlab.GetVector("TEST.car");
Matlab.Execute("[TEST.DS, TEST.DSI] = sort(abs(diag(TEST.D)));");
Matlab.Execute("TEST.zidx = TEST.DSI(6:end);");
Matlab.Execute("TEST.Dz = TEST.D;");
//Matlab.Execute("TEST.Dz(TEST.zidx,TEST.zidx) = 0;");
Matlab.Execute("TEST.invJHJz = TEST.V * pinv(TEST.Dz) * TEST.V';");
Matlab.Execute("TEST.torz = TEST.invJHJz * TEST.J' * TEST.F;");
Matlab.Execute("TEST.carz = TEST.J * TEST.torz;");
torz = Matlab.GetVector("TEST.torz");
maxcarz = Matlab.GetValue("max(max(abs(TEST.carz)))");
scale = 1;
if (maxcarz > 0.01)
{
scale = scale * 0.01 / maxcarz;
}
Matlab.Clear("TEST");
};
tor_normInf = torz.NormInf();
double frcnrinf = car.ToArray().HAbs().Max();
if (maxcarz < 0.001)
{
break;
}
System.Console.WriteLine("iter {0:###}: frcnrminf {1}, tor(frcnrinf) {2}, energy {3}, scale {4}", iter, forces_normsInf, frcnrinf, energy, scale);
HDebug.Assert(univ_rotinfos.Count == torz.Size);
for (int i = 0; i < univ_rotinfos.Count; i++)
{
Universe.RotableInfo rotinfo = univ_rotinfos[i];
Vector rotOrigin = coords[rotinfo.bondedAtom.ID];
double rotAngle = torz[i] * scale; // (maxRotAngle / tor_normInf);
if (rotAngle == 0)
{
continue;
}
Vector rotAxis = coords[rotinfo.bond.atoms[1].ID] - coords[rotinfo.bond.atoms[0].ID];
Quaternion rot = new Quaternion(rotAxis, rotAngle);
MatrixByArr rotMat = rot.RotationMatrix;
foreach (Atom atom in rotinfo.rotAtoms)
{
int id = atom.ID;
Vector coord = rotMat * (coords[id] - rotOrigin) + rotOrigin;
coords[id] = coord;
}
}
this._SaveCoordsToPdb(iter.ToString("0000") + ".pdb", coords);
}
}
public static Vector[] GetRotate(Vector[] coords, Vector cent, int[] block)
{
throw new Exception("this implementation is wrong. Use the following algorithm to get rotation modes for RTB.");
double[] io_mass = null;
if (HDebug.IsDebuggerAttached)
{
using (var temp = new HTempDirectory(@"K:\temp\", null))
{
temp.EnterTemp();
HFile.WriteAllText("rtbProjection.m", @"
function [P, xyz] = rtbProjection(xyz, mass)
% the approach is to find the inertia. compute the principal axes. and then use them to determine directly translation or rotation.
n = size(xyz, 1); % n: the number of atoms
if nargin == 1
mass = ones(n,1);
end
M = sum(mass);
% find the mass center.
m3 = repmat(mass, 1, 3);
center = sum (xyz.*m3)/M;
xyz = xyz - center(ones(n, 1), :);
mwX = sqrt (m3).*xyz;
inertia = sum(sum(mwX.^2))*eye(3) - mwX'*mwX;
[V,D] = eig(inertia);
tV = V'; % tV: transpose of V. Columns of V are principal axes.
for i=1:3
trans{i} = tV(ones(n,1)*i, :); % the 3 translations are along principal axes
end
P = zeros(n*3, 6);
for i=1:3
rotate{i} = cross(trans{i}, xyz);
temp = mat2vec(trans{i});
P(:,i) = temp/norm(temp);
temp = mat2vec(rotate{i});
P(:,i+3) = temp/norm(temp);
end
m3 = mat2vec(sqrt(m3));
P = repmat (m3(:),1,size(P,2)).*P;
% now normalize columns of P
P = P*diag(1./normMat(P,1));
function vec = mat2vec(mat)
% convert a matrix to a vector, extracting data *row-wise*.
vec = reshape(mat',1,prod(size(mat)));
");
Matlab.Execute("cd \'" + temp.dirinfo.FullName + "\'");
Matlab.PutMatrix("xyz", coords.ToMatrix(false));
Matlab.PutVector("mass", io_mass);
temp.QuitTemp();
}
}
HDebug.Assert(coords.Length == io_mass.Length);
Vector mwcenter = new double[3];
for (int i = 0; i < coords.Length; i++)
{
mwcenter += (coords[i] * io_mass[i]);
}
mwcenter /= io_mass.Sum();
Vector[] mwcoords = new Vector[coords.Length];
for (int i = 0; i < coords.Length; i++)
{
mwcoords[i] = (coords[i] - mwcenter) * io_mass[i];
}
Matrix mwPCA = new double[3, 3];
for (int i = 0; i < coords.Length; i++)
{
mwPCA += LinAlg.VVt(mwcoords[i], mwcoords[i]);
}
var V_D = LinAlg.Eig(mwPCA.ToArray());
var V = V_D.Item1;
Vector[] rotvecs = new Vector[3];
for (int i = 0; i < 3; i++)
{
Vector rotaxis = new double[] { V[0, i], V[1, i], V[2, i] };
Vector[] rotveci = new Vector[coords.Length];
for (int j = 0; j < coords.Length; j++)
{
rotveci[j] = LinAlg.CrossProd(rotaxis, mwcoords[i]);
}
rotvecs[i] = rotveci.ToVector().UnitVector();
}
if (HDebug.IsDebuggerAttached)
{
double dot01 = LinAlg.VtV(rotvecs[0], rotvecs[1]);
double dot02 = LinAlg.VtV(rotvecs[0], rotvecs[2]);
double dot12 = LinAlg.VtV(rotvecs[1], rotvecs[2]);
HDebug.Assert(Math.Abs(dot01) < 0.0000001);
HDebug.Assert(Math.Abs(dot02) < 0.0000001);
HDebug.Assert(Math.Abs(dot12) < 0.0000001);
}
return(rotvecs);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// from song: rtbProjection.m
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// function [P, xyz] = rtbProjection(xyz, mass)
/// % the approach is to find the inertia. compute the principal axes. and then use them to determine directly translation or rotation.
///
/// n = size(xyz, 1); % n: the number of atoms
/// if nargin == 1
/// mass = ones(n,1);
/// end
///
/// M = sum(mass);
/// % find the mass center.
/// m3 = repmat(mass, 1, 3);
/// center = sum (xyz.*m3)/M;
/// xyz = xyz - center(ones(n, 1), :);
///
/// mwX = sqrt (m3).*xyz;
/// inertia = sum(sum(mwX.^2))*eye(3) - mwX'*mwX;
/// [V,D] = eig(inertia);
/// tV = V'; % tV: transpose of V. Columns of V are principal axes.
/// for i=1:3
/// trans{i} = tV(ones(n,1)*i, :); % the 3 translations are along principal axes
/// end
/// P = zeros(n*3, 6);
/// for i=1:3
/// rotate{i} = cross(trans{i}, xyz);
/// temp = mat2vec(trans{i});
/// P(:,i) = temp/norm(temp);
/// temp = mat2vec(rotate{i});
/// P(:,i+3) = temp/norm(temp);
/// end
/// m3 = mat2vec(sqrt(m3));
/// P = repmat (m3(:),1,size(P,2)).*P;
/// % now normalize columns of P
/// P = P*diag(1./normMat(P,1));
///
/// function vec = mat2vec(mat)
/// % convert a matrix to a vector, extracting data *row-wise*.
/// vec = reshape(mat',1,prod(size(mat)));
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// rotx[t_ ] := { { 1,0,0,0},{ 0,Cos[t],-Sin[t],0},{ 0,Sin[t],Cos[t],0},{ 0,0,0,1} };
/// roty[t_ ] := { { Cos[t],0,Sin[t],0},{ 0,1,0,0},{ -Sin[t],0,Cos[t],0},{ 0,0,0,1} };
/// rotz[t_ ] := { { Cos[t],-Sin[t],0,0},{ Sin[t],Cos[t],0,0},{ 0,0,1,0},{ 0,0,0,1} };
/// tran[tx_, ty_, tz_] := { { 1,0,0,tx},{ 0,1,0,ty},{ 0,0,1,tz},{ 0,0,0,1} };
/// pt = Transpose[{{px,py,pz,1}}];
///
/// point : (px,py,pz)
/// center : (cx,cy,cz)
/// angle : t
///
/// tran[cx, cy, cz].rotx[t].tran[-cx, -cy, -cz].pt = {{px}, {cy - cy Cos[t] + py Cos[t] + cz Sin[t] - pz Sin[t]}, {cz - cz Cos[t] + pz Cos[t] - cy Sin[t] + py Sin[t]}, {1}}
/// tran[cx, cy, cz].roty[t].tran[-cx, -cy, -cz].pt = {{cx - cx Cos[t] + px Cos[t] - cz Sin[t] + pz Sin[t]}, {py}, {cz - cz Cos[t] + pz Cos[t] + cx Sin[t] - px Sin[t]}, {1}}
/// tran[cx, cy, cz].rotz[t].tran[-cx, -cy, -cz].pt = {{cx - cx Cos[t] + px Cos[t] + cy Sin[t] - py Sin[t]}, {cy - cy Cos[t] + py Cos[t] - cx Sin[t] + px Sin[t]}, {pz}, {1}}
///
/// D[tran[cx, cy, cz].rotx[t].tran[-cx, -cy, -cz].pt, t] = {{0}, {cz Cos[t] - pz Cos[t] + cy Sin[t] - py Sin[t]}, {-cy Cos[t] + py Cos[t] + cz Sin[t] - pz Sin[t]}, {0}}
/// D[tran[cx, cy, cz].roty[t].tran[-cx, -cy, -cz].pt, t] = {{-cz Cos[t] + pz Cos[t] + cx Sin[t] - px Sin[t]}, {0}, {cx Cos[t] - px Cos[t] + cz Sin[t] - pz Sin[t]}, {0}}
/// D[tran[cx, cy, cz].rotz[t].tran[-cx, -cy, -cz].pt, t] = {{cy Cos[t] - py Cos[t] + cx Sin[t] - px Sin[t]}, {-cx Cos[t] + px Cos[t] + cy Sin[t] - py Sin[t]}, {0}, {0}}
///
/// D[tran[cx,cy,cz].rotx[a].tran[-cx,-cy,-cz].pt,a]/.a->0 = {{0}, {cz - pz}, {-cy + py}, {0}}
/// D[tran[cx,cy,cz].roty[a].tran[-cx,-cy,-cz].pt,a]/.a->0 = {{-cz + pz}, {0}, {cx - px}, {0}}
/// D[tran[cx,cy,cz].rotz[a].tran[-cx,-cy,-cz].pt,a]/.a->0 = {{cy - py}, {-cx + px}, {0}, {0}}
/// rotx of atom (px,py,pz) with center (cx,cy,cz): {{0}, {cz - pz}, {-cy + py}, {0}} = { 0, cz - pz, -cy + py, 0 } => { 0, cz - pz, -cy + py }
/// rotx of atom (px,py,pz) with center (cx,cy,cz): {{-cz + pz}, {0}, {cx - px}, {0}} = { -cz + pz, 0, cx - px, 0 } => { -cz + pz, 0, cx - px }
/// rotx of atom (px,py,pz) with center (cx,cy,cz): {{cy - py}, {-cx + px}, {0}, {0}} = { cy - py, -cx + px, 0, 0 } => { cy - py, -cx + px, 0 }
///
int leng = coords.Length;
Vector[] rots;
{
Vector[] rotbyx = new Vector[leng];
Vector[] rotbyy = new Vector[leng];
Vector[] rotbyz = new Vector[leng];
double cx = cent[0];
double cy = cent[1];
double cz = cent[2];
for (int i = 0; i < leng; i++)
{
double px = coords[i][0];
double py = coords[i][1];
double pz = coords[i][2];
rotbyx[i] = new double[] { 0, cz - pz, -cy + py };
rotbyy[i] = new double[] { -cz + pz, 0, cx - px };
rotbyz[i] = new double[] { cy - py, -cx + px, 0 };
}
rots = new Vector[]
{
rotbyx.ToVector().UnitVector(),
rotbyy.ToVector().UnitVector(),
rotbyz.ToVector().UnitVector(),
};
}
if (HDebug.IsDebuggerAttached)
{
Vector[] rotbyx = new Vector[leng];
Vector[] rotbyy = new Vector[leng];
Vector[] rotbyz = new Vector[leng];
Vector zeros = new double[3];
for (int i = 0; i < leng; i++)
{
rotbyx[i] = rotbyy[i] = rotbyz[i] = zeros;
}
Vector rx = new double[3] {
1, 0, 0
};
Vector ry = new double[3] {
0, 1, 0
};
Vector rz = new double[3] {
0, 0, 1
};
Func <Vector, Vector, Vector> GetTangent = delegate(Vector pt, Vector axisdirect)
{
/// Magnitude of rotation tangent is proportional to the distance from the point to the axis.
/// Ex) when a point is in x-axis (r,0), rotating along z-axis by θ is: (r*sin(θ), 0)
///
/// |
/// | ^ sin(θ)
/// | |
/// -+-----------------r----------
///
Vector rot1 = cent;
Vector rot2 = cent + axisdirect;
double dist = Geometry.DistancePointLine(pt, rot1, rot2);
Vector tan = Geometry.RotateTangentUnit(pt, rot1, rot2) * dist;
return(tan);
};
IEnumerable <int> enumblock = block;
if (block != null)
{
enumblock = block;
}
else
{
enumblock = HEnum.HEnumCount(leng);
}
foreach (int i in enumblock)
{
Vector pt = coords[i];
rotbyx[i] = GetTangent(pt, rx);
rotbyy[i] = GetTangent(pt, ry);
rotbyz[i] = GetTangent(pt, rz);
}
Vector[] trots = new Vector[3]
{
rotbyx.ToVector().UnitVector(),
rotbyy.ToVector().UnitVector(),
rotbyz.ToVector().UnitVector(),
};
double test0 = LinAlg.VtV(rots[0], trots[0]);
double test1 = LinAlg.VtV(rots[1], trots[1]);
double test2 = LinAlg.VtV(rots[2], trots[2]);
HDebug.Assert(Math.Abs(test0 - 1) < 0.00000001);
HDebug.Assert(Math.Abs(test1 - 1) < 0.00000001);
HDebug.Assert(Math.Abs(test2 - 1) < 0.00000001);
}
return(rots);
}
public static Vector[] GetRotTran(Vector[] coords, double[] masses)
{
#region source rtbProjection.m
/// rtbProjection.m
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// function [P, xyz] = rtbProjection(xyz, mass)
/// % the approach is to find the inertia. compute the principal axes. and then use them to determine directly translation or rotation.
///
/// n = size(xyz, 1); % n: the number of atoms
/// if nargin == 1
/// mass = ones(n,1);
/// end
///
/// M = sum(mass);
/// % find the mass center.
/// m3 = repmat(mass, 1, 3);
/// center = sum (xyz.*m3)/M;
/// xyz = xyz - center(ones(n, 1), :);
///
/// mwX = sqrt (m3).*xyz;
/// inertia = sum(sum(mwX.^2))*eye(3) - mwX'*mwX;
/// [V,D] = eig(inertia);
/// tV = V'; % tV: transpose of V. Columns of V are principal axes.
/// for i=1:3
/// trans{i} = tV(ones(n,1)*i, :); % the 3 translations are along principal axes
/// end
/// P = zeros(n*3, 6);
/// for i=1:3
/// rotate{i} = cross(trans{i}, xyz);
/// temp = mat2vec(trans{i});
/// P(:,i) = temp/norm(temp);
/// temp = mat2vec(rotate{i});
/// P(:,i+3) = temp/norm(temp);
/// end
/// m3 = mat2vec(sqrt(m3));
/// P = repmat (m3(:),1,size(P,2)).*P;
/// % now normalize columns of P
/// P = P*diag(1./normMat(P,1));
///
/// function vec = mat2vec(mat)
/// % convert a matrix to a vector, extracting data *row-wise*.
/// vec = reshape(mat',1,prod(size(mat)));
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#endregion
if (HDebug.Selftest())
#region selftest
{
// get test coords and masses
Vector[] tcoords = Pdb.FromLines(SelftestData.lines_1EVC_pdb).atoms.ListCoord().ToArray();
double[] tmasses = new double[tcoords.Length];
for (int i = 0; i < tmasses.Length; i++)
{
tmasses[i] = 1;
}
// get test rot/trans RTB vectors
Vector[] trottra = GetRotTran(tcoords, tmasses);
HDebug.Assert(trottra.Length == 6);
// get test ANM
var tanm = Hess.GetHessAnm(tcoords);
// size of vec_i == 1
for (int i = 0; i < trottra.Length; i++)
{
double dist = trottra[i].Dist;
HDebug.Assert(Math.Abs(dist - 1) < 0.00000001);
}
// vec_i and vec_j must be orthogonal
for (int i = 0; i < trottra.Length; i++)
{
for (int j = i + 1; j < trottra.Length; j++)
{
double dot = LinAlg.VtV(trottra[i], trottra[j]);
HDebug.Assert(Math.Abs(dot) < 0.00000001);
}
}
// vec_i' * ANM * vec_i == 0
for (int i = 0; i < trottra.Length; i++)
{
double eigi = LinAlg.VtMV(trottra[i], tanm, trottra[i]);
HDebug.Assert(Math.Abs(eigi) < 0.00000001);
Vector tvecx = trottra[i].Clone();
tvecx[1] += (1.0 / tvecx.Size) * Math.Sign(tvecx[1]);
tvecx = tvecx.UnitVector();
double eigix = LinAlg.VtMV(tvecx, tanm, tvecx);
HDebug.Assert(Math.Abs(eigix) > 0.00000001);
}
}
#endregion
Vector[] rottran;
using (new Matlab.NamedLock(""))
{
Matlab.PutMatrix("xyz", coords.ToMatrix(), true);
Matlab.Execute("xyz = xyz';");
Matlab.PutVector("mass", masses);
//Matlab.Execute("function [P, xyz] = rtbProjection(xyz, mass) ");
//Matlab.Execute("% the approach is to find the inertia. compute the principal axes. and then use them to determine directly translation or rotation. ");
Matlab.Execute(" ");
Matlab.Execute("n = size(xyz, 1); % n: the number of atoms ");
//Matlab.Execute("if nargin == 1; ");
//Matlab.Execute(" mass = ones(n,1); ");
//Matlab.Execute("end ");
Matlab.Execute(" ");
Matlab.Execute("M = sum(mass); ");
Matlab.Execute("% find the mass center. ");
Matlab.Execute("m3 = repmat(mass, 1, 3); ");
Matlab.Execute("center = sum (xyz.*m3)/M; ");
Matlab.Execute("xyz = xyz - center(ones(n, 1), :); ");
Matlab.Execute(" ");
Matlab.Execute("mwX = sqrt (m3).*xyz; ");
Matlab.Execute("inertia = sum(sum(mwX.^2))*eye(3) - mwX'*mwX; ");
Matlab.Execute("[V,D] = eig(inertia); ");
Matlab.Execute("tV = V'; % tV: transpose of V. Columns of V are principal axes. ");
Matlab.Execute("for i=1:3 \n"
+ " trans{i} = tV(ones(n,1)*i, :); % the 3 translations are along principal axes \n"
+ "end \n");
Matlab.Execute("P = zeros(n*3, 6); ");
Matlab.Execute("mat2vec = @(mat) reshape(mat',1,prod(size(mat))); ");
Matlab.Execute("for i=1:3 \n"
+ " rotate{i} = cross(trans{i}, xyz); \n"
+ " temp = mat2vec(trans{i}); \n"
+ " P(:,i) = temp/norm(temp); \n"
+ " temp = mat2vec(rotate{i}); \n"
+ " P(:,i+3) = temp/norm(temp); \n"
+ "end ");
Matlab.Execute("m3 = mat2vec(sqrt(m3)); ");
Matlab.Execute("P = repmat (m3(:),1,size(P,2)).*P; ");
//Matlab.Execute("% now normalize columns of P "); // already normalized
//Matlab.Execute("normMat = @(x) sqrt(sum(x.^2,2)); "); // already normalized
//Matlab.Execute("P = P*diag(1./normMat(P,1)); "); // already normalized
//Matlab.Execute(" "); // already normalized
//////////////////////////////////////////////////////////////////////////////////////////////////////
//Matlab.Execute("function vec = mat2vec(mat) ");
//Matlab.Execute("% convert a matrix to a vector, extracting data *row-wise*. ");
//Matlab.Execute("vec = reshape(mat',1,prod(size(mat))); ");
//////////////////////////////////////////////////////////////////////////////////////////////////////
//Matlab.Execute("function amp = normMat(x) ");
//Matlab.Execute("amp = sqrt(sum(x.^2,2)); ");
Matrix xyz = Matlab.GetMatrix("xyz", true);
Matrix P = Matlab.GetMatrix("P", true);
rottran = P.GetColVectorList();
}
return(rottran);
}
public static Vector[] ToOrthonormal(Vector[] coords, double[] masses, int[] block, Vector[] PBlk)
{
if (HDebug.IsDebuggerAttached)
#region check if elements in non-block are zeros.
{
int leng = coords.Length;
foreach (int i in HEnum.HEnumCount(leng).HEnumExcept(block.HToHashSet()))
{
for (int r = 0; r < PBlk.Length; r++)
{
int c0 = i * 3;
HDebug.Assert(PBlk[r][c0 + 0] == 0);
HDebug.Assert(PBlk[r][c0 + 1] == 0);
HDebug.Assert(PBlk[r][c0 + 2] == 0);
}
}
}
#endregion
Matrix Pmat = new double[block.Length * 3, PBlk.Length];
for (int r = 0; r < PBlk.Length; r++)
{
for (int i = 0; i < block.Length; i++)
{
int i0 = i * 3;
int c0 = block[i] * 3;
Pmat[i0 + 0, r] = PBlk[r][c0 + 0];
Pmat[i0 + 1, r] = PBlk[r][c0 + 1];
Pmat[i0 + 2, r] = PBlk[r][c0 + 2];
}
}
using (new Matlab.NamedLock(""))
{
Matlab.PutValue("n", PBlk.Length);
Matlab.PutMatrix("P", Pmat);
Matlab.Execute("[U,S,V] = svd(P);");
Matlab.Execute("U = U(:,1:n);");
if (HDebug.IsDebuggerAttached)
{
Matlab.Execute("SV = S(1:n,1:n)*V';");
double err = Matlab.GetValue("max(max(abs(P - U*SV)))");
HDebug.Assert(Math.Abs(err) < 0.00000001);
}
Pmat = Matlab.GetMatrix("U");
}
Vector[] PBlkOrth = new Vector[PBlk.Length];
for (int r = 0; r < PBlk.Length; r++)
{
Vector PBlkOrth_r = new double[PBlk[r].Size];
for (int i = 0; i < block.Length; i++)
{
int i0 = i * 3;
int c0 = block[i] * 3;
PBlkOrth_r[c0 + 0] = Pmat[i0 + 0, r];
PBlkOrth_r[c0 + 1] = Pmat[i0 + 1, r];
PBlkOrth_r[c0 + 2] = Pmat[i0 + 2, r];
}
PBlkOrth[r] = PBlkOrth_r;
}
if (HDebug.IsDebuggerAttached)
#region checi the orthonormal condition, and rot/trans condition (using ANM)
{
{ // check if all trans/rot modes are orthonormal
for (int i = 0; i < PBlkOrth.Length; i++)
{
HDebug.Exception(Math.Abs(PBlkOrth[i].Dist - 1) < 0.00000001);
for (int j = i + 1; j < PBlkOrth.Length; j++)
{
double dot = LinAlg.VtV(PBlkOrth[i], PBlkOrth[j]);
HDebug.Exception(Math.Abs(dot) < 0.00000001);
}
}
}
{ // check if this is true rot/trans modes using ANM
Vector[] anmcoords = coords.HClone();
int leng = coords.Length;
foreach (int i in HEnum.HEnumCount(leng).HEnumExcept(block.HToHashSet()))
{
anmcoords[i] = null;
}
HessMatrix H = GetHessAnm(anmcoords, 100);
Matrix PHP;
using (new Matlab.NamedLock(""))
{
Matlab.PutSparseMatrix("H", H.GetMatrixSparse(), 3, 3);
Matlab.PutMatrix("P", PBlkOrth.ToMatrix(true));
PHP = Matlab.GetMatrix("P'*H*P");
}
double maxerr = PHP.HAbsMax();
HDebug.Exception(Math.Abs(maxerr) < 0.00000001);
}
}
#endregion
return(PBlkOrth);
}
public static HessRTB GetHessRTB(HessMatrix hess, Vector[] coords, double[] masses, IList <int[]> blocks, string opt)
{
#region check pre-condition
{
HDebug.Assert(coords.Length == hess.ColBlockSize); // check hess matrix
HDebug.Assert(coords.Length == hess.RowBlockSize); // check hess matrix
HDebug.Assert(coords.Length == blocks.HMerge().HToHashSet().Count); // check hess contains all blocks
HDebug.Assert(coords.Length == blocks.HMerge().Count); // no duplicated index in blocks
}
#endregion
List <Vector> Ps = new List <Vector>();
foreach (int[] block in blocks)
{
List <Vector> PBlk = new List <Vector>();
switch (opt)
{
case "v1":
// GetRotate is incorrect
PBlk.AddRange(GetTrans(coords, masses, block));
PBlk.AddRange(GetRotate(coords, masses, block));
break;
case "v2":
PBlk.AddRange(GetRotTran(coords, masses, block));
break;
case null:
goto case "v2";
}
{
// PBlk = ToOrthonormal (coords, masses, block, PBlk.ToArray()).ToList();
///
/// Effect of making orthonormal is not significant as below table, but consumes time by calling SVD
/// Therefore, skip making orthonormal
/// =========================================================================================================================================================
/// model | making orthonormal?| | MSF corr , check sparsity , overlap weighted by eigval : overlap of mode 1-1, 2-2, 3-3, ...
/// =========================================================================================================================================================
/// NMA | orthonormal by SVD | RTB | corr 0.9234, spcty(all NaN, ca NaN), wovlp 0.5911 : 0.82,0.79,0.74,0.69,0.66,0.63,0.60,0.59,0.56,0.54)
/// | orthogonal | RTB | corr 0.9230, spcty(all NaN, ca NaN), wovlp 0.5973 : 0.83,0.80,0.75,0.70,0.67,0.64,0.60,0.59,0.58,0.55)
/// ---------------------------------------------------------------------------------------------------------------------------------------------------------
/// scrnNMA | orthonormal by SVD | RTB | corr 0.9245, spcty(all NaN, ca NaN), wovlp 0.5794 : 0.83,0.78,0.73,0.68,0.65,0.62,0.60,0.58,0.55,0.55)
/// | orthogonal | RTB | corr 0.9243, spcty(all NaN, ca NaN), wovlp 0.5844 : 0.83,0.78,0.73,0.68,0.66,0.62,0.60,0.58,0.55,0.55)
/// ---------------------------------------------------------------------------------------------------------------------------------------------------------
/// sbNMA | orthonormal by SVD | RTB | corr 0.9777, spcty(all NaN, ca NaN), wovlp 0.6065 : 0.93,0.89,0.86,0.81,0.75,0.71,0.69,0.66,0.63,0.62)
/// | orthogonal | RTB | corr 0.9776, spcty(all NaN, ca NaN), wovlp 0.6175 : 0.94,0.90,0.87,0.82,0.76,0.73,0.71,0.69,0.66,0.63)
/// ---------------------------------------------------------------------------------------------------------------------------------------------------------
/// ssNMA | orthonormal by SVD | RTB | corr 0.9677, spcty(all NaN, ca NaN), wovlp 0.5993 : 0.92,0.87,0.83,0.77,0.72,0.69,0.66,0.63,0.60,0.59)
/// | orthogonal | RTB | corr 0.9675, spcty(all NaN, ca NaN), wovlp 0.6076 : 0.92,0.88,0.84,0.78,0.73,0.70,0.67,0.64,0.62,0.60)
/// ---------------------------------------------------------------------------------------------------------------------------------------------------------
/// eANM | orthonormal by SVD | RTB | corr 0.9870, spcty(all NaN, ca NaN), wovlp 0.5906 : 0.95,0.91,0.87,0.83,0.77,0.73,0.71,0.68,0.66,0.61)
/// | orthogonal | RTB | corr 0.9869, spcty(all NaN, ca NaN), wovlp 0.6014 : 0.95,0.92,0.88,0.84,0.78,0.74,0.73,0.70,0.67,0.65)
/// ---------------------------------------------------------------------------------------------------------------------------------------------------------
/// AA-ANM | orthonormal by SVD | RTB | corr 0.9593, spcty(all NaN, ca NaN), wovlp 0.4140 : 0.94,0.90,0.85,0.78,0.74,0.72,0.66,0.64,0.61,0.61)
/// | orthogonal | RTB | corr 0.9589, spcty(all NaN, ca NaN), wovlp 0.4204 : 0.94,0.91,0.85,0.80,0.76,0.73,0.68,0.66,0.63,0.61)
}
Ps.AddRange(PBlk);
}
Matrix P = Matrix.FromColVectorList(Ps);
Matrix PHP;
Matrix PMP;
using (new Matlab.NamedLock(""))
{
if (hess is HessMatrixSparse)
{
Matlab.PutSparseMatrix("H", hess.GetMatrixSparse(), 3, 3);
}
else if (hess is HessMatrixDense)
{
Matlab.PutMatrix("H", hess, true);
}
else
{
HDebug.Exception();
}
Matlab.PutMatrix("P", P, true);
Matlab.PutVector("M", masses);
Matlab.Execute("M=diag(reshape([M,M,M]',length(M)*3,1));");
Matlab.Execute("PHP = P'*H*P; PHP = (PHP + PHP')/2;");
Matlab.Execute("PMP = P'*M*P; PMP = (PMP + PMP')/2;");
PHP = Matlab.GetMatrix("PHP", true);
PMP = Matlab.GetMatrix("PMP", true);
}
return(new HessRTB
{
hess = hess,
coords = coords,
masses = masses,
blocks = blocks,
P = P,
PHP = PHP,
PMP = PMP,
});
}
public Mode[] GetRtbModes()
{
if (_rtbmodes == null)
{
Matrix eigvec;
double[] eigval;
using (new Matlab.NamedLock(""))
{ // solve [eigvec, eigval] = eig(PHP, PMP)
{ // PMPih = 1/sqrt(PMP) where "ih" stands for "Inverse Half" -1/2
Matlab.PutMatrix("PMP", PMP);
Matlab.Execute("PMP = (PMP + PMP')/2;");
Matlab.Execute("[PMPih.V, PMPih.D] = eig(PMP); PMPih.D = diag(PMPih.D);");
Matlab.Execute("PMPih.Dih = 1.0 ./ sqrt(PMPih.D);"); // PMPih.Dih = PMPih.D ^ -1/2
if (HDebug.IsDebuggerAttached)
{
double err = Matlab.GetValue("max(abs(1 - PMPih.D .* PMPih.Dih .* PMPih.Dih))");
HDebug.AssertTolerance(0.00000001, err);
}
Matlab.Execute("PMPih = PMPih.V * diag(PMPih.Dih) * PMPih.V';");
if (HDebug.IsDebuggerAttached)
{
double err = Matlab.GetValue("max(max(abs(eye(size(PMP)) - (PMP * PMPih * PMPih))))");
HDebug.AssertTolerance(0.00000001, err);
}
Matlab.Execute("clear PMP;");
}
{ // to solve [eigvec, eigval] = eig(PHP, PMP)
// 1. H = PMP^-1/2 * PHP * PMP^-1/2
// 2. [V,D] = eig(H)
// 3. V = PMP^-1/2 * V
Matlab.PutMatrix("PHP", PHP); // put RTB Hess
Matlab.Execute("PHP = (PHP + PHP')/2;");
Matlab.Execute("PHP = PMPih * PHP * PMPih; PHP = (PHP + PHP')/2;"); // mass-weighted Hess
Matlab.Execute("[V,D] = eig(PHP); D=diag(D); clear PHP;"); // mass-weighted modes, eigenvalues
Matlab.Execute("V = PMPih * V; clear PMPih;"); // mass-reduced modes
}
eigvec = Matlab.GetMatrix("V");
eigval = Matlab.GetVector("D");
Matlab.Execute("clear;");
}
List <Mode> modes;
{ // sort by eigenvalues
int[] idx = eigval.HIdxSorted();
modes = new List <Mode>(idx.Length);
for (int i = 0; i < eigval.Length; i++)
{
Mode mode = new Mode
{
th = i + 1,
eigval = eigval[idx[i]],
eigvec = eigvec.GetColVector(idx[i]),
};
modes.Add(mode);
}
}
_rtbmodes = modes.ToArray();
}
return(_rtbmodes);
}
