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 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 HessInfoCoarseResiIter GetHessCoarseResiIter
(Hess.HessInfo hessinfo
, Vector[] coords
, FuncGetIdxKeepListRemv GetIdxKeepListRemv
, ILinAlg ila
, double thres_zeroblk = 0.001
, IterOption iteropt = IterOption.Matlab_experimental
, string[] options = null
)
{
bool rediag = true;
HessMatrix H = null;
List <int>[] lstNewIdxRemv = null;
int numca = 0;
double[] reMass = null;
object[] reAtoms = null;
Vector[] reCoords = null;
Tuple <int[], int[][]> idxKeepRemv = null;
//System.Console.WriteLine("begin re-indexing hess");
{
object[] atoms = hessinfo.atoms;
idxKeepRemv = GetIdxKeepListRemv(atoms, coords);
int[] idxKeep = idxKeepRemv.Item1;
int[][] idxsRemv = idxKeepRemv.Item2;
{
List <int> check = new List <int>();
check.AddRange(idxKeep);
foreach (int[] idxRemv in idxsRemv)
{
check.AddRange(idxRemv);
}
check = check.HToHashSet().ToList();
if (check.Count != coords.Length)
{
throw new Exception("the re-index contains the duplicated atoms or the missing atoms");
}
}
List <int> idxs = new List <int>();
idxs.AddRange(idxKeep);
foreach (int[] idxRemv in idxsRemv)
{
idxs.AddRange(idxRemv);
}
HDebug.Assert(idxs.Count == idxs.HToHashSet().Count);
H = hessinfo.hess.ReshapeByAtom(idxs);
numca = idxKeep.Length;
reMass = hessinfo.mass.ToArray().HSelectByIndex(idxs);
reAtoms = hessinfo.atoms.ToArray().HSelectByIndex(idxs);
reCoords = coords.HSelectByIndex(idxs);
int nidx = idxKeep.Length;
lstNewIdxRemv = new List <int> [idxsRemv.Length];
for (int i = 0; i < idxsRemv.Length; i++)
{
lstNewIdxRemv[i] = new List <int>();
foreach (var idx in idxsRemv[i])
{
lstNewIdxRemv[i].Add(nidx);
nidx++;
}
}
HDebug.Assert(nidx == lstNewIdxRemv.Last().Last() + 1);
HDebug.Assert(nidx == idxs.Count);
}
GC.Collect(0);
HDebug.Assert(numca == H.ColBlockSize - lstNewIdxRemv.HListCount().Sum());
//if(bool.Parse("false"))
{
if (bool.Parse("false"))
#region
{
int[] idxKeep = idxKeepRemv.Item1;
int[][] idxsRemv = idxKeepRemv.Item2;
Pdb.Atom[] pdbatoms = hessinfo.atomsAsUniverseAtom.ListPdbAtoms();
Pdb.ToFile(@"C:\temp\coarse-keeps.pdb", pdbatoms.HSelectByIndex(idxKeep), false);
if (HFile.Exists(@"C:\temp\coarse-graining.pdb"))
{
HFile.Delete(@"C:\temp\coarse-graining.pdb");
}
foreach (int[] idxremv in idxsRemv.Reverse())
{
List <Pdb.Element> delatoms = new List <Pdb.Element>();
foreach (int idx in idxremv)
{
if (pdbatoms[idx] == null)
{
continue;
}
string line = pdbatoms[idx].GetUpdatedLine(coords[idx]);
Pdb.Atom delatom = Pdb.Atom.FromString(line);
delatoms.Add(delatom);
}
Pdb.ToFile(@"C:\temp\coarse-graining.pdb", delatoms.ToArray(), true);
}
}
#endregion
if (bool.Parse("false"))
#region
{
// export matrix to matlab, so the matrix can be checked in there.
int[] idxca = HEnum.HEnumCount(numca).ToArray();
int[] idxoth = HEnum.HEnumFromTo(numca, coords.Length - 1).ToArray();
Matlab.Register(@"C:\temp\");
Matlab.PutSparseMatrix("H", H.GetMatrixSparse(), 3, 3);
Matlab.Execute("figure; spy(H)");
Matlab.Clear();
}
#endregion
if (bool.Parse("false"))
#region
{
HDirectory.CreateDirectory(@"K:\temp\$coarse-graining\");
{ // export original hessian matrix
List <int> cs = new List <int>();
List <int> rs = new List <int>();
foreach (ValueTuple <int, int, MatrixByArr> bc_br_bval in hessinfo.hess.EnumBlocks())
{
cs.Add(bc_br_bval.Item1);
rs.Add(bc_br_bval.Item2);
}
Matlab.Clear();
Matlab.PutVector("cs", cs.ToArray());
Matlab.PutVector("rs", rs.ToArray());
Matlab.Execute("hess = sparse(cs+1, rs+1, ones(size(cs)));");
Matlab.Execute("hess = float(hess);");
Matlab.Execute("figure; spy(hess)");
Matlab.Execute("cs = int32(cs+1);");
Matlab.Execute("rs = int32(rs+1);");
Matlab.Execute(@"save('K:\temp\$coarse-graining\hess-original.mat', 'cs', 'rs', '-v6');");
Matlab.Clear();
}
{ // export reshuffled hessian matrix
List <int> cs = new List <int>();
List <int> rs = new List <int>();
foreach (ValueTuple <int, int, MatrixByArr> bc_br_bval in H.EnumBlocks())
{
cs.Add(bc_br_bval.Item1);
rs.Add(bc_br_bval.Item2);
}
Matlab.Clear();
Matlab.PutVector("cs", cs.ToArray());
Matlab.PutVector("rs", rs.ToArray());
Matlab.Execute("H = sparse(cs+1, rs+1, ones(size(cs)));");
Matlab.Execute("H = float(H);");
Matlab.Execute("figure; spy(H)");
Matlab.Execute("cs = int32(cs+1);");
Matlab.Execute("rs = int32(rs+1);");
Matlab.Execute(@"save('K:\temp\$coarse-graining\hess-reshuffled.mat', 'cs', 'rs', '-v6');");
Matlab.Clear();
}
}
#endregion
if (bool.Parse("false"))
#region
{
int[] idxca = HEnum.HEnumCount(numca).ToArray();
int[] idxoth = HEnum.HEnumFromTo(numca, coords.Length - 1).ToArray();
HessMatrix A = H.SubMatrixByAtoms(false, idxca, idxca);
HessMatrix B = H.SubMatrixByAtoms(false, idxca, idxoth);
HessMatrix C = H.SubMatrixByAtoms(false, idxoth, idxca);
HessMatrix D = H.SubMatrixByAtoms(false, idxoth, idxoth);
Matlab.Clear();
Matlab.PutSparseMatrix("A", A.GetMatrixSparse(), 3, 3);
Matlab.PutSparseMatrix("B", B.GetMatrixSparse(), 3, 3);
Matlab.PutSparseMatrix("C", C.GetMatrixSparse(), 3, 3);
Matlab.PutSparseMatrix("D", D.GetMatrixSparse(), 3, 3);
Matlab.Clear();
}
#endregion
}
List <HessCoarseResiIterInfo> iterinfos = null;
{
object[] atoms = reAtoms; // reAtoms.HToType(null as Universe.Atom[]);
CGetHessCoarseResiIterImpl info = null;
switch (iteropt)
{
case IterOption.ILinAlg_20150329: info = GetHessCoarseResiIterImpl_ILinAlg_20150329(H, lstNewIdxRemv, thres_zeroblk, ila, false); break;
case IterOption.ILinAlg: info = GetHessCoarseResiIterImpl_ILinAlg(H, lstNewIdxRemv, thres_zeroblk, ila, false); break;
case IterOption.Matlab: info = GetHessCoarseResiIterImpl_Matlab(atoms, H, lstNewIdxRemv, thres_zeroblk, ila, false, options); break;
case IterOption.Matlab_experimental: info = GetHessCoarseResiIterImpl_Matlab_experimental(atoms, H, lstNewIdxRemv, thres_zeroblk, ila, false, options); break;
case IterOption.Matlab_IterLowerTri: info = GetHessCoarseResiIterImpl_Matlab_IterLowerTri(atoms, H, lstNewIdxRemv, thres_zeroblk, ila, false, options); break;
case IterOption.LinAlg_IterLowerTri: info = GetHessCoarseResiIterImpl_LinAlg_IterLowerTri.Do(atoms, H, lstNewIdxRemv, thres_zeroblk, ila, false, options); break;
}
;
H = info.H;
iterinfos = info.iterinfos;
}
//{
// var info = GetHessCoarseResiIterImpl_Matlab(H, lstNewIdxRemv, thres_zeroblk);
// H = info.H;
//}
GC.Collect(0);
if (HDebug.IsDebuggerAttached)
{
int nidx = 0;
int[] ikeep = idxKeepRemv.Item1;
foreach (int idx in ikeep)
{
bool equal = object.ReferenceEquals(hessinfo.atoms[idx], reAtoms[nidx]);
if (equal == false)
{
HDebug.Assert(false);
}
HDebug.Assert(equal);
nidx++;
}
}
if (rediag)
{
H = H.CorrectHessDiag();
}
//System.Console.WriteLine("finish fixing diag");
return(new HessInfoCoarseResiIter
{
hess = H,
mass = reMass.HSelectCount(numca),
atoms = reAtoms.HSelectCount(numca),
coords = reCoords.HSelectCount(numca),
numZeroEigval = 6,
iterinfos = iterinfos,
});
}
public static CGetHessCoarseResiIterImpl GetHessCoarseResiIterImpl_Matlab(HessMatrix H, List <int>[] lstNewIdxRemv, double thres_zeroblk)
{
HessMatrix CGH = null;
List <HessCoarseResiIterInfo> iterinfos = new List <HessCoarseResiIterInfo>();
using (new Matlab.NamedLock("CGHessIter"))
{
Matlab.PutSparseMatrix("CG.H", H.GetMatrixSparse(), 3, 3);
Matlab.PutValue("CG.th", thres_zeroblk);
Matlab.PutValue("CG.iter", lstNewIdxRemv.Length);
for (int iter = lstNewIdxRemv.Length - 1; iter >= 0; iter--)
{
int[] iremv = lstNewIdxRemv[iter].ToArray();
int[] idxkeep = HEnum.HEnumFromTo(0, iremv.Min() - 1).ToArray();
int[] idxremv = HEnum.HEnumFromTo(iremv.Min(), iremv.Max()).ToArray();
Matlab.PutVector("CG.idxkeep", idxkeep);
Matlab.PutVector("CG.idxremv", idxremv);
Matlab.Execute("CG.idxkeep = sort([CG.idxkeep*3+1; CG.idxkeep*3+2; CG.idxkeep*3+3]);");
Matlab.Execute("CG.idxremv = sort([CG.idxremv*3+1; CG.idxremv*3+2; CG.idxremv*3+3]);");
HessCoarseResiIterInfo iterinfo = new HessCoarseResiIterInfo();
iterinfo.sizeHessBlkMat = idxremv.Max() + 1; // H.ColBlockSize;
iterinfo.numAtomsRemoved = idxremv.Length;
iterinfo.idxkeep = idxkeep.HClone();
iterinfo.idxremv = idxremv.HClone();
iterinfo.time0 = DateTime.UtcNow;
if (HDebug.IsDebuggerAttached)
{
int maxkeep = Matlab.GetValueInt("max(CG.idxkeep)");
int minremv = Matlab.GetValueInt("min(CG.idxremv)");
HDebug.Assert(maxkeep + 1 == minremv);
int maxremv = Matlab.GetValueInt("max(CG.idxremv)");
int Hsize = Matlab.GetValueInt("max(size(CG.H))");
HDebug.Assert(Hsize == maxremv);
int idxsize = Matlab.GetValueInt("length(union(CG.idxkeep,CG.idxremv))");
HDebug.Assert(Hsize == idxsize);
}
Matlab.Execute("CG.A = CG.H(CG.idxkeep, CG.idxkeep);");
Matlab.Execute("CG.B = CG.H(CG.idxkeep, CG.idxremv);");
//Matlab.Execute("CG.C = CG.H(CG.idxremv, CG.idxkeep);");
Matlab.Execute("CG.D = CG.H(CG.idxremv, CG.idxremv);");
HDebug.Assert(false);
Matlab.Execute("CG.B(abs(CG.B) < CG.th) = 0;"); /// matlab cannot handle this call. Matlab try to use 20G memory.
Matlab.Execute("CG.BDC = CG.B * inv(full(CG.D)) * CG.B';");
Matlab.Execute("CG.BDC = sparse(CG.BDC);");
Matlab.Execute("CG.BDC(abs(CG.BDC) < (CG.th / CG.iter)) = 0;");
Matlab.Execute("CG.H = CG.A - sparse(CG.BDC);");
iterinfo.numSetZeroBlock = -1;
iterinfo.numNonZeroBlock = -1;
iterinfo.numAddIgnrBlock = -1;
iterinfo.usedMemoryByte = -1;
iterinfo.time1 = DateTime.UtcNow;
iterinfos.Add(iterinfo);
System.Console.WriteLine(" - {0:000} : makezero {1,5}, nonzero {2,5}, numIgnMul {3,7}, numRemvAtoms {4,3}, {5,5:0.00} sec, {6} mb, {7}x{7}"
, iter
, iterinfo.numSetZeroBlock
, iterinfo.numNonZeroBlock
, iterinfo.numAddIgnrBlock
, iterinfo.numAtomsRemoved
, iterinfo.compSec
, iterinfo.usedMemoryByte / (1024 * 1024)
, (idxkeep.Length * 3)
);
}
Matrix CG_H = Matlab.GetMatrix("CG.H");
CGH = new HessMatrixDense {
hess = CG_H
};
}
return(new CGetHessCoarseResiIterImpl
{
iterinfos = iterinfos,
H = CGH,
});
}
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 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 HessMatrixDense GetHessCoarseBlkmat(HessMatrix hess, IList <int> idx_heavy, string invopt = "inv")
{
/// Hess = [ HH HL ] = [ A B ]
/// [ LH LL ] [ C D ]
///
/// Hess_HH = HH - HL * LL^-1 * LH
/// = A - B * D^-1 * C
Matrix hess_HH;
using (new Matlab.NamedLock(""))
{
Matlab.Clear();
if (hess is HessMatrixSparse)
{
Matlab.PutSparseMatrix("H", hess.GetMatrixSparse(), 3, 3);
}
else
{
Matlab.PutMatrix("H", hess, true);
}
Matlab.Execute("H = (H + H')/2;");
int[] idx0 = new int[idx_heavy.Count * 3];
for (int i = 0; i < idx_heavy.Count; i++)
{
idx0[i * 3 + 0] = idx_heavy[i] * 3 + 0;
idx0[i * 3 + 1] = idx_heavy[i] * 3 + 1;
idx0[i * 3 + 2] = idx_heavy[i] * 3 + 2;
}
Matlab.PutVector("idx0", idx0);
Matlab.Execute("idx0 = idx0+1;");
Matlab.PutValue("idx1", hess.ColSize);
Matlab.Execute("idx1 = setdiff(1:idx1, idx0)';");
HDebug.Assert(Matlab.GetValueInt("length(union(idx0,idx1))") == hess.ColSize);
Matlab.Execute("A = full(H(idx0,idx0));");
Matlab.Execute("B = H(idx0,idx1) ;");
Matlab.Execute("C = H(idx1,idx0) ;");
Matlab.Execute("D = full(H(idx1,idx1));");
Matlab.Execute("clear H;");
object linvopt = null;
switch (invopt)
{
case "B/D":
Matlab.Execute("bhess = A -(B / D)* C;");
break;
case "inv":
Matlab.Execute("D = inv(D);");
Matlab.Execute("bhess = A - B * D * C;");
break;
case "pinv":
Matlab.Execute("D = pinv(D);");
Matlab.Execute("bhess = A - B * D * C;");
break;
case "_eig":
bool bCheckInv = false;
if (bCheckInv)
{
Matlab.Execute("Dbak = D;");
}
Matlab.Execute("[D,DD] = eig(D);");
if (HDebug.False)
{
Matlab.Execute("DD(abs(DD)<" + linvopt + ") = 0;");
Matlab.Execute("DD = pinv(DD);");
}
else
{
Matlab.Execute("DD = diag(DD);");
Matlab.Execute("DDidx = abs(DD)<" + linvopt + ";");
Matlab.Execute("DD = 1./DD;");
Matlab.Execute("DD(DDidx) = 0;");
Matlab.Execute("DD = diag(DD);");
Matlab.Execute("clear DDidx;");
}
Matlab.Execute("D = D * DD * D';");
if (bCheckInv)
{
double err0 = Matlab.GetValue("max(max(abs(eye(size(D)) - Dbak * D)))");
}
if (bCheckInv)
{
double err1 = Matlab.GetValue("max(max(abs(eye(size(D)) - D * Dbak)))");
}
if (bCheckInv)
{
Matlab.Execute("clear Dbak;");
}
Matlab.Execute("clear DD;");
Matlab.Execute("bhess = A - B * D * C;");
break;
default:
{
if (invopt.StartsWith("eig(threshold:") && invopt.EndsWith(")"))
{
// ex: "eig(threshold:0.000000001)"
linvopt = invopt.Replace("eig(threshold:", "").Replace(")", "");
linvopt = double.Parse(linvopt as string);
goto case "_eig";
}
}
throw new HException();
}
Matlab.Execute("clear A; clear B; clear C; clear D;");
Matlab.Execute("bhess = (bhess + bhess')/2;");
hess_HH = Matlab.GetMatrix("bhess", Matrix.Zeros, true);
Matlab.Clear();
}
return(new HessMatrixDense {
hess = hess_HH
});
}
