//public static OOverlapWeighted OverlapWeightedByFreq(IList<Mode> modes1, IList<Mode> modes2, ILinAlg ila, bool bResetUnitVector, string optSelectOverlap)
//{
// Vector weights = new double[modes1.Count];
// for(int i=0; i<weights.Size; i++)
// weights[i] = 1/Math.Sqrt(Math.Abs(modes1[i].eigval));
// weights /= weights.Sum();
//
// return OverlapWeighted(modes1, modes2, weights.ToArray(), ila, bResetUnitVector, optSelectOverlap);
//}
public static OOverlapWeighted OverlapWeighted(IList <Mode> modes1, double[] mass1, double[] mass2, IList <Mode> modes2, IList <double> weights, ILinAlg ila, bool bResetUnitVector, string optSelectOverlap)
{
Matrix soverlap = OverlapSigned(modes1, mass1, mass2, modes2, ila, bResetUnitVector);
HDebug.Exception(modes1.Count == weights.Count);
int[] idxOverlap1to2;
switch (optSelectOverlap)
{
case "corresponding index":
if (modes1.Count != modes2.Count)
{
throw new HException();
}
idxOverlap1to2 = HEnum.HEnumCount(modes1.Count).ToArray();
break;
case "best matching overlap":
idxOverlap1to2 = new int[modes1.Count];
for (int im = 0; im < modes1.Count; im++)
{
idxOverlap1to2[im] = 0;
for (int k = 0; k < modes2.Count; k++)
{
if (Math.Abs(soverlap[im, idxOverlap1to2[im]]) < Math.Abs(soverlap[im, k]))
{
idxOverlap1to2[im] = k;
}
}
}
break;
default:
throw new HException();
}
Vector overlap1to2 = new double[modes1.Count];
Vector overlap1to2signed = new double[modes1.Count];
double woverlap = 0;
for (int i = 0; i < modes1.Count; i++)
{
overlap1to2 [i] = Math.Abs(soverlap[i, idxOverlap1to2[i]]);
overlap1to2signed[i] = soverlap[i, idxOverlap1to2[i]];
woverlap += weights[i] * overlap1to2[i];
}
return(new OOverlapWeighted
{
soverlap1to2 = soverlap,
woverlap = woverlap,
weights = weights.ToArray(),
overlaps = overlap1to2.ToArray(),
sgnoverlaps = overlap1to2signed.ToArray(),
idxOverlap1to2 = idxOverlap1to2,
modes1 = modes1.ToArray(),
modes2 = modes2.ToArray(),
});
}
// Constructor for Moving Objects
public HBackground(HEnum.BackgroundTyp pType, String pTextureName, String pPfad, Vector2 pXAxis, Vector2 pYAxis, int pAmount, float pSpeed)
{
this.Initialize("", Vector2.Zero, pTextureName, pPfad);
_type = pType;
_xRange = pXAxis;
_yRange = pYAxis;
_cloudAmount = pAmount;
_cloudSpeed = pSpeed;
}
public void Rotate(HEnum._direction direction, HEnum.GeometryTyp pType)
{
//if (direction.HasFlag(HEnum._direction.Left))
if (HateEngine.Input.HKeyboard.isMoveLeft || (direction.HasFlag(HEnum._direction.Left) && pType == HEnum.GeometryTyp.Viereck))
_rotation -= _rotationSpeed;
//else if (direction.HasFlag(HEnum._direction.Right))
else if (HateEngine.Input.HKeyboard.isMoveRight || (direction.HasFlag(HEnum._direction.Right) && pType == HEnum.GeometryTyp.Viereck))
_rotation += _rotationSpeed;
if (_rotation > 360)
_rotation = 0;
}
static void Main()
{
//exe
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
//控制台
bool b = EnumUse1.D >= EnumUse1.A;
Console.WriteLine(b.ToString());
Show(EnumUse2.E);
HEnum.ForEach((x) => Console.WriteLine("{0} = {1},", x, (int)x));
}
public static Vector[] GetTrans(Vector[] coords, Vector cent, int[] block)
{
int leng = coords.Length;
Vector[] transx = new Vector[leng];
Vector[] transy = new Vector[leng];
Vector[] transz = new Vector[leng];
Vector zeros = new double[3];
for (int i = 0; i < leng; i++)
{
transx[i] = transy[i] = transz[i] = zeros;
}
Vector dx = new double[3] {
1, 0, 0
};
Vector dy = new double[3] {
0, 1, 0
};
Vector dz = new double[3] {
0, 0, 1
};
IEnumerable <int> enumblock = block;
if (block != null)
{
enumblock = block;
}
else
{
enumblock = HEnum.HEnumCount(leng);
}
foreach (int i in enumblock)
{
transx[i] = dx;
transy[i] = dy;
transz[i] = dz;
}
Vector[] trans = new Vector[3]
{
transx.ToVector().UnitVector(),
transy.ToVector().UnitVector(),
transz.ToVector().UnitVector(),
};
return(trans);
}
public static Tuple <Sheet[], Atom[]>[] HSelectAtoms <Atom>(this IList <Sheet> sheets, IList <Atom> atoms)
where Atom : IAtom
{
var chain_resi_atoms = atoms.GroupChainIDResSeq();
var id_sheets = sheets.HGroupBySheetID();
List <Tuple <Sheet[], Atom[]> > list = new List <Tuple <Sheet[], Atom[]> >();
foreach (string id in id_sheets.Keys)
{
Sheet[] idsheets = id_sheets[id];
List <Atom> idsheets_atoms = new List <Atom>();
foreach (var sheet in idsheets)
{
HDebug.Exception(sheet.initChainID == sheet.endChainID);
char chain = sheet.initChainID;
if (chain_resi_atoms.ContainsKey(chain) == false)
{
continue;
}
var chainresi_atoms = chain_resi_atoms[chain];
int[] resis;
resis = new int[] { sheet.initSeqNum, sheet.endSeqNum };
resis = resis.HSort();
resis = HEnum.HEnumFromTo(resis[0], resis[1]).ToArray();
foreach (var resi in resis)
{
if (chainresi_atoms.ContainsKey(resi) == false)
{
continue;
}
idsheets_atoms.AddRange(chainresi_atoms[resi]);
}
}
list.Add(new Tuple <Sheet[], Atom[]>
(
idsheets,
idsheets_atoms.ToArray()
));
}
return(list.ToArray());
}
public void ChangeForm(HEnum.GeometryTyp pType)
{
State = pType;
switch (State)
{
case HEnum.GeometryTyp.Strich: SetMultiplyer(1.0f, 0.6f);
_rotationSpeed = 10;
break;
case HEnum.GeometryTyp.Viereck: SetMultiplyer(1.0f, 0.7f); //(0.85f, 0.7f)
_rotationSpeed = 3;
break;
case HEnum.GeometryTyp.Sechseck: SetMultiplyer(1.0f, 1.0f);
_rotationSpeed = 10;
break;
case HEnum.GeometryTyp.Kreis: SetMultiplyer(1.0f, 1.0f);
_rotationSpeed = 10;
break;
}
}
public static MixHessInfo GetHessMixModel(Universe univ, IList <Vector> coords, ILinAlg la
, IList <ResInfo> lstResAllAtom, FnGetHess GetHess, out string errmsg
, bool bGetIntmInfo, string strBkbnReso
)
{
FnGetHess lGetHess = delegate(Universe luniv, IList <Vector> lcoords, int[] lidxAll, int[] lidxBuffer, int[] lidxCoarse, int[] idxBackbone)
{
// double check if all three indices are disjoint
HDebug.Assert(lidxAll.HUnion().Length == lidxAll.Length);
HDebug.Assert(lidxBuffer.HUnion().Length == lidxBuffer.Length);
HDebug.Assert(lidxCoarse.HUnion().Length == lidxCoarse.Length);
HDebug.Assert(lidxAll.HListCommonT(lidxBuffer).Count == 0);
HDebug.Assert(lidxBuffer.HListCommonT(lidxCoarse).Count == 0);
HDebug.Assert(lidxCoarse.HListCommonT(lidxAll).Count == 0);
if (HDebug.IsDebuggerAttached)
{
foreach (int idx in lidxAll)
{
HDebug.Assert(lcoords[idx] != null);
}
foreach (int idx in lidxBuffer)
{
HDebug.Assert(lcoords[idx] != null);
}
foreach (int idx in lidxCoarse)
{
HDebug.Assert(lcoords[idx] != null);
}
}
var hessinfo = GetHess(luniv, lcoords, lidxAll, lidxBuffer, lidxCoarse, idxBackbone);
return(hessinfo);
};
bool bVerifySteps = false; // HDebug.IsDebuggerAttached;
Vector bfactorFull = null;
if (bVerifySteps && HDebug.IsDebuggerAttached)
{
int[] idxAll = HEnum.HEnumCount(coords.Count).ToArray();
var hessinfo = lGetHess(univ, coords, idxAll, new int[0], new int[0], new int[0]);
var modes = hessinfo.GetModesMassReduced();
var modesPosZero = modes.SeparateTolerants();
HDebug.Assert(modesPosZero.Item2.Length == 6);
bfactorFull = modesPosZero.Item1.GetBFactor().ToArray();
}
IList <Pdb.Atom> pdbatoms = univ.atoms.ListPdbAtoms();
ResInfo[] resinfos = pdbatoms.ListResInfo(true);
int[] idxCa; // idxs of Ca atoms
int[] idxBkbn; // idxs of backbone atoms
int[] idxSele; // idxs of all atoms of lstResAllAtom (selected)
int[] idxCntk; // idxs of all atoms contacting idxSele
{
string[] nameBkbn;
switch (strBkbnReso)
{
case "NCaC": nameBkbn = new string[] { "N", "CA", "C" }; break;
case "NCaC-O": nameBkbn = new string[] { "N", "CA", "C", "O" }; break;
case "NCaC-OHn": nameBkbn = new string[] { "N", "CA", "C", "O", "HN" }; break;
case "NCaC-O-Ha": nameBkbn = new string[] { "N", "CA", "C", "O", "HA" }; break;
case "NCaC-OHn-HaCb": nameBkbn = new string[] { "N", "CA", "C", "O", "HN", "HA", "CB" }; break;
default: throw new NotImplementedException();
}
idxCa = univ.atoms.ListPdbAtoms().IdxByName(true, "CA");
//idxBkbn = univ.atoms.ListPdbAtoms().IdxByName(true, "N", "CA", "C", "O", "HA");
idxBkbn = univ.atoms.ListPdbAtoms().IdxByName(true, nameBkbn);
idxSele = resinfos.HIdxEqual(ResInfo.Equals, lstResAllAtom.ToArray());
Vector[] coordSele = coords.HSelectByIndex(idxSele);
int[] idxCtof = coords.HIdxWithinCutoff(4.5, coordSele);
ResInfo[] resCtof = resinfos.HSelectByIndex(idxCtof);
resCtof = resCtof.HUnion(); // remove redundant residues
resCtof = resCtof.HRemoveAll(lstResAllAtom.ToArray()).ToArray(); // remove active site residues
idxCntk = resinfos.HIdxEqual(ResInfo.Equals, resCtof);
bool plot = false;
if (plot)
#region verify by plotting
{
Pdb.ToFile(@"C:\temp\mix.pdb", pdbatoms, coords);
Pymol.Py.CgoOld.WriteBlank(@"C:\temp\mix.py", false);
Pymol.Py.CgoOld.WriteSphere(@"C:\temp\mix.py", "Ca", coords.HSelectByIndex(idxCa).HRemoveAllNull(), 0.3);
Pymol.Py.CgoOld.WriteSphere(@"C:\temp\mix.py", "backbone", coords.HSelectByIndex(idxBkbn).HRemoveAllNull(), 0.3);
Pymol.Py.CgoOld.WriteSphere(@"C:\temp\mix.py", "active", coordSele.HRemoveAllNull()
, 0.3
, red: 1, green: 0, blue: 0);
Pymol.Py.CgoOld.WriteSphere(@"C:\temp\mix.py", "connect", coords.HSelectByIndex(idxCntk).HRemoveAllNull()
, 0.3
, red: 0, green: 0, blue: 1);
HFile.WriteAllLines(@"C:\temp\mix.pml", new string[]
{
"load mix.pdb",
"run mix.py",
"reset",
});
}
#endregion
}
//idxBkbn = HEnum.HSequence(coords.Count).ToArray();
int[] idxFull = idxSele.HUnionWith(idxCntk).HUnionWith(idxBkbn);
Vector[] coordsFull = coords.HCopyIdx(idxFull, null);
var hessinfoFull = lGetHess(univ, coordsFull
, idxAll: idxSele
, idxBuffer: idxCntk.HRemoveAll(idxSele)
, idxCoarse: idxBkbn.HRemoveAll(idxSele).HRemoveAll(idxCntk)
, idxBackbone: idxBkbn
);
HDebug.Assert(hessinfoFull.hess.IsComputable() == false);
//{
// var modes = hessinfoFull.GetModesMassReduced(false, la);
// var modesPosZero = modes.SeparateTolerants();
// Vector bf = modesPosZero.Item1.GetBFactor().ToArray();
// Vector nma = ext as Vector;
// double corr = BFactor.Corr(bf, nma);
//}
var hessinfoSub = hessinfoFull.GetSubHessInfo(idxFull);
HDebug.Assert(hessinfoSub.hess.IsComputable() == true);
if (HDebug.IsDebuggerAttached)
{
Mode[] lmodes = hessinfoSub.GetModesMassReduced();
if (lmodes.SeparateTolerants().Item2.Length != 6)
{
HDebug.Assert(false);
//throw new Exception();
}
}
if (bVerifySteps && HDebug.IsDebuggerAttached)
{
var modes = hessinfoSub.GetModesMassReduced();
var modesPosZero = modes.SeparateTolerants();
Vector bf0 = modesPosZero.Item1.GetBFactor().ToArray();
Vector bf = new double[coords.Count]; bf.SetValue(double.NaN);
for (int i = 0; i < idxFull.Length; i++)
{
bf[idxFull[i]] = bf0[i];
}
int[] idxCax = idxCa.HRemoveAll(idxSele).HRemoveAll(idxCntk);
double corr = HBioinfo.BFactor.Corr(bf, bfactorFull, idxFull);
double corrCa = HBioinfo.BFactor.Corr(bf, bfactorFull, idxCa);
double corrCax = HBioinfo.BFactor.Corr(bf, bfactorFull, idxCax);
double corrBkbn = HBioinfo.BFactor.Corr(bf, bfactorFull, idxBkbn);
double corrSele = HBioinfo.BFactor.Corr(bf, bfactorFull, idxSele);
double corrCntk = HBioinfo.BFactor.Corr(bf, bfactorFull, idxCntk);
}
int[] idxMix;
{
Universe.Atom[] mixAtoms = hessinfoSub.atoms.HToType <object, Universe.Atom>();
Pdb.Atom[] mixPdbAtoms = mixAtoms.ListPdbAtoms();
ResInfo[] mixResinfos = mixPdbAtoms.ListResInfo(true);
int[] mixIdxCa = mixPdbAtoms.IdxByName(true, "CA");
int[] mixIdxSele = mixResinfos.HIdxEqual(ResInfo.Equals, lstResAllAtom.ToArray());
idxMix = mixIdxCa.HUnionWith(mixIdxSele).HSort();
}
HessMatrix hessMix = Hess.GetHessCoarseBlkmat(hessinfoSub.hess, idxMix, la);
if (hessMix.IsComputable() == false)
{
// hessSub (=hessinfoSub.hess) is computable, but hessMix become in-computable.
// This happens when 1. hessSub=[A,B;C,D] has more then 6 zero eigenvalues,
// 2. the D matrix become singular,
// 3. inv(D) is incomputable
// 4. "A - B inv(D) C" becomes incomputable.
errmsg = "hess(Sele,Cntk,Bkbn)->hess(Sele,Ca) becomes incomputable";
return(null);
}
MixHessInfo hessinfoMix = new MixHessInfo
{
hess = hessMix,
mass = hessinfoSub.mass.ToArray().HSelectByIndex(idxMix),
atoms = hessinfoSub.atoms.ToArray().HSelectByIndex(idxMix),
coords = hessinfoSub.coords.ToArray().HSelectByIndex(idxMix),
numZeroEigval = 6,
};
if (bGetIntmInfo)
{
hessinfoMix.intmHessinfoAllMidBkbn = hessinfoSub;
hessinfoMix.intmAtomCa = univ.atoms.ToArray().HSelectByIndex(idxCa);
hessinfoMix.intmAtomAll = univ.atoms.ToArray().HSelectByIndex(idxSele);
hessinfoMix.intmAtomMid = univ.atoms.ToArray().HSelectByIndex(idxCntk);
hessinfoMix.intmAtomBkbn = univ.atoms.ToArray().HSelectByIndex(idxBkbn);
}
if (HDebug.IsDebuggerAttached)
{
Mode[] lmodes = hessinfoMix.GetModesMassReduced();
if (lmodes.SeparateTolerants().Item2.Length != 6)
{
throw new Exception();
}
}
if (bVerifySteps && HDebug.IsDebuggerAttached)
{
var modes = hessinfoMix.GetModesMassReduced();
var modesPosZero = modes.SeparateTolerants();
Vector bf0 = modesPosZero.Item1.GetBFactor().ToArray();
Vector bf = new double[coords.Count]; bf.SetValue(double.NaN);
for (int i = 0; i < idxMix.Length; i++)
{
bf[idxFull[idxMix[i]]] = bf0[i];
}
int[] idxCax = idxCa.HRemoveAll(idxSele).HRemoveAll(idxCntk);
double corr = HBioinfo.BFactor.Corr(bf, bfactorFull, true);
double corrCa = HBioinfo.BFactor.Corr(bf, bfactorFull, idxCa);
double corrCax = HBioinfo.BFactor.Corr(bf, bfactorFull, idxCax);
double corrBkbn = HBioinfo.BFactor.Corr(bf, bfactorFull, idxBkbn);
double corrSele = HBioinfo.BFactor.Corr(bf, bfactorFull, idxSele);
double corrCntk = HBioinfo.BFactor.Corr(bf, bfactorFull, idxCntk);
}
errmsg = null;
return(hessinfoMix);
}
public static CGetHessCoarseResiIterImpl GetHessCoarseResiIterImpl_Matlab_IterLowerTri
(object[] atoms
, HessMatrix H
, List <int>[] lstNewIdxRemv
, double thres_zeroblk
, ILinAlg ila
, bool cloneH
, string[] options // { "pinv(D)" }
)
{
ila = null;
if (cloneH)
{
H = H.CloneHess();
}
bool process_disp_console = true;
if (options != null && options.Contains("print process"))
{
process_disp_console = true;
}
bool parallel = true;
/// keep only lower triangle of H (lower block triangles)
{
HashSet <Tuple <int, int, MatrixByArr> > lstUppTrig = new HashSet <Tuple <int, int, MatrixByArr> >();
foreach (ValueTuple <int, int, MatrixByArr> bc_br_bval in H.EnumBlocks())
{
int bc = bc_br_bval.Item1;
int br = bc_br_bval.Item2;
if (bc < br)
{
lstUppTrig.Add(bc_br_bval.ToTuple());
}
}
foreach (Tuple <int, int, MatrixByArr> bc_br_bval in lstUppTrig)
{
int bc = bc_br_bval.Item1;
int br = bc_br_bval.Item2;
HDebug.Assert(bc < br);
H.SetBlock(bc, br, null);
}
}
GC.Collect();
List <DateTime> process_time = new List <DateTime>();
//System.Console.WriteLine("begin coarse-graining");
List <HessCoarseResiIterInfo> iterinfos = new List <HessCoarseResiIterInfo>();
for (int iter = lstNewIdxRemv.Length - 1; iter >= 0; iter--)
{
process_time.Clear();
if (process_disp_console)
{
process_time.Add(DateTime.UtcNow);
System.Console.Write(" - {0:000} : ", 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);
HessCoarseResiIterInfo iterinfo = new HessCoarseResiIterInfo();
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; // HessMatrix A = H.SubMatrixByAtoms(false, idxkeep, idxkeep);
// HessMatrix B = H.SubMatrixByAtoms(false, idxkeep, idxremv);
HessMatrix C; // HessMatrix C = H.SubMatrixByAtoms(false, idxremv, idxkeep, parallel:parallel);
HessMatrix D; // HessMatrix D = H.SubMatrixByAtoms(false, idxremv, idxremv, parallel:parallel);
{
C = H.Zeros(idxremv.Length * 3, idxkeep.Length * 3);
D = H.Zeros(idxremv.Length * 3, idxremv.Length * 3);
//List<Tuple<int, int, MatrixByArr>> lst_bc_br_bval = H.EnumBlocksInCols(idxremv).ToList();
//foreach(var bc_br_bval in lst_bc_br_bval)
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;
H.SetBlock(bc, br, null);
if (bc > iremv_max)
{
HDebug.Assert(false); continue;
}
if (br > iremv_max)
{
HDebug.Assert(false); continue;
}
if (br < iremv_min)
{
int nc = bc - iremv_min;
int nr = br;
HDebug.Assert(C.HasBlock(nc, nr) == false);
C.SetBlock(nc, nr, bval.CloneT());
}
else
{
int nc = bc - iremv_min;
int nr = br - iremv_min;
HDebug.Assert(D.HasBlock(nc, nr) == false);
D.SetBlock(nc, nr, bval);
if (nc != nr)
{
HDebug.Assert(D.HasBlock(nr, nc) == false);
D.SetBlock(nr, nc, bval.Tr());
}
}
}
HDebug.Assert(H.EnumBlocksInCols(idxremv).Count() == 0);
}
if (process_disp_console)
{
process_time.Add(DateTime.UtcNow);
int ptc = process_time.Count;
System.Console.Write("CD({0:00.00} min), ", (process_time[ptc - 1] - process_time[ptc - 2]).TotalMinutes);
}
////////////////////////////////////////////////////////////////////////////////////////
// Get B.inv(D).C
HessMatrix B_invD_C;
{
{
B_invD_C = GetHessCoarseResiIterImpl_Matlab_IterLowerTri_Get_BInvDC(A, C, D, process_disp_console
, options
, thld_BinvDC: thres_zeroblk / lstNewIdxRemv.Length
, parallel: parallel
);
}
if (process_disp_console)
{
process_time.Add(DateTime.UtcNow);
int ptc = process_time.Count;
System.Console.Write("B.invD.C({0:00.00} min), ", (process_time[ptc - 1] - process_time[ptc - 2]).TotalMinutes);
}
GC.Collect(0);
}
////////////////////////////////////////////////////////////////////////////////////////
// Get A - B.inv(D).C
/// iterinfo.numAddIgnrBlock = A.UpdateAdd(B_invD_C, -1, null, thres_zeroblk/lstNewIdxRemv.Length, parallel:parallel);
{
HessMatrix __this = A;
HessMatrix other = B_invD_C;
double _thres_NearZeroBlock = thres_zeroblk / lstNewIdxRemv.Length;
int[] _count = new int[1];
int[] _count_ignored = new int[1];
//foreach(var bc_br_bval in other.EnumBlocks())
Action <ValueTuple <int, int, MatrixByArr> > func = delegate(ValueTuple <int, int, MatrixByArr> bc_br_bval)
{
_count[0]++;
int bc = bc_br_bval.Item1;
int br = bc_br_bval.Item2;
MatrixByArr other_bmat = bc_br_bval.Item3;
if (bc < br)
{
return; // continue;
}
if (other_bmat.HAbsMax() <= _thres_NearZeroBlock)
{
/// other_bmat = other_bmat -other_bmat;
/// other_diag = other_diag - (-other_bmat) = other_diag + other_bmat;
/// this_diag = this_diat - B_invD_C
/// = this_diat - other_diag
/// = this_diat - (other_diag + other_bmat)
/// = this_diat - other_diag - other_bmat
/// = (this_diat - other_bmat) - other_diag
/// = (this_diat - other_bmat) - (processed later)
/// = (this_diat - other_bmat)
MatrixByArr this_diag = __this.GetBlock(bc, bc);
MatrixByArr new_diag = this_diag - other_bmat;
__this.SetBlockLock(bc, bc, new_diag);
other_bmat = null;
lock (_count_ignored)
_count_ignored[0]++;
}
if (other_bmat != null)
{
MatrixByArr this_bmat = __this.GetBlock(bc, br);
if (this_bmat == null)
{
this_bmat = new double[3, 3];
}
MatrixByArr new_bmat = this_bmat - other_bmat;
__this.SetBlockLock(bc, br, new_bmat);
}
};
if (parallel)
{
HParallel.ForEach(other.EnumBlocks(), func);
}
else
{
foreach (var bc_br_bval in other.EnumBlocks())
{
func(bc_br_bval);
}
}
iterinfo.numAddIgnrBlock = _count_ignored[0];
}
if (process_disp_console)
{
process_time.Add(DateTime.UtcNow);
int ptc = process_time.Count;
System.Console.Write("A-BinvDC({0:00.00} min), ", (process_time[ptc - 1] - process_time[ptc - 2]).TotalMinutes);
}
//HessMatrix nH = A - B_invD_C;
//nH = ((nH + nH.Tr())/2).ToHessMatrix();
////////////////////////////////////////////////////////////////////////////////////////
// Replace A -> H
H = A;
////////////////////////////////////////////////////////////////////////////////////////
// print iteration log
iterinfo.usedMemoryByte = GC.GetTotalMemory(false);
iterinfo.time1 = DateTime.UtcNow;
iterinfos.Add(iterinfo);
if (process_disp_console)
{
System.Console.Write("summary(makezero {0,5}, nonzero {1,5}, numIgnMul {2,7}, numRemvAtoms {3,3}, {4,5:0.00} min, {5} mb, {6}x{6}, nzeroBlk/Atom {7:0.00}), GC("
, iterinfo.numSetZeroBlock
, iterinfo.numNonZeroBlock
, iterinfo.numAddIgnrBlock
, iterinfo.numAtomsRemoved
, iterinfo.compTime.TotalMinutes
, iterinfo.usedMemoryByte / (1024 * 1024)
, (idxkeep.Length * 3)
, ((double)iterinfo.numNonZeroBlock / idxremv.Length)
);
}
GC.Collect();
if (process_disp_console)
{
System.Console.WriteLine(")");
}
}
int numca = H.ColBlockSize - lstNewIdxRemv.HListCount().Sum();
//System.Console.WriteLine("finish coarse-graining");
{
int[] idxkeep = HEnum.HEnumCount(numca).ToArray();
H = H.SubMatrixByAtoms(false, idxkeep, idxkeep, false);
}
{
H.MakeNearZeroBlockAsZero(thres_zeroblk);
}
GC.Collect();
//System.Console.WriteLine("finish resizing");
return(new CGetHessCoarseResiIterImpl
{
iterinfos = iterinfos,
H = H,
});
}
static void Show(HEnum e)
{
Console.WriteLine(@"{0} = {1},""{2}""", e, (int)e, e.ToString());
}
public static CGetHessCoarseResiIterImpl GetHessCoarseResiIterImpl_ILinAlg_20150329(HessMatrix H, List <int>[] lstNewIdxRemv, double thres_zeroblk, ILinAlg ila, bool cloneH)
{
if (cloneH)
{
H = H.CloneHess();
}
//System.Console.WriteLine("begin coarse-graining");
List <HessCoarseResiIterInfo> iterinfos = new List <HessCoarseResiIterInfo>();
for (int iter = lstNewIdxRemv.Length - 1; iter >= 0; iter--)
{
//int[] ikeep = lstNewIdxRemv[iter].Item1;
int[] iremv = lstNewIdxRemv[iter].ToArray();
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);
HessCoarseResiIterInfo iterinfo = new HessCoarseResiIterInfo();
iterinfo.sizeHessBlkMat = idxremv.Max() + 1; // H.ColBlockSize;
iterinfo.numAtomsRemoved = idxremv.Length;
iterinfo.time0 = DateTime.UtcNow;
{
//HessMatrix A = H.SubMatrixByAtoms(false, idxkeep, idxkeep);
HessMatrix A = H;
//HessMatrix B = H.SubMatrixByAtoms(false, idxkeep, idxremv);
HessMatrix C = H.SubMatrixByAtoms(false, idxremv, idxkeep);
HessMatrix D = H.SubMatrixByAtoms(false, idxremv, idxremv);
HessMatrix invD = new HessMatrixDense {
hess = ila.InvSymm(D)
};
// make B,C sparse
//int B_cntzero = B.MakeNearZeroBlockAsZero(thres_zeroblk);
iterinfo.numSetZeroBlock = C.MakeNearZeroBlockAsZero(thres_zeroblk);
//int B_nzeros = B.NumUsedBlocks; double B_nzeros_ = Math.Sqrt(B_nzeros);
iterinfo.numNonZeroBlock = C.NumUsedBlocks;
HessMatrix B = C.Tr();
HessMatrix B_invD_C = B * invD * C;
iterinfo.numAddIgnrBlock = A.UpdateAdd(B_invD_C, -1, null, thres_zeroblk / lstNewIdxRemv.Length);
//HessMatrix nH = A - B_invD_C;
//nH = ((nH + nH.Tr())/2).ToHessMatrix();
H = A;
}
iterinfo.usedMemoryByte = GC.GetTotalMemory(false);
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)
// );
GC.Collect();
}
int numca = H.ColBlockSize - lstNewIdxRemv.HListCount().Sum();
//System.Console.WriteLine("finish coarse-graining");
{
int[] idxkeep = HEnum.HEnumCount(numca).ToArray();
H = H.SubMatrixByAtoms(false, idxkeep, idxkeep, false);
}
{
H.MakeNearZeroBlockAsZero(thres_zeroblk);
}
GC.Collect();
//System.Console.WriteLine("finish resizing");
return(new CGetHessCoarseResiIterImpl
{
iterinfos = iterinfos,
H = H,
});
}
public static CGetHessCoarseResiIterImpl Do
(object[] atoms
, HessMatrix H
, List <int>[] lstNewIdxRemv
, double thres_zeroblk
, ILinAlg ila
, bool cloneH
, string[] options
)
{
//HDebug.ToDo();
ila = null;
cloneH = true;
if (cloneH)
{
H = H.CloneHess();
}
bool process_disp_console = true;
if (options != null && options.Contains("print process"))
{
process_disp_console = true;
}
bool parallel = false;
/// keep only lower triangle of H (lower block triangles)
{
HashSet <Tuple <int, int, MatrixByArr> > lstUppTrig = new HashSet <Tuple <int, int, MatrixByArr> >();
foreach (ValueTuple <int, int, MatrixByArr> bc_br_bval in H.EnumBlocks())
{
int bc = bc_br_bval.Item1;
int br = bc_br_bval.Item2;
if (bc < br)
{
lstUppTrig.Add(bc_br_bval.ToTuple());
}
}
foreach (Tuple <int, int, MatrixByArr> bc_br_bval in lstUppTrig)
{
int bc = bc_br_bval.Item1;
int br = bc_br_bval.Item2;
HDebug.Assert(bc < br);
H.SetBlock(bc, br, null);
}
}
GC.Collect();
DateTime[] process_time = new DateTime[6];
//System.Console.WriteLine("begin coarse-graining");
List <HessCoarseResiIterInfo> iterinfos = new List <HessCoarseResiIterInfo>();
for (int iter = lstNewIdxRemv.Length - 1; iter >= 0; iter--)
{
bool lprocess_disp_console = (process_disp_console && iter % 5 == 0);
lprocess_disp_console = true;
if (lprocess_disp_console)
{
process_time[0] = DateTime.UtcNow;
System.Console.Write(" - {0:000} : ", iter);
}
//int[] ikeep = lstNewIdxRemv[iter].Item1;
HessCoarseResiIterInfo iterinfo = new HessCoarseResiIterInfo();
iterinfo.sizeHessBlkMat = 1;
iterinfo.numAtomsRemoved = 1;
iterinfo.time0 = DateTime.UtcNow;
int _count_update = 0;
{
HDebug.Assert(lstNewIdxRemv[iter].Count == 1);
int iremv = lstNewIdxRemv[iter][0];
HessMatrix A = H;
MatrixByArr D = null;
double D_absmin = 0;
List <int> C_lstbr = new List <int>();
List <MatrixByArr> C_lstbval = new List <MatrixByArr>();
{
// get C and D
foreach (var(bc, br, bval) in H.EnumBlocksInCols(new int[] { iremv }))
{
HDebug.Assert(iremv == bc);
if (bc == br)
{
HDebug.Assert(D == null);
D = bval;
D_absmin = D.HAbsMin();
}
else
{
if (bval.HAbsMin() >= thres_zeroblk)
{
C_lstbr.Add(br);
C_lstbval.Add(bval);
}
}
}
// remove C and D
{
int bc = iremv;
H.SetBlock(bc, bc, null);
foreach (int br in C_lstbr)
{
H.SetBlock(bc, br, null);
}
}
}
if (lprocess_disp_console)
{
process_time[1] = process_time[2] = DateTime.UtcNow;
System.Console.Write("CD({0:00.00} min), ", (process_time[2] - process_time[0]).TotalMinutes);
}
double threshold = thres_zeroblk / lstNewIdxRemv.Length;
// DD ={ { d00,d01,d02},{ d10,d11,d12},{ d20,d21,d22} }; MatrixForm[DD]
// BB ={ { b00,b01,b02},{ b10,b11,b12},{ b20,b21,b22} }; MatrixForm[BB]
// CC ={ { c00,c01,c02},{ c10,c11,c12},{ c20,c21,c22} }; MatrixForm[CC]
// object[] dbginfo = null; // new object[] { iremv, atoms, H, D, C_lstbr, C_lstbval };
Action <ValueTuple <int, int, MatrixByArr, MatrixByArr> > Update_A_B_invD_C = delegate(ValueTuple <int, int, MatrixByArr, MatrixByArr> info)
{
int bc = info.Item1; // bc
int br = info.Item2; // br
MatrixByArr DC = info.Item3; // invDD_CC // XX ={ { x00,x01,x02},{ x10,x11,x12},{ x20,x21,x22} }; MatrixForm[CC]
MatrixByArr B = info.Item4; // BB // BB ={ { b00,b01,b02},{ b10,b11,b12},{ b20,b21,b22} }; MatrixForm[BB]
//var _iremv = (int)dbginfo[0];
//var _atoms = dbginfo[1] as Universe.Atom[] ;
//var _H = dbginfo[2] as HessMatrix ;
//var _D = dbginfo[3] as MatrixByArr ;
//var _C_lstbr = dbginfo[4] as List<int> ;
//var _C_lstbval = dbginfo[5] as List<MatrixByArr>;
//MatrixByArr BB_invDD_CC = BB * invDD_CC;
double _BDC00 = 0 - B[0, 0] * DC[0, 0] - B[0, 1] * DC[1, 0] - B[0, 2] * DC[2, 0]; // { { b00 x00 +b01 x10 + b02 x20
double _BDC01 = 0 - B[0, 0] * DC[0, 1] - B[0, 1] * DC[1, 1] - B[0, 2] * DC[2, 1]; // , b00 x01 +b01 x11 + b02 x21
double _BDC02 = 0 - B[0, 0] * DC[0, 2] - B[0, 1] * DC[1, 2] - B[0, 2] * DC[2, 2]; // , b00 x02 +b01 x12 + b02 x22
double _BDC10 = 0 - B[1, 0] * DC[0, 0] - B[1, 1] * DC[1, 0] - B[1, 2] * DC[2, 0]; // },{ b10 x00 +b11 x10 + b12 x20
double _BDC11 = 0 - B[1, 0] * DC[0, 1] - B[1, 1] * DC[1, 1] - B[1, 2] * DC[2, 1]; // , b10 x01 +b11 x11 + b12 x21
double _BDC12 = 0 - B[1, 0] * DC[0, 2] - B[1, 1] * DC[1, 2] - B[1, 2] * DC[2, 2]; // , b10 x02 +b11 x12 + b12 x22
double _BDC20 = 0 - B[2, 0] * DC[0, 0] - B[2, 1] * DC[1, 0] - B[2, 2] * DC[2, 0]; // },{ b20 x00 +b21 x10 + b22 x20
double _BDC21 = 0 - B[2, 0] * DC[0, 1] - B[2, 1] * DC[1, 1] - B[2, 2] * DC[2, 1]; // , b20 x01 +b21 x11 + b22 x21
double _BDC22 = 0 - B[2, 0] * DC[0, 2] - B[2, 1] * DC[1, 2] - B[2, 2] * DC[2, 2]; // , b20 x02 +b21 x12 + b22 x22 }}
if (A.HasBlockLock(bc, br))
{
MatrixByArr A_bc_br = A.GetBlockLock(bc, br);
A_bc_br[0, 0] += _BDC00; // A = A + (-B.invD.C)
A_bc_br[0, 1] += _BDC01; // A = A + (-B.invD.C)
A_bc_br[0, 2] += _BDC02; // A = A + (-B.invD.C)
A_bc_br[1, 0] += _BDC10; // A = A + (-B.invD.C)
A_bc_br[1, 1] += _BDC11; // A = A + (-B.invD.C)
A_bc_br[1, 2] += _BDC12; // A = A + (-B.invD.C)
A_bc_br[2, 0] += _BDC20; // A = A + (-B.invD.C)
A_bc_br[2, 1] += _BDC21; // A = A + (-B.invD.C)
A_bc_br[2, 2] += _BDC22; // A = A + (-B.invD.C)
// (small && small && small) == !(large || large || large)
bool toosmall = !(Math.Abs(A_bc_br[0, 0]) > threshold || Math.Abs(A_bc_br[0, 1]) > threshold || Math.Abs(A_bc_br[0, 2]) > threshold ||
Math.Abs(A_bc_br[1, 0]) > threshold || Math.Abs(A_bc_br[1, 1]) > threshold || Math.Abs(A_bc_br[1, 2]) > threshold ||
Math.Abs(A_bc_br[2, 0]) > threshold || Math.Abs(A_bc_br[2, 1]) > threshold || Math.Abs(A_bc_br[2, 2]) > threshold);
if (toosmall)
{
HDebug.Assert(bc != br);
A.SetBlockLock(bc, br, null);
}
}
else
{
// (small && small && small) == !(large || large || large)
bool toosmall = !(Math.Abs(_BDC00) > threshold || Math.Abs(_BDC01) > threshold || Math.Abs(_BDC02) > threshold ||
Math.Abs(_BDC10) > threshold || Math.Abs(_BDC11) > threshold || Math.Abs(_BDC12) > threshold ||
Math.Abs(_BDC20) > threshold || Math.Abs(_BDC21) > threshold || Math.Abs(_BDC22) > threshold);
if (!toosmall)
{
MatrixByArr A_bc_br = new double[3, 3]
{
{ _BDC00, _BDC01, _BDC02 } // A = 0 + (-B.invD.C)
, { _BDC10, _BDC11, _BDC12 } // A = 0 + (-B.invD.C)
, { _BDC20, _BDC21, _BDC22 } // A = 0 + (-B.invD.C)
};
A.SetBlockLock(bc, br, A_bc_br);
}
}
System.Threading.Interlocked.Increment(ref _count_update);
};
var lstCompInfo = EnumComput(D, C_lstbr, C_lstbval, threshold);
if (parallel)
{
Parallel.ForEach(lstCompInfo, Update_A_B_invD_C);
}
else
{
foreach (var info in lstCompInfo)
{
Update_A_B_invD_C(info);
}
}
//GC.Collect(0);
if (lprocess_disp_console)
{
process_time[4] = DateTime.UtcNow;
System.Console.Write("B.invD.C({0:00.00} min), ", (process_time[4] - process_time[3]).TotalMinutes);
}
H = A;
}
iterinfo.usedMemoryByte = GC.GetTotalMemory(false);
iterinfo.time1 = DateTime.UtcNow;
iterinfos.Add(iterinfo);
if (lprocess_disp_console)
{
System.Console.WriteLine("summary(makezero {0,5}, nonzero {1,5}, numIgnMul {2,7}, numRemvAtoms {3,3}, {4,5:0.00} sec, {5} mb, {6}x{6}, nzeroBlk/Atom {7:0.00}, cntUpdateBlk({8}))"
, iterinfo.numSetZeroBlock
, iterinfo.numNonZeroBlock
, iterinfo.numAddIgnrBlock
, iterinfo.numAtomsRemoved
, iterinfo.compSec
, iterinfo.usedMemoryByte / (1024 * 1024)
, (0 * 3)
, 0//((double)iterinfo.numNonZeroBlock / idxremv.Length)
, _count_update
);
}
}
int numca = H.ColBlockSize - lstNewIdxRemv.HListCount().Sum();
//System.Console.WriteLine("finish coarse-graining");
{
int[] idxkeep = HEnum.HEnumCount(numca).ToArray();
H = H.SubMatrixByAtoms(false, idxkeep, idxkeep, false);
}
{
H.MakeNearZeroBlockAsZero(thres_zeroblk);
}
GC.Collect(0);
//System.Console.WriteLine("finish resizing");
return(new CGetHessCoarseResiIterImpl
{
iterinfos = iterinfos,
H = H,
});
}
public int UpdateAdd(HessMatrix other, double mul_other, IList <int> idxOther, double thres_NearZeroBlock, bool parallel = false)
{
Matrix debug_updateadd = null;
if (UpdateAdd_SelfTest && idxOther == null && thres_NearZeroBlock == 0)
{
if ((100 < ColBlockSize) && (ColBlockSize < 1000) &&
(100 < RowBlockSize) && (RowBlockSize < 1000) &&
(other.NumUsedBlocks > 20))
{
UpdateAdd_SelfTest = false;
debug_updateadd = this.ToArray();
debug_updateadd.UpdateAdd(other, mul_other);
}
}
int[] idx_other;
if (idxOther == null)
{
//HDebug.Exception(ColSize == other.ColSize);
//HDebug.Exception(RowSize == other.RowSize);
idx_other = HEnum.HEnumCount(other.ColSize).ToArray();
}
else
{
idx_other = idxOther.ToArray();
}
int count = 0;
int count_ignored = 0;
object _lock = new object();
object _lock_ignored = new object();
Action <ValueTuple <int, int, MatrixByArr> > func = delegate(ValueTuple <int, int, MatrixByArr> bc_br_bval)
{
count++;
int other_bc = bc_br_bval.Item1;
int other_br = bc_br_bval.Item2;
MatrixByArr other_bmat = bc_br_bval.Item3;
if (other_bmat.HAbsMax() <= thres_NearZeroBlock)
{
lock (_lock_ignored)
count_ignored++;
//continue;
return;
}
int bc = idx_other[other_bc];
int br = idx_other[other_br];
lock (_lock)
{
MatrixByArr this_bmat = GetBlock(bc, br);
MatrixByArr new_bmat;
if (this_bmat == null)
{
if (other_bmat == null)
{
new_bmat = null;
}
else
{
new_bmat = mul_other * other_bmat;
}
}
else
{
if (other_bmat == null)
{
new_bmat = this_bmat.CloneT();
}
else
{
new_bmat = this_bmat + mul_other * other_bmat;
}
}
SetBlock(bc, br, new_bmat);
}
};
if (parallel)
{
Parallel.ForEach(other.EnumBlocks(), func);
}
else
{
foreach (var bc_br_bval in other.EnumBlocks())
{
func(bc_br_bval);
}
}
if (debug_updateadd != null)
{
Matrix debug_diff = debug_updateadd - this;
double debug_absmax = debug_diff.HAbsMax();
HDebug.AssertToleranceMatrix(0, debug_diff);
}
return(count_ignored);
}
public static CGetHessCoarseResiIterImpl GetHessCoarseResiIterImpl_ILinAlg(HessMatrix H, List <int>[] lstNewIdxRemv, double thres_zeroblk, ILinAlg ila, bool cloneH)
{
if (cloneH)
{
H = H.CloneHess();
}
bool process_disp_console = true;
DateTime[] process_time = new DateTime[7];
//System.Console.WriteLine("begin coarse-graining");
List <HessCoarseResiIterInfo> iterinfos = new List <HessCoarseResiIterInfo>();
for (int iter = lstNewIdxRemv.Length - 1; iter >= 0; iter--)
{
if (process_disp_console)
{
process_time[0] = DateTime.UtcNow; System.Console.Write(" - {0:000} : ", iter);
}
//int[] ikeep = lstNewIdxRemv[iter].Item1;
int[] iremv = lstNewIdxRemv[iter].ToArray();
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);
HessCoarseResiIterInfo iterinfo = new HessCoarseResiIterInfo();
iterinfo.sizeHessBlkMat = idxremv.Max() + 1; // H.ColBlockSize;
iterinfo.numAtomsRemoved = idxremv.Length;
iterinfo.time0 = DateTime.UtcNow;
double C_density0 = double.NaN;
double C_density1 = double.NaN;
{
//HessMatrix A = H.SubMatrixByAtoms(false, idxkeep, idxkeep);
HessMatrix A = H;
//HessMatrix B = H.SubMatrixByAtoms(false, idxkeep, idxremv);
HessMatrix C = H.SubMatrixByAtoms(false, idxremv, idxkeep); if (process_disp_console)
{
process_time[1] = DateTime.UtcNow; System.Console.Write("C({0:00.00} min), ", (process_time[1] - process_time[0]).TotalMinutes);
}
HessMatrix D = H.SubMatrixByAtoms(false, idxremv, idxremv); if (process_disp_console)
{
process_time[2] = DateTime.UtcNow; System.Console.Write("D({0:00.00} min), ", (process_time[2] - process_time[1]).TotalMinutes);
}
HessMatrix invD = new HessMatrixDense {
hess = ila.InvSymm(D)
}; if (process_disp_console)
{
process_time[3] = DateTime.UtcNow; System.Console.Write("invD({0:00.00} min), ", (process_time[3] - process_time[2]).TotalMinutes);
}
// make B,C sparse
//int B_cntzero = B.MakeNearZeroBlockAsZero(thres_zeroblk);
C_density0 = C.RatioUsedBlocks;
iterinfo.numSetZeroBlock = C.MakeNearZeroBlockAsZero(thres_zeroblk); if (process_disp_console)
{
process_time[4] = DateTime.UtcNow; System.Console.Write("sparseC({0:00.00} min), ", (process_time[4] - process_time[3]).TotalMinutes);
}
//int B_nzeros = B.NumUsedBlocks; double B_nzeros_ = Math.Sqrt(B_nzeros);
iterinfo.numNonZeroBlock = C.NumUsedBlocks;
C_density1 = C.RatioUsedBlocks;
HessMatrix B = C.Tr();
HessMatrix B_invD_C = HessMatrix.GetMul(ila, B, invD, C); /* B * invD * C;*/ if (process_disp_console)
{
process_time[5] = DateTime.UtcNow; System.Console.Write("B.invD.C({0:00.00} min), ", (process_time[5] - process_time[4]).TotalMinutes);
}
iterinfo.numAddIgnrBlock = A.UpdateAdd(B_invD_C, -1, null, thres_zeroblk / lstNewIdxRemv.Length); if (process_disp_console)
{
process_time[6] = DateTime.UtcNow; System.Console.Write("A+BinvDC({0:00.00} min), ", (process_time[6] - process_time[5]).TotalMinutes);
}
//HessMatrix nH = A - B_invD_C;
//nH = ((nH + nH.Tr())/2).ToHessMatrix();
H = A;
}
iterinfo.usedMemoryByte = GC.GetTotalMemory(false);
iterinfo.time1 = DateTime.UtcNow;
iterinfos.Add(iterinfo);
if (process_disp_console)
{
System.Console.WriteLine("summary(makezero {0,5}, nonzero {1,5}, numIgnMul {2,7}, numRemvAtoms {3,3}, {4,5:0.00} sec, {5} mb, {6}x{6}, nzeroBlk/Atom {7:0.00})"
, iterinfo.numSetZeroBlock
, iterinfo.numNonZeroBlock
, iterinfo.numAddIgnrBlock
, iterinfo.numAtomsRemoved
, iterinfo.compSec
, iterinfo.usedMemoryByte / (1024 * 1024)
, (idxkeep.Length * 3)
, ((double)iterinfo.numNonZeroBlock / idxremv.Length)
);
}
GC.Collect(0);
}
int numca = H.ColBlockSize - lstNewIdxRemv.HListCount().Sum();
//System.Console.WriteLine("finish coarse-graining");
{
int[] idxkeep = HEnum.HEnumCount(numca).ToArray();
H = H.SubMatrixByAtoms(false, idxkeep, idxkeep, false);
}
{
H.MakeNearZeroBlockAsZero(thres_zeroblk);
}
GC.Collect(0);
//System.Console.WriteLine("finish resizing");
return(new CGetHessCoarseResiIterImpl
{
iterinfos = iterinfos,
H = H,
});
}
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 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 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 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 void ChangeForm(HEnum.GeometryTyp pType)
{
Typ = pType;
_typSettings.ChangeForm(Typ);
_acceleration = _typSettings.Acceleration;
_maxSpeed = _typSettings.Speed;
}
public static CGetHessCoarseResiIterImpl GetHessCoarseResiIterImpl_Matlab_experimental
(object[] atoms
, HessMatrix H
, List <int>[] lstNewIdxRemv
, double thres_zeroblk
, ILinAlg ila
, bool cloneH
, string[] options
)
{
ila = null;
if (cloneH)
{
H = H.CloneHess();
}
bool process_disp_console = true;
if (options != null && options.Contains("print process"))
{
process_disp_console = true;
}
bool parallel = true;
GC.Collect(0);
DateTime[] process_time = new DateTime[6];
//System.Console.WriteLine("begin coarse-graining");
List <HessCoarseResiIterInfo> iterinfos = new List <HessCoarseResiIterInfo>();
for (int iter = lstNewIdxRemv.Length - 1; iter >= 0; iter--)
{
if (process_disp_console)
{
process_time[0] = DateTime.UtcNow;
System.Console.Write(" - {0:000} : ", iter);
}
//int[] ikeep = lstNewIdxRemv[iter].Item1;
int[] iremv = lstNewIdxRemv[iter].ToArray();
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);
HessCoarseResiIterInfo iterinfo = new HessCoarseResiIterInfo();
iterinfo.sizeHessBlkMat = idxremv.Max() + 1; // H.ColBlockSize;
iterinfo.numAtomsRemoved = idxremv.Length;
iterinfo.time0 = DateTime.UtcNow;
double C_density0 = double.NaN;
double C_density1 = double.NaN;
{
//HessMatrix A = H.SubMatrixByAtoms(false, idxkeep, idxkeep);
HessMatrix A = H;
//HessMatrix B = H.SubMatrixByAtoms(false, idxkeep, idxremv);
HessMatrix C, D;
/// HessMatrix C = H.SubMatrixByAtoms(false, idxremv, idxkeep, parallel:parallel);
/// HessMatrix D = H.SubMatrixByAtoms(false, idxremv, idxremv, parallel:parallel);
{
C = H.Zeros(idxremv.Length * 3, idxkeep.Length * 3);
D = H.Zeros(idxremv.Length * 3, idxremv.Length * 3);
int iremv_min = iremv.Min();
int iremv_max = iremv.Max();
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 (bc > iremv_max)
{
continue;
}
if (br > iremv_max)
{
continue;
}
if (br < iremv_min)
{
int nc = bc - iremv_min;
int nr = br;
C.SetBlock(nc, nr, bval.CloneT());
}
else
{
int nc = bc - iremv_min;
int nr = br - iremv_min;
D.SetBlock(nc, nr, bval.CloneT());
}
}
}
if (process_disp_console)
{
process_time[1] = process_time[2] = DateTime.UtcNow;
System.Console.Write("CD({0:00.00} min), ", (process_time[2] - process_time[0]).TotalMinutes);
}
// make B,C sparse
//int B_cntzero = B.MakeNearZeroBlockAsZero(thres_zeroblk);
C_density0 = C.RatioUsedBlocks;
/// iterinfo.numSetZeroBlock = C.MakeNearZeroBlockAsZero(thres_zeroblk);
{
double thres_absmax = thres_zeroblk;
List <Tuple <int, int> > lstIdxToMakeZero = new List <Tuple <int, int> >();
foreach (var bc_br_bval in C.EnumBlocks())
{
int bc = bc_br_bval.Item1;
int br = bc_br_bval.Item2;
var bval = bc_br_bval.Item3;
double absmax_bval = bval.HAbsMax();
if (absmax_bval < thres_absmax)
{
lstIdxToMakeZero.Add(new Tuple <int, int>(bc, br));
}
}
foreach (var bc_br in lstIdxToMakeZero)
{
int cc = bc_br.Item1;
int cr = bc_br.Item2;
var Cval = C.GetBlock(cc, cr);
C.SetBlock(cc, cr, null);
var Dval = D.GetBlock(cc, cc); // nCval = Cval -Cval
D.SetBlock(cc, cc, Dval + Cval); // nDval = Dval - (-Cval) = Dval + Cval
int bc = cr;
int br = cc;
var Bval = Cval.Tr();
var Aval = A.GetBlock(bc, bc); // nBval = Bval -Bval
A.SetBlock(bc, bc, Aval + Bval); // nAval = Aval - (-Bval) = Aval + Bval
}
iterinfo.numSetZeroBlock = lstIdxToMakeZero.Count;
}
//int B_nzeros = B.NumUsedBlocks; double B_nzeros_ = Math.Sqrt(B_nzeros);
iterinfo.numNonZeroBlock = C.NumUsedBlocks;
C_density1 = C.RatioUsedBlocks;
HessMatrix B_invD_C = Get_BInvDC(A, C, D, process_disp_console
, options
, parallel: parallel
);
if (process_disp_console)
{
process_time[4] = DateTime.UtcNow;
System.Console.Write("B.invD.C({0:00.00} min), ", (process_time[4] - process_time[3]).TotalMinutes);
}
/// iterinfo.numAddIgnrBlock = A.UpdateAdd(B_invD_C, -1, null, thres_zeroblk/lstNewIdxRemv.Length, parallel:parallel);
{
HessMatrix _this = A;
HessMatrix other = B_invD_C;
double thres_NearZeroBlock = thres_zeroblk / lstNewIdxRemv.Length;
int count = 0;
int count_ignored = 0;
foreach (var bc_br_bval in other.EnumBlocks())
{
count++;
int bc = bc_br_bval.Item1;
int br = bc_br_bval.Item2;
MatrixByArr other_bmat = bc_br_bval.Item3;
if (other_bmat.HAbsMax() <= thres_NearZeroBlock)
{
// other_bmat = other_bmat -other_bmat;
// other_diag = other_diag - (-other_bmat) = other_diag + other_bmat;
// this_diag = this_diat - B_invD_C
// = this_diat - other_diag
// = this_diat - (other_diag + other_bmat)
// = this_diat - other_diag - other_bmat
// = (this_diat - other_bmat) - other_diag
// = (this_diat - other_bmat) - (processed later)
// = (this_diat - other_bmat)
MatrixByArr this_diag = _this.GetBlock(bc, bc);
MatrixByArr new_diag = this_diag - other_bmat;
_this.SetBlock(bc, bc, new_diag);
other_bmat = null;
count_ignored++;
}
if (other_bmat != null)
{
MatrixByArr this_bmat = _this.GetBlock(bc, br);
MatrixByArr new_bmat = this_bmat - other_bmat;
_this.SetBlock(bc, br, new_bmat);
}
}
iterinfo.numAddIgnrBlock = count_ignored;
}
//HessMatrix nH = A - B_invD_C;
//nH = ((nH + nH.Tr())/2).ToHessMatrix();
H = A;
}
iterinfo.usedMemoryByte = GC.GetTotalMemory(false);
iterinfo.time1 = DateTime.UtcNow;
iterinfos.Add(iterinfo);
if (process_disp_console)
{
System.Console.WriteLine("summary(makezero {0,5}, nonzero {1,5}, numIgnMul {2,7}, numRemvAtoms {3,3}, {4,5:0.00} sec, {5} mb, {6}x{6}, nzeroBlk/Atom {7:0.00})"
, iterinfo.numSetZeroBlock
, iterinfo.numNonZeroBlock
, iterinfo.numAddIgnrBlock
, iterinfo.numAtomsRemoved
, iterinfo.compSec
, iterinfo.usedMemoryByte / (1024 * 1024)
, (idxkeep.Length * 3)
, ((double)iterinfo.numNonZeroBlock / idxremv.Length)
);
}
GC.Collect(0);
}
int numca = H.ColBlockSize - lstNewIdxRemv.HListCount().Sum();
//System.Console.WriteLine("finish coarse-graining");
{
int[] idxkeep = HEnum.HEnumCount(numca).ToArray();
H = H.SubMatrixByAtoms(false, idxkeep, idxkeep, false);
}
{
H.MakeNearZeroBlockAsZero(thres_zeroblk);
}
GC.Collect(0);
//System.Console.WriteLine("finish resizing");
return(new CGetHessCoarseResiIterImpl
{
iterinfos = iterinfos,
H = H,
});
}