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);
}
}
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 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());
}
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);
}
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 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
));
}
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 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);
}
public Mode[] GetModesMassReduced(bool delhess, int?numModeReturn, Dictionary <string, object> secs)
{
HessMatrix mwhess_ = GetHessMassWeighted(delhess);
IMatrix <double> mwhess = mwhess_;
bool bsparse = (mwhess_ is HessMatrixSparse);
Mode[] modes;
using (new Matlab.NamedLock(""))
{
string msg = "";
{
if (bsparse)
{
Matlab.PutSparseMatrix("V", mwhess_.GetMatrixSparse(), 3, 3);
}
else
{
Matlab.PutMatrix("V", ref mwhess, true, true);
}
}
msg += Matlab.Execute("tic;");
msg += Matlab.Execute("V = (V+V')/2; "); // make symmetric
{ // eigen-decomposition
if (bsparse)
{
if (numModeReturn != null)
{
int numeig = numModeReturn.Value;
string cmd = "eigs(V," + numeig + ",'sm')";
msg += Matlab.Execute("[V,D] = " + cmd + "; ");
}
else
{
msg += Matlab.Execute("[V,D] = eig(full(V)); ");
}
}
else
{
msg += Matlab.Execute("[V,D] = eig(V); ");
}
}
msg += Matlab.Execute("tm=toc; ");
if (secs != null)
{
int numcore = Matlab.Environment.NumCores;
double tm = Matlab.GetValue("tm");
secs.Clear();
secs.Add("num cores", numcore);
secs.Add("secs multi-threaded", tm);
secs.Add("secs estimated single-threaded", tm * Math.Sqrt(numcore));
/// x=[]; for i=1:20; tic; H=rand(100*i); [V,D]=eig(H+H'); xx=toc; x=[x;i,xx]; fprintf('%d, %f\n',i,xx); end; x
///
/// http://www.mathworks.com/help/matlab/ref/matlabwindows.html
/// run matlab in single-thread: matlab -nodesktop -singleCompThread
/// multi-thread: matlab -nodesktop
///
/// my computer, single thread: cst1={0.0038,0.0106,0.0277,0.0606,0.1062,0.1600,0.2448,0.3483,0.4963,0.6740,0.9399,1.1530,1.4568,1.7902,2.1794,2.6387,3.0510,3.6241,4.2203,4.8914};
/// 2 cores: cst2={0.0045,0.0098,0.0252,0.0435,0.0784,0.1203,0.1734,0.2382,0.3316,0.4381,0.5544,0.6969,1.0170,1.1677,1.4386,1.7165,2.0246,2.4121,2.8124,3.2775};
/// scale: (cst1.cst2)/(cst1.cst1) = 0.663824
/// approx: (cst1.cst2)/(cst1.cst1)*Sqrt[2.2222] = 0.989566
/// my computer, single thread: cst1={0.0073,0.0158,0.0287,0.0573,0.0998,0.1580,0.2377,0.3439,0.4811,0.6612,0.8738,1.0974,1.4033,1.7649,2.1764,2.6505,3.1142,3.5791,4.1910,4.8849};
/// 2 cores: cst2={0.0085,0.0114,0.0250,0.0475,0.0719,0.1191,0.1702,0.2395,0.3179,0.4319,0.5638,0.7582,0.9454,1.1526,1.4428,1.7518,2.0291,2.4517,2.8200,3.3090};
/// scale: (cst1.cst2)/(cst1.cst1) = 0.671237
/// approx: (cst1.cst2)/(cst1.cst1)*Sqrt[2.2222] = 1.00062
/// ts4-stat , singhe thread: cst1={0.0048,0.0213,0.0641,0.1111,0.1560,0.2013,0.3307,0.3860,0.4213,0.8433,1.0184,1.3060,1.9358,2.2699,2.1718,3.0149,3.1081,4.3594,5.0356,5.5260};
/// 12 cores: cst2={0.2368,0.0614,0.0235,0.1321,0.0574,0.0829,0.1078,0.1558,0.1949,0.3229,0.4507,0.3883,0.4685,0.6249,0.6835,0.8998,0.9674,1.1851,1.3415,1.6266};
/// scale: (cst1.cst2)/(cst1.cst1) = 0.286778
/// (cst1.cst2)/(cst1.cst1)*Sqrt[12*1.1111] = 1.04716
/// ts4-stat , singhe thread: cst1={0.0138,0.0215,0.0522,0.0930,0.1783,0.2240,0.2583,0.4054,0.4603,0.9036,0.9239,1.5220,1.9443,2.1042,2.3583,3.0208,3.5507,3.8810,3.6943,6.2085};
/// 12 cores: cst2={0.1648,0.1429,0.1647,0.0358,0.0561,0.0837,0.1101,0.1525,0.2084,0.2680,0.3359,0.4525,0.4775,0.7065,0.6691,0.9564,1.0898,1.2259,1.2926,1.5879};
/// scale: (cst1.cst2)/(cst1.cst1) = 0.294706
/// (cst1.cst2)/(cst1.cst1)*Sqrt[12] = 1.02089
/// ts4-stat , singhe thread: cst1={0.0126,0.0183,0.0476,0.0890,0.1353,0.1821,0.2265,0.3079,0.4551,0.5703,1.0009,1.2175,1.5922,1.8805,2.1991,2.3096,3.7680,3.7538,3.9216,5.2899,5.6737,7.0783,8.8045,9.0091,9.9658,11.6888,12.8311,14.4933,17.2462,17.5660};
/// 12 cores: cst2={0.0690,0.0117,0.0275,0.0523,0.0819,0.1071,0.1684,0.1984,0.1974,0.2659,0.3305,0.4080,0.4951,0.7089,0.9068,0.7936,1.2632,1.0708,1.3187,1.6106,1.7216,2.1114,2.8249,2.7840,2.8259,3.3394,4.3092,4.2708,5.3358,5.7479};
/// scale: (cst1.cst2)/(cst1.cst1) = 0.311008
/// (cst1.cst2)/(cst1.cst1)*Sqrt[12] = 1.07736
/// Therefore, the speedup using multi-core could be sqrt(#core)
}
msg += Matlab.Execute("D = diag(D); ");
if (msg.Trim() != "")
{
System.Console.WriteLine();
bool domanual = HConsole.ReadValue <bool>("possibly failed. Will you do ((('V = (V+V')/2;[V,D] = eig(V);D = diag(D);))) manually ?", false, null, false, true);
if (domanual)
{
Matlab.Clear();
Matlab.PutMatrix("V", ref mwhess, true, true);
System.Console.WriteLine("cleaning working-space and copying V in matlab are done.");
System.Console.WriteLine("do V = (V+V')/2; [V,D]=eig(V); D=diag(D);");
while (HConsole.ReadValue <bool>("V and D are ready to use in matlab?", false, null, false, true) == false)
{
;
}
//string path_V = HConsole.ReadValue<string>("path V.mat", @"C:\temp\V.mat", null, false, true);
//Matlab.Execute("clear;");
//Matlab.PutMatrix("V", ref mwhess, true, true);
//Matlab.Execute(string.Format("save('{0}', '-V7.3');", path_V));
//while(HConsole.ReadValue<bool>("ready for VD.mat containing V and D?", false, null, false, true) == false) ;
//string path_VD = HConsole.ReadValue<string>("path VD.mat", @"C:\temp\VD.mat", null, false, true);
//Matlab.Execute(string.Format("load '{0}';", path_V));
}
}
if (numModeReturn != null)
{
Matlab.PutValue("nmode", numModeReturn.Value);
Matlab.Execute("V = V(:,1:nmode);");
Matlab.Execute("D = D(1:nmode);");
}
MatrixByRowCol V = Matlab.GetMatrix("V", MatrixByRowCol.Zeros, true, true);
Vector D = Matlab.GetVector("D");
HDebug.Assert(V.RowSize == D.Size);
modes = new Mode[D.Size];
for (int i = 0; i < D.Size; i++)
{
Vector eigvec = V.GetColVector(i);
double eigval = D[i];
modes[i] = new Mode
{
th = i,
eigval = eigval,
eigvec = eigvec,
};
}
V = null;
}
System.GC.Collect();
modes.UpdateMassReduced(mass.ToArray());
return(modes);
}
public static HessForcInfo GetCoarseHessForcSubSimple
(object[] atoms
, HessMatrix hess
, Vector[] forc
, List <int>[] lstNewIdxRemv
, double thres_zeroblk
, ILinAlg ila
, bool cloneH
, string[] options // { "pinv(D)" }
)
{
HessMatrix H = hess;
Vector F = forc.ToVector();
if (cloneH)
{
H = H.CloneHess();
}
bool process_disp_console = false;
bool parallel = true;
for (int iter = lstNewIdxRemv.Length - 1; iter >= 0; iter--)
{
//int[] ikeep = lstNewIdxRemv[iter].Item1;
int[] iremv = lstNewIdxRemv[iter].ToArray();
int iremv_min = iremv.Min();
int iremv_max = iremv.Max();
HDebug.Assert(H.ColBlockSize == H.RowBlockSize);
int blksize = H.ColBlockSize;
//HDebug.Assert(ikeep.Max() < blksize);
//HDebug.Assert(iremv.Max() < blksize);
//HDebug.Assert(iremv.Max()+1 == blksize);
//HDebug.Assert(iremv.Max() - iremv.Min() + 1 == iremv.Length);
int[] idxkeep = HEnum.HEnumFromTo(0, iremv_min - 1).ToArray();
int[] idxremv = HEnum.HEnumFromTo(iremv_min, iremv_max).ToArray();
//HDebug.Assert(idxkeep.HUnionWith(idxremv).Length == blksize);
IterInfo iterinfo = new IterInfo();
iterinfo.sizeHessBlkMat = idxremv.Max() + 1; // H.ColBlockSize;
iterinfo.numAtomsRemoved = idxremv.Length;
iterinfo.time0 = DateTime.UtcNow;
////////////////////////////////////////////////////////////////////////////////////////
// make C sparse
double C_density0;
double C_density1;
{
double thres_absmax = thres_zeroblk;
C_density0 = 0;
List <Tuple <int, int> > lstIdxToMakeZero = new List <Tuple <int, int> >();
foreach (var bc_br_bval in H.EnumBlocksInCols(idxremv))
{
int bc = bc_br_bval.Item1;
int br = bc_br_bval.Item2;
var bval = bc_br_bval.Item3;
if (br >= iremv_min)
{
// bc_br is in D, not in C
continue;
}
C_density0++;
double absmax_bval = bval.HAbsMax();
if (absmax_bval < thres_absmax)
{
lstIdxToMakeZero.Add(new Tuple <int, int>(bc, br));
}
}
C_density1 = C_density0 - lstIdxToMakeZero.Count;
foreach (var bc_br in lstIdxToMakeZero)
{
int bc = bc_br.Item1;
int br = bc_br.Item2;
HDebug.Assert(bc > br);
var Cval = H.GetBlock(bc, br);
var Dval = H.GetBlock(bc, bc);
var Aval = H.GetBlock(br, br);
var Bval = Cval.Tr();
H.SetBlock(bc, br, null); // nCval = Cval -Cval
H.SetBlock(bc, bc, Dval + Cval); // nDval = Dval - (-Cval) = Dval + Cval
// nBval = Bval -Bval
H.SetBlock(br, br, Aval + Bval); // nAval = Aval - (-Bval) = Aval + Bval
}
iterinfo.numSetZeroBlock = lstIdxToMakeZero.Count;
iterinfo.numNonZeroBlock = (int)C_density1;
C_density0 /= (idxkeep.Length * idxremv.Length);
C_density1 /= (idxkeep.Length * idxremv.Length);
}
////////////////////////////////////////////////////////////////////////////////////////
// get A, B, C, D
HessMatrix A = H.SubMatrixByAtoms(false, idxkeep, idxkeep);
HessMatrix B = H.SubMatrixByAtoms(false, idxkeep, idxremv);
HessMatrix C = H.SubMatrixByAtoms(false, idxremv, idxkeep);
HessMatrix D = H.SubMatrixByAtoms(false, idxremv, idxremv);
Vector nF;
Vector nG;
{
nF = new double[idxkeep.Length * 3];
nG = new double[idxremv.Length * 3];
for (int i = 0; i < idxkeep.Length * 3; i++)
{
nF[i] = F[i];
}
for (int i = 0; i < idxremv.Length * 3; i++)
{
nG[i] = F[i + nF.Size];
}
}
Matlab.PutMatrix("A", A, true);
Matlab.PutMatrix("B", B, true);
Matlab.PutMatrix("C", C, true);
Matlab.PutMatrix("D", D, true);
Matlab.PutVector("F", nF);
Matlab.PutVector("G", nG);
////////////////////////////////////////////////////////////////////////////////////////
// Get B.inv(D).C
//
// var BInvDC_BInvDG = Get_BInvDC_BInvDG_WithSqueeze(C, D, nG, process_disp_console
// , options
// , thld_BinvDC: thres_zeroblk/lstNewIdxRemv.Length
// , parallel: parallel
// );
// HessMatrix B_invD_C = BInvDC_BInvDG.Item1;
// Vector B_invD_G = BInvDC_BInvDG.Item2;
// GC.Collect(0);
Matlab.Execute("BinvD = B * inv(D);");
Matlab.Execute("clear B, D;");
Matlab.Execute("BinvDC = BinvD * C;");
Matlab.Execute("BinvDG = BinvD * G;");
////////////////////////////////////////////////////////////////////////////////////////
// Get A - B.inv(D).C
// F - B.inv(D).G
Matlab.Execute("HH = A - BinvDC;");
Matlab.Execute("FF = F - BinvDG;");
////////////////////////////////////////////////////////////////////////////////////////
// Replace A -> H
H = Matlab.GetMatrix("HH", H.Zeros, true);
F = Matlab.GetVector("FF");
Matlab.Execute("clear;");
{
ValueTuple <HessMatrix, Vector> BBInvDDCC_BBInvDDGG = Get_BInvDC_BInvDG_Simple
(C
, D
, nG
, process_disp_console: process_disp_console
, thld_BinvDC: thres_zeroblk / lstNewIdxRemv.Length
, parallel: parallel
);
HessMatrix HH = A - BBInvDDCC_BBInvDDGG.Item1;
Vector FF = nF - BBInvDDCC_BBInvDDGG.Item2;
double dbg_HH = (HH - H).HAbsMax();
double dbg_FF = (FF - F).ToArray().MaxAbs();
HDebug.Assert(Math.Abs(dbg_HH) < 0.00000001);
HDebug.Assert(Math.Abs(dbg_FF) < 0.00000001);
}
{
ValueTuple <HessMatrix, Vector> BBInvDDCC_BBInvDDGG = Get_BInvDC_BInvDG
(C
, D
, nG
, process_disp_console: process_disp_console
, options: new string[0]
, thld_BinvDC: thres_zeroblk / lstNewIdxRemv.Length
, parallel: parallel
);
HessMatrix HH = A - BBInvDDCC_BBInvDDGG.Item1;
Vector FF = nF - BBInvDDCC_BBInvDDGG.Item2;
double dbg_HH = (HH - H).HAbsMax();
double dbg_FF = (FF - F).ToArray().MaxAbs();
HDebug.Assert(Math.Abs(dbg_HH) < 0.00000001);
HDebug.Assert(Math.Abs(dbg_FF) < 0.00000001);
}
{
ValueTuple <HessMatrix, Vector> BBInvDDCC_BBInvDDGG = Get_BInvDC_BInvDG_WithSqueeze
(C
, D
, nG
, process_disp_console: process_disp_console
, options: new string[0]
, thld_BinvDC: thres_zeroblk / lstNewIdxRemv.Length
, parallel: parallel
);
HessMatrix HH = A - BBInvDDCC_BBInvDDGG.Item1;
Vector FF = nF - BBInvDDCC_BBInvDDGG.Item2;
double dbg_HH = (HH - H).HAbsMax();
double dbg_FF = (FF - F).ToArray().MaxAbs();
HDebug.Assert(Math.Abs(dbg_HH) < 0.00000001);
HDebug.Assert(Math.Abs(dbg_FF) < 0.00000001);
}
GC.Collect();
}
HDebug.Assert(H.ColSize == H.RowSize);
HDebug.Assert(H.ColSize == F.Size);
return(new HessForcInfo
{
hess = H,
forc = F.ToVectors(3),
});
}
public static Mode[] GetModeByTorsional(HessMatrix hessian, Vector masses, Matrix J
, HPack <Matrix> optoutJMJ = null // J' M J
, HPack <Matrix> optoutJM = null // J' M
, Func <Matrix, Tuple <Matrix, Vector> > fnEigSymm = null
, Func <Matrix, Matrix, Matrix, Matrix> fnMul = null
)
{
string opt;
opt = "eig(JMJ^-1/2 * JHJ * JMJ^-1/2)";
//opt = "mwhess->tor->eig(H)->cart->mrmode";
if ((fnEigSymm != null) && (fnMul != null))
{
opt = "fn-" + opt;
}
switch (opt)
{
case "mwhess->tor->eig(H)->cart->mrmode":
/// http://www.lct.jussieu.fr/manuels/Gaussian03/g_whitepap/vib.htm
/// http://www.lct.jussieu.fr/manuels/Gaussian03/g_whitepap/vib/vib.pdf
/// does not work properly.
HDebug.Assert(false);
using (new Matlab.NamedLock("GetModeByTor"))
{
int n = J.ColSize;
int m = J.RowSize;
//Matrix M = massmat; // univ.GetMassMatrix(3);
Vector[] toreigvecs = new Vector[m];
Vector[] tormodes = new Vector[m];
double[] toreigvals = new double[m];
Mode[] modes = new Mode[m];
{
Matlab.Clear("GetModeByTor");
Matlab.PutMatrix("GetModeByTor.H", hessian);
Matlab.PutMatrix("GetModeByTor.J", J);
//Matlab.PutMatrix("GetModeByTor.M", M);
Matlab.PutVector("GetModeByTor.m", masses); // ex: m = [1,2,...,n]
Matlab.Execute("GetModeByTor.m3 = kron(GetModeByTor.m,[1;1;1]);"); // ex: m3 = [1,1,1,2,2,2,...,n,n,n]
Matlab.Execute("GetModeByTor.M = diag(GetModeByTor.m3);");
Matlab.Execute("GetModeByTor.m = diag(1 ./ sqrt(diag(GetModeByTor.M)));");
Matlab.Execute("GetModeByTor.mHm = GetModeByTor.m * GetModeByTor.H * GetModeByTor.m;");
Matlab.Execute("GetModeByTor.JmHmJ = GetModeByTor.J' * GetModeByTor.mHm * GetModeByTor.J;");
Matlab.Execute("[GetModeByTor.V, GetModeByTor.D] = eig(GetModeByTor.JmHmJ);");
Matlab.Execute("GetModeByTor.JV = GetModeByTor.m * GetModeByTor.J * GetModeByTor.V;");
Matrix V = Matlab.GetMatrix("GetModeByTor.V");
Vector D = Matlab.GetVector("diag(GetModeByTor.D)");
Matrix JV = Matlab.GetMatrix("GetModeByTor.JV");
Matlab.Clear("GetModeByTor");
for (int i = 0; i < m; i++)
{
toreigvecs[i] = V.GetColVector(i);
toreigvals[i] = D[i];
tormodes[i] = JV.GetColVector(i);
modes[i] = new Mode();
modes[i].eigval = toreigvals[i];
modes[i].eigvec = tormodes[i];
modes[i].th = i;
}
}
return(modes);
}
case "eig(JMJ^-1/2 * JHJ * JMJ^-1/2)":
/// Solve the problem of using eng(H,M).
///
/// eig(H,M) => H.v = M.v.l
/// H.(M^-1/2 . M^1/2).v = (M^1/2 . M^1/2).v.l
/// M^-1/2 . H.(M^-1/2 . M^1/2).v = M^1/2 .v.l
/// (M^-1/2 . H . M^-1/2) . (M^1/2.v) = (M^1/2.v).l
/// (M^-1/2 . H . M^-1/2) . w = w.l
/// where (M^1/2.v) = w
/// v = M^-1/2 . w
/// where M = V . D . V'
/// M^-1/2 = V . (1/sqrt(D)) . V'
/// M^-1/2 . M^-1/2 . M = (V . (1/sqrt(D)) . V') . (V . (1/sqrt(D)) . V') . (V . D . V')
/// = V . (1/sqrt(D)) . (1/sqrt(D)) . D . V'
/// = V . I . V'
/// = I
using (new Matlab.NamedLock("GetModeByTor"))
{
int n = J.ColSize;
int m = J.RowSize;
//Matrix M = massmat; // univ.GetMassMatrix(3);
Vector[] toreigvecs = new Vector[m];
Vector[] tormodes = new Vector[m];
double[] toreigvals = new double[m];
Mode[] modes = new Mode[m];
{
Matlab.Clear("GetModeByTor");
Matlab.PutMatrix("GetModeByTor.J", J.ToArray(), true);
//Matlab.PutMatrix("GetModeByTor.M", M , true);
//Matlab.PutMatrix("GetModeByTor.H", hessian, true);
Matlab.PutSparseMatrix("GetModeByTor.H", hessian.GetMatrixSparse(), 3, 3);
if (HDebug.IsDebuggerAttached && hessian.ColSize < 10000)
{
Matlab.PutMatrix("GetModeByTor.Htest", hessian.ToArray(), true);
double dHessErr = Matlab.GetValue("max(max(abs(GetModeByTor.H - GetModeByTor.Htest)))");
Matlab.Execute("clear GetModeByTor.Htest");
HDebug.Assert(dHessErr == 0);
}
Matlab.PutVector("GetModeByTor.m", masses); // ex: m = [1,2,...,n]
Matlab.Execute("GetModeByTor.m3 = kron(GetModeByTor.m,[1;1;1]);"); // ex: m3 = [1,1,1,2,2,2,...,n,n,n]
Matlab.Execute("GetModeByTor.M = diag(GetModeByTor.m3);");
Matlab.Execute("GetModeByTor.JMJ = GetModeByTor.J' * GetModeByTor.M * GetModeByTor.J;");
Matlab.Execute("GetModeByTor.JHJ = GetModeByTor.J' * GetModeByTor.H * GetModeByTor.J;");
Matlab.Execute("[GetModeByTor.V, GetModeByTor.D] = eig(GetModeByTor.JMJ);");
Matlab.Execute("GetModeByTor.jmj = GetModeByTor.V * diag(1 ./ sqrt(diag(GetModeByTor.D))) * GetModeByTor.V';"); // jmj = sqrt(JMJ)
//Matlab.Execute("max(max(abs(JMJ*jmj*jmj - eye(size(JMJ)))));"); // for checking
//Matlab.Execute("max(max(abs(jmj*JMJ*jmj - eye(size(JMJ)))));"); // for checking
//Matlab.Execute("max(max(abs(jmj*jmj*JMJ - eye(size(JMJ)))));"); // for checking
Matlab.Execute("[GetModeByTor.V, GetModeByTor.D] = eig(GetModeByTor.jmj * GetModeByTor.JHJ * GetModeByTor.jmj);");
Matlab.Execute("GetModeByTor.D = diag(GetModeByTor.D);");
Matlab.Execute("GetModeByTor.V = GetModeByTor.jmj * GetModeByTor.V;");
Matlab.Execute("GetModeByTor.JV = GetModeByTor.J * GetModeByTor.V;");
Matrix V = Matlab.GetMatrix("GetModeByTor.V", true);
Vector D = Matlab.GetVector("GetModeByTor.D");
Matrix JV = Matlab.GetMatrix("GetModeByTor.JV", true);
if (optoutJMJ != null)
{
optoutJMJ.value = Matlab.GetMatrix("GetModeByTor.JMJ", true);
}
if (optoutJM != null)
{
optoutJM.value = Matlab.GetMatrix("GetModeByTor.J' * GetModeByTor.M", true);
}
Matlab.Clear("GetModeByTor");
for (int i = 0; i < m; i++)
{
toreigvecs[i] = V.GetColVector(i);
toreigvals[i] = D[i];
tormodes[i] = JV.GetColVector(i);
modes[i] = new Mode();
modes[i].eigval = toreigvals[i];
modes[i].eigvec = tormodes[i];
modes[i].th = i;
}
}
return(modes);
}
case "fn-eig(JMJ^-1/2 * JHJ * JMJ^-1/2)":
/// Solve the problem of using eng(H,M).
///
/// eig(H,M) => H.v = M.v.l
/// H.(M^-1/2 . M^1/2).v = (M^1/2 . M^1/2).v.l
/// M^-1/2 . H.(M^-1/2 . M^1/2).v = M^1/2 .v.l
/// (M^-1/2 . H . M^-1/2) . (M^1/2.v) = (M^1/2.v).l
/// (M^-1/2 . H . M^-1/2) . w = w.l
/// where (M^1/2.v) = w
/// v = M^-1/2 . w
/// where M = V . D . V'
/// M^-1/2 = V . (1/sqrt(D)) . V'
/// M^-1/2 . M^-1/2 . M = (V . (1/sqrt(D)) . V') . (V . (1/sqrt(D)) . V') . (V . D . V')
/// = V . (1/sqrt(D)) . (1/sqrt(D)) . D . V'
/// = V . I . V'
/// = I
{
int n = J.ColSize;
int m = J.RowSize;
//Matrix M = massmat; // univ.GetMassMatrix(3);
Vector[] toreigvecs = new Vector[m];
Vector[] tormodes = new Vector[m];
double[] toreigvals = new double[m];
Mode[] modes = new Mode[m];
{
Matrix H = hessian; HDebug.Assert(hessian.ColSize == hessian.RowSize);
Matrix M = Matrix.Zeros(hessian.ColSize, hessian.RowSize); HDebug.Assert(3 * masses.Size == M.ColSize, M.ColSize == M.RowSize);
for (int i = 0; i < M.ColSize; i++)
{
M[i, i] = masses[i / 3];
}
Matrix Jt = J.Tr();
Matrix JMJ = fnMul(Jt, M, J); // JMJ = J' * M * J
Matrix JHJ = fnMul(Jt, H, J); // JHJ = J' * H * J
Matrix V; Vector D; { // [V, D] = eig(JMJ)
var VD = fnEigSymm(JMJ);
V = VD.Item1;
D = VD.Item2;
}
Matrix jmj; { // jmj = sqrt(JMJ)
Vector isD = new double[D.Size];
for (int i = 0; i < isD.Size; i++)
{
isD[i] = 1 / Math.Sqrt(D[i]);
}
jmj = fnMul(V, LinAlg.Diag(isD), V.Tr());
}
{ // [V, D] = eig(jmj * JHJ * jmj)
Matrix jmj_JHJ_jmj = fnMul(jmj, JHJ, jmj);
var VD = fnEigSymm(jmj_JHJ_jmj);
V = VD.Item1;
D = VD.Item2;
}
V = fnMul(jmj, V, null); // V = jmj * V
Matrix JV = fnMul(J, V, null); // JV = J * V
if (optoutJMJ != null)
{
optoutJMJ.value = JMJ;
}
if (optoutJM != null)
{
optoutJM.value = fnMul(Jt, M, null); // J' * M
}
for (int i = 0; i < m; i++)
{
toreigvecs[i] = V.GetColVector(i);
toreigvals[i] = D[i];
tormodes[i] = JV.GetColVector(i);
modes[i] = new Mode();
modes[i].eigval = toreigvals[i];
modes[i].eigvec = tormodes[i];
modes[i].th = i;
}
}
//if(Debug.IsDebuggerAttached)
//{
// Mode[] tmodes = GetModeByTorsional(hessian, masses, J);
// Debug.Assert(modes.Length == tmodes.Length);
// for(int i=0; i<modes.Length; i++)
// {
// Debug.AssertTolerance(0.00001, modes[i].eigval - tmodes[i].eigval);
// Debug.AssertTolerance(0.00001, modes[i].eigvec - tmodes[i].eigvec);
// }
//}
return(modes);
}
case "eig(JHJ,JMJ)":
/// Generalized eigendecomposition does not guarantee that the eigenvalue be normalized.
/// This becomes a problem when a B-factor (determined using eig(H,M)) is compared with another B-factor (determined using eig(M^-1/2 H M^-1/2)).
/// This problem is being solved using case "eig(JMJ^-1/2 * JHJ * JMJ^-1/2)"
using (new Matlab.NamedLock("GetModeByTor"))
{
int n = J.ColSize;
int m = J.RowSize;
//Matrix M = massmat; // univ.GetMassMatrix(3);
Matrix JMJ;
{
Matlab.PutMatrix("GetModeByTor.J", J);
//Matlab.PutMatrix("GetModeByTor.M", M);
Matlab.PutVector("GetModeByTor.m", masses); // ex: m = [1,2,...,n]
Matlab.Execute("GetModeByTor.m3 = kron(GetModeByTor.m,[1;1;1]);"); // ex: m3 = [1,1,1,2,2,2,...,n,n,n]
Matlab.Execute("GetModeByTor.M = diag(GetModeByTor.m3);");
Matlab.Execute("GetModeByTor.JMJ = GetModeByTor.J' * GetModeByTor.M * GetModeByTor.J;");
JMJ = Matlab.GetMatrix("GetModeByTor.JMJ");
Matlab.Clear("GetModeByTor");
}
Matrix JHJ;
{
Matlab.PutMatrix("GetModeByTor.J", J);
Matlab.PutMatrix("GetModeByTor.H", hessian);
Matlab.Execute("GetModeByTor.JHJ = GetModeByTor.J' * GetModeByTor.H * GetModeByTor.J;");
JHJ = Matlab.GetMatrix("GetModeByTor.JHJ");
Matlab.Clear("GetModeByTor");
}
Vector[] toreigvecs = new Vector[m];
Vector[] tormodes = new Vector[m];
double[] toreigvals = new double[m];
Mode[] modes = new Mode[m];
{
Matlab.PutMatrix("GetModeByTor.JHJ", JHJ);
Matlab.PutMatrix("GetModeByTor.JMJ", JMJ);
Matlab.PutMatrix("GetModeByTor.J", J);
Matlab.Execute("[GetModeByTor.V, GetModeByTor.D] = eig(GetModeByTor.JHJ, GetModeByTor.JMJ);");
Matlab.Execute("GetModeByTor.D = diag(GetModeByTor.D);");
Matlab.Execute("GetModeByTor.JV = GetModeByTor.J * GetModeByTor.V;");
Matrix V = Matlab.GetMatrix("GetModeByTor.V");
Vector D = Matlab.GetVector("GetModeByTor.D");
Matrix JV = Matlab.GetMatrix("GetModeByTor.JV");
Matlab.Clear("GetModeByTor");
for (int i = 0; i < m; i++)
{
toreigvecs[i] = V.GetColVector(i);
toreigvals[i] = D[i];
tormodes[i] = JV.GetColVector(i);
modes[i] = new Mode();
modes[i].eigval = toreigvals[i];
modes[i].eigvec = tormodes[i];
modes[i].th = i;
}
}
return(modes);
}
}
return(null);
}
public static TorEigen[] GetEigenTorsional(HessMatrix hessian, Vector masses, Matrix J)
{
int n = J.ColSize;
int m = J.RowSize;
//Matrix M = massmat; // univ.GetMassMatrix(3);
Matrix JMJ;
using (new Matlab.NamedLock("GetModeByTor"))
{
Matlab.PutMatrix("GetModeByTor.J", J);
//Matlab.PutMatrix("GetModeByTor.M", M);
Matlab.PutVector("GetModeByTor.m", masses); // ex: m = [1,2,...,n]
Matlab.Execute("GetModeByTor.m3 = kron(GetModeByTor.m,[1;1;1]);"); // ex: m3 = [1,1,1,2,2,2,...,n,n,n]
Matlab.Execute("GetModeByTor.M = diag(GetModeByTor.m3);");
Matlab.Execute("GetModeByTor.JMJ = GetModeByTor.J' * GetModeByTor.M * GetModeByTor.J;");
JMJ = Matlab.GetMatrix("GetModeByTor.JMJ");
Matlab.Clear("GetModeByTor");
}
Matrix JHJ;
using (new Matlab.NamedLock("GetModeByTor"))
{
Matlab.PutMatrix("GetModeByTor.J", J);
Matlab.PutMatrix("GetModeByTor.H", hessian);
Matlab.Execute("GetModeByTor.JHJ = GetModeByTor.J' * GetModeByTor.H * GetModeByTor.J;");
JHJ = Matlab.GetMatrix("GetModeByTor.JHJ");
Matlab.Clear("GetModeByTor");
}
TorEigen[] toreigens = new TorEigen[m];
using (new Matlab.NamedLock("GetModeByTor"))
{
Matlab.PutMatrix("GetModeByTor.JHJ", JHJ);
Matlab.PutMatrix("GetModeByTor.JMJ", JMJ);
Matlab.PutMatrix("GetModeByTor.J", J);
Matlab.Execute("[GetModeByTor.V, GetModeByTor.D] = eig(GetModeByTor.JHJ, GetModeByTor.JMJ);");
Matlab.Execute("GetModeByTor.D = diag(GetModeByTor.D);");
Matrix V = Matlab.GetMatrix("GetModeByTor.V");
Vector D = Matlab.GetVector("GetModeByTor.D");
Matlab.Clear("GetModeByTor");
for (int i = 0; i < m; i++)
{
toreigens[i] = new TorEigen();
toreigens[i].th = i;
toreigens[i].eigval = D[i];
toreigens[i].eigvec = V.GetColVector(i);
}
}
if (HDebug.IsDebuggerAttached)
{
Mode[] modes0 = GetModeByTorsional(hessian, masses, J);
Mode[] modes1 = GetModeByTorsional(toreigens, J);
HDebug.Assert(modes0.Length == modes1.Length);
for (int i = 0; i < modes1.Length; i++)
{
HDebug.Assert(modes0[i].th == modes1[i].th);
HDebug.AssertTolerance(0.000000001, modes0[i].eigval - modes1[i].eigval);
HDebug.AssertTolerance(0.000000001, modes0[i].eigvec - modes1[i].eigvec);
}
}
return(toreigens);
}
public static Mode[] PCA(Matrix cov, int numconfs, Func <Matrix, Tuple <Matrix, Vector> > fnEig = null)
{
HDebug.Assert(cov.RowSize == cov.ColSize);
int size3 = cov.ColSize;
if (fnEig == null)
{
fnEig = delegate(Matrix A)
{
using (new Matlab.NamedLock("TEST"))
{
Matlab.Clear("TEST");
Matlab.PutMatrix("TEST.H", A);
Matlab.Execute("TEST.H = (TEST.H + TEST.H')/2;");
Matlab.Execute("[TEST.V, TEST.D] = eig(TEST.H);");
Matlab.Execute("TEST.D = diag(TEST.D);");
//Matlab.Execute("TEST.idx = find(TEST.D>0.00000001);");
//Matrix leigvecs = Matlab.GetMatrix("TEST.V(:,TEST.idx)");
//Vector leigvals = Matlab.GetVector("TEST.D(TEST.idx)");
Matrix leigvecs = Matlab.GetMatrix("TEST.V");
Vector leigvals = Matlab.GetVector("TEST.D");
Matlab.Clear("TEST");
return(new Tuple <Matrix, Vector>(leigvecs, leigvals));
}
}
}
;
Tuple <Matrix, Vector> eigs = fnEig(cov);
Matrix eigvecs = eigs.Item1;
Vector eigvals = eigs.Item2;
HDebug.Assert(eigvecs.ColSize == size3, eigvals.Size == eigvecs.RowSize);
Mode[] modes = new Mode[eigvals.Size];
for (int im = 0; im < modes.Length; im++)
{
modes[im] = new Mode
{
eigvec = eigvecs.GetColVector(im),
eigval = 1.0 / eigvals[im],
th = im
}
}
;
int maxNumEigval = Math.Min(numconfs - 1, size3);
HDebug.Assert(maxNumEigval >= 0);
HDebug.Assert(eigvals.Size == size3);
if (maxNumEigval < size3)
{
modes = modes.SortByEigvalAbs().ToArray();
modes = modes.Take(maxNumEigval).ToArray();
foreach (var mode in modes)
{
HDebug.Assert(mode.eigval >= 0);
}
//Tuple<Mode[], Mode[]> nzmodes_zeromodes = modes.SeparateTolerants();
//Mode[] modesNonzero = nzmodes_zeromodes.Item1;
//Mode[] modesZero = nzmodes_zeromodes.Item2;
//modes = modesZero;
}
HDebug.Assert(modes.Length == maxNumEigval);
return(modes);
}