public Tuple <Pdb.Atom, int>[] SelectPdbAtoms()
{
HDebug.Assert(false); // use ListPdbAtoms()
List <Tuple <Pdb.Atom, int> > lstPdbatomIdx = new List <Tuple <Pdb.Atom, int> >();
Pdb.Atom[] pdbatoms = ListPdbAtoms();
for (int idx = 0; idx < atoms.Count; idx++)
{
if (pdbatoms[idx] == null)
{
continue;
}
lstPdbatomIdx.Add(new Tuple <Pdb.Atom, int>(pdbatoms[idx], idx));
}
return(lstPdbatomIdx.ToArray());
}
///////////////////////////////////////////////////////////////////////
// UpdateSubMatrixByAtom
public void UpdateSubMatrixByAtom(HessMatrix submat, IList <int> idxcolatoms, IList <int> idxrowatoms)
{
HDebug.Assert(idxcolatoms.Max() < ColBlockSize);
HDebug.Assert(idxrowatoms.Max() < RowBlockSize);
HDebug.Assert(submat.ColBlockSize == idxcolatoms.Count);
HDebug.Assert(submat.RowBlockSize == idxrowatoms.Count);
for (int ic = 0; ic < idxcolatoms.Count; ic++)
{
for (int ir = 0; ir < idxrowatoms.Count; ir++)
{
int hess_ic = idxcolatoms[ic];
int hess_ir = idxrowatoms[ir];
SetBlock(hess_ic, hess_ir, submat.GetBlock(ic, ir).CloneT());
}
}
}
public static List <List <string> > FromLines_CollectGroup(IList <string> lines)
{
List <List <string> > groups = new List <List <string> >();
for (int i = 0; i < lines.Count; i++)
{
string line = lines[i];
HDebug.Assert(line[0] == ' ');
if (line[1] != ' ' && "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".IndexOf(line[2]) != -1)
{
groups.Add(new List <string>());
}
groups.Last().Add(line);
}
return(groups);
}
public void BuildHess4PwIntrAct(Universe.AtomPack info, Vector[] coords, out Pair <int, int>[] pwidxs, out PwIntrActInfo[] pwhessinfos)
{
Universe.Nonbonded nonbonded = (Universe.Nonbonded)info;
HDebug.Depreciated("check idx1 and idx2");
int idx1 = 0; // nonbonded.atoms[0].ID;
int idx2 = 1; // nonbonded.atoms[1].ID;
Universe.Atom atom1 = nonbonded.atoms[0];
Universe.Atom atom2 = nonbonded.atoms[1];
double pchij = atom1.Charge * atom2.Charge;
if (double.IsNaN(pchij))
{
HDebug.Assert(false);
pwidxs = null;
pwhessinfos = null;
return;
}
Vector diff = (coords[idx2] - coords[idx1]);
double dx = diff[0];
double dy = diff[1];
double dz = diff[2];
double pchi = atom1.Charge;
double pchj = atom2.Charge;
double ee = 80;
// !V(Lennard-Jones) = Eps,i,j[(Rmin,i,j/ri,j)**12 - 2(Rmin,i,j/ri,j)**6]
// !epsilon: kcal/mole, Eps,i,j = sqrt(eps,i * eps,j)
// !Rmin/2: A, Rmin,i,j = Rmin/2,i + Rmin/2,j
//
// V(rij) = (332 * pchij / ee) * rij^-1
// F(rij) = ( -1) * (332 * pchij / ee) * rij^-2
// K(rij) = (-2*-1) * (332 * pchij / ee) * rij^-3
// double pchij = pchi * pchj;
double rij2 = dx * dx + dy * dy + dz * dz;
double rij = Math.Sqrt(rij2);
double rij3 = rij2 * rij;
double fij = (-1) * (332 * pchij / ee) / rij2;
double kij = (-2 * -1) * (332 * pchij / ee) / rij3;
pwidxs = new Pair <int, int> [1];
pwidxs[0] = new Pair <int, int>(0, 1);
pwhessinfos = new PwIntrActInfo[1];
pwhessinfos[0] = new PwIntrActInfo(kij, fij);
}
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 static IList <Atom> CloneByReindexByCoords(this IList <Atom> atoms, IList <Vector> coords, int serialStart = 1)
{
KDTree.KDTree <object> kdtree = new KDTree.KDTree <object>(3);
for (int i = 0; i < coords.Count; i++)
{
kdtree.insert(coords[i], i);
}
Atom[] natoms = new Atom[atoms.Count];
for (int ai = 0; ai < natoms.Length; ai++)
{
Atom atom = atoms[ai];
Vector coord = atom.coord;
int ni = (int)(kdtree.nearest(coord));
Vector ncoord = coords[ni];
double dist = (coord - ncoord).Dist;
HDebug.AssertTolerance(0.001, dist);
HDebug.Assert(natoms[ni] == null);
natoms[ni] = Atom.FromData(serial: serialStart + ni
, name: atom.name
, resName: atom.resName
, chainID: atom.chainID
, resSeq: atom.resSeq
, x: atom.x
, y: atom.y
, z: atom.z
, altLoc: atom.altLoc
, iCode: atom.iCode
, occupancy: atom.occupancy
, tempFactor: atom.tempFactor
, element: atom.element
, charge: atom.charge
);
}
if (HDebug.IsDebuggerAttached)
{
for (int i = 0; i < natoms.Length; i++)
{
HDebug.Assert(natoms[i] != null);
}
}
return(natoms);
}
public static double GetHessTraceSpringBwAtoms(this HessMatrix hess, int atomi, int atomj)
{
HDebug.Assert(hess.ColSize == hess.RowSize);
HDebug.Assert(hess.ColSize % 3 == 0);
HDebug.Assert(hess.RowSize % 3 == 0);
HDebug.Assert(atomi < hess.ColSize / 3);
HDebug.Assert(atomj < hess.ColSize / 3);
HDebug.Assert(hess.ColBlockSize == hess.RowBlockSize);
HDebug.Assert(atomi < hess.ColBlockSize);
HDebug.Assert(atomj < hess.ColBlockSize);
double bibj_trace = 0;
{
MatrixByArr hess_ij = hess.GetBlock(atomi, atomj);
if (hess_ij != null)
{
bibj_trace += hess_ij[0, 0];
bibj_trace += hess_ij[1, 1];
bibj_trace += hess_ij[2, 2];
}
}
double bjbi_trace = 0;
{
MatrixByArr hess_ji = hess.GetBlock(atomj, atomi);
if (hess_ji != null)
{
bjbi_trace += hess_ji[0, 0];
bjbi_trace += hess_ji[1, 1];
bjbi_trace += hess_ji[2, 2];
}
}
double threshold = 0.00001;
HDebug.Assert(Math.Abs(bibj_trace - bjbi_trace) < threshold);
double spr_ij = -1 * (bibj_trace + bjbi_trace) / 2;
if (selftest_GetHessTraceSpringBwAtoms_hess_atomi_atomj)
{
selftest_GetHessTraceSpringBwAtoms_hess_atomi_atomj = false;
double _spr_ij = GetHessTraceSpringBwAtoms(hess as Matrix, atomi, atomj);
HDebug.Assert(Math.Abs(spr_ij - _spr_ij) < threshold);
}
return(spr_ij);
}
public static IEnumerable <Universe.Nonbonded> EnumNonbondeds
(Universe.Atoms atoms
, IList <Vector> coords
, int size
, double maxdist // = 12
, FuncListTip3pHBond func
, string[] options
)
{
bool[] waters = new bool[coords.Count];
KDTree.KDTree <Universe.Atom> kdtree_water = new KDTree.KDTree <Universe.Atom>(3);
foreach (var atom in atoms)
{
if (coords[atom.ID] == null)
{
continue;
}
bool water = atom.IsWater();
waters[atom.ID] = water;
if (water)
{
kdtree_water.insert(coords[atom.ID], atom);
}
}
Universe.Nonbondeds _nonbondeds;
_nonbondeds = new Universe.Nonbondeds(atoms, size, maxdist);
_nonbondeds.UpdateCoords(coords, true);
foreach (var nonbonded in _nonbondeds.EnumNonbondeds(true))
{
HDebug.Assert(nonbonded.atoms.Length == 2);
var atom0 = nonbonded.atoms[0];
var atom1 = nonbonded.atoms[1];
if (waters[atom0.ID] && waters[atom1.ID])
{
continue;
}
yield return(nonbonded);
}
foreach (Universe.Nonbonded nonbonded in func(atoms, coords, waters, kdtree_water, options))
{
yield return(nonbonded);
}
}
public static MatrixByArr GetJ(Universe univ, Vector[] coords, List <RotableInfo> rotInfos, string option = null)
{
switch (option)
{
case "mine":
{
MatrixByArr[,] J = TNM_mine.GetJ(univ, coords, rotInfos, fnInv3x3: null);
double tolerance = 0.00001;
HDebug.Assert(CheckEckartConditions(univ, coords, rotInfos, J, tolerance: tolerance));
//if(Debug.IsDebuggerAttachedWithProb(0.1))
//{
// Matrix J0 = Matrix.FromBlockmatrix(J);
// Matrix J1 = Matrix.FromBlockmatrix(GetJ(univ, coords, rotInfos, option:"paper", useNamedLock:false));
// Debug.AssertTolerance(0.00000001, J0 - J1);
//}
return(MatrixByArr.FromMatrixArray(J));
}
case "paper":
{
MatrixByArr[,] J = TNM_paper.GetJ(univ, coords, rotInfos);
HDebug.Assert(CheckEckartConditions(univ, coords, rotInfos, J, 0.0000001));
return(MatrixByArr.FromMatrixArray(J));
}
case "mineopt":
{
MatrixByArr J = TNM_mineopt.GetJ(univ, coords, rotInfos);
if (HDebug.IsDebuggerAttached && univ.GetMolecules().Length == 1)
{
MatrixByArr J0 = TNM.GetJ(univ, coords, rotInfos, option: "paper");
MatrixByArr dJ = J - J0;
//double tolerance = dJ.ToArray().HAbs().HToArray1D().Mean();
//double maxAbsDH = dJ.ToArray().HAbs().HMax();
//if(tolerance == 0)
// tolerance = 0.000001;
HDebug.AssertTolerance(0.00000001, dJ);
}
return(J);
}
case null:
// my implementation has smaller error while checking Eckart conditions
goto case "mineopt";
}
return(null);
}
/// <summary>
/// Nonbonded Term (Van der Waals)
/// V4 = Epsilon ( 5 (r0_ij / r_ij)^12 - 6 (r0_ij / r_ij)^10 )
/// </summary>
/// <param name="caArray_"></param>
/// <param name="Epsilon"></param>
/// <returns></returns>
public static Matrix FourthTerm(IList <Vector> caArray_, double Epsilon)
{
VECTORS caArray = new VECTORS(caArray_);
MATRIX hessian = new MATRIX(new double[6, 6]);
// derive the hessian of the first term (off diagonal)
{
int i = 1;
int j = 2;
double bx = caArray[i, 1] - caArray[j, 1];
double by = caArray[i, 2] - caArray[j, 2];
double bz = caArray[i, 3] - caArray[j, 3];
double distijsqr = pow(sqrt(bx * bx + by * by + bz * bz), 4);
// diagonals of off-diagonal super elements (1st term)
hessian[3 * i - 2, 3 * j - 2] += -120 * Epsilon * bx * bx / distijsqr;
hessian[3 * i - 1, 3 * j - 1] += -120 * Epsilon * by * by / distijsqr;
hessian[3 * i, 3 * j] += -120 * Epsilon * bz * bz / distijsqr;
// off-diagonals of off-diagonal super elements (1st term)
hessian[3 * i - 2, 3 * j - 1] += -120 * Epsilon * bx * by / distijsqr;
hessian[3 * i - 2, 3 * j] += -120 * Epsilon * bx * bz / distijsqr;
hessian[3 * i - 1, 3 * j - 2] += -120 * Epsilon * by * bx / distijsqr;
hessian[3 * i - 1, 3 * j] += -120 * Epsilon * by * bz / distijsqr;
hessian[3 * i, 3 * j - 2] += -120 * Epsilon * bx * bz / distijsqr;
hessian[3 * i, 3 * j - 1] += -120 * Epsilon * by * bz / distijsqr;
//Hii
//update the diagonals of diagonal super elements
hessian[3 * i - 2, 3 * i - 2] += +120 * Epsilon * bx * bx / distijsqr;
hessian[3 * i - 1, 3 * i - 1] += +120 * Epsilon * by * by / distijsqr;
hessian[3 * i, 3 * i] += +120 * Epsilon * bz * bz / distijsqr;
// update the off-diagonals of diagonal super elements
hessian[3 * i - 2, 3 * i - 1] += +120 * Epsilon * bx * by / distijsqr;
hessian[3 * i - 2, 3 * i] += +120 * Epsilon * bx * bz / distijsqr;
hessian[3 * i - 1, 3 * i - 2] += +120 * Epsilon * by * bx / distijsqr;
hessian[3 * i - 1, 3 * i] += +120 * Epsilon * by * bz / distijsqr;
hessian[3 * i, 3 * i - 2] += +120 * Epsilon * bz * bx / distijsqr;
hessian[3 * i, 3 * i - 1] += +120 * Epsilon * bz * by / distijsqr;
}
HDebug.Assert(hessian.matrix.IsComputable());
return(hessian.matrix);
}
public static void Compute(Vector[] coords, out double energy, out double force01, out double spring01, double Kb, double b0)
{
/// BONDS
/// !V(bond) = Kb(b - b0)**2
///
/// p0 ---------- p1
/// (+) --→ ←-- (+)
/// ←-- (-) (-) --→
///
/// V = Kb ( b - b0 ) ^ 2
/// d_V / d_b = 2 Kb ( b - b0 )
/// d2_V / d_b2 = 2 Kb
///
/// b = b1 + t
/// d_b / d_t = 1
/// d2_b / d_t2 = 0
///
/// energy = V
/// = Kb ( b - b0 ) ^ 2
///
/// force = d_V / d_t
/// = {d_V / d_b } * {d_b / d_t}
/// = {2 Kb ( b - b0 )} * { 1 }
/// = 2 Kb ( b - b0 )
///
/// spring = d_V2 / d2_t
/// = d_(d_V / d_t) / d_t
/// = d_({d_V / d_b } * {d_b / d_t}) / d_t
/// = {d_{d_V / d_b } / d_t} * {d_b / d_t}
/// + {d_V / d_b } * {d_{d_b / d_t} / d_t}
/// = {d2_V / d_b2}*{d_b / d_t} * {d_b / d_t}
/// + {d_V / d_b } * {d2_b / d_t2}
/// = {d2_V / d_b2}*{d_b / d_t}*{d_b / d_t} + {d_V / d_b }*{d2_b / d_t2}
/// = {2 Kb }*{ 1 }*{ 1 } + {2 Kb (b - b0)}*{ 0 }
/// = 2 Kb
///////////////////////////////////////////////////////////////////////////////
Vector pos1 = coords[0];
Vector pos2 = coords[1];
double b = (pos1 - pos2).Dist;
HDebug.Assert(b != 0, double.IsNaN(b) == false, double.IsInfinity(b) == false);
energy = Kb * (b - b0) * (b - b0);
force01 = 2 * Kb * (b - b0);
spring01 = 2 * Kb;
HDebug.AssertIf(force01 > 0, b0 < b); // positive force => attractive
HDebug.AssertIf(force01 < 0, b < b0); // negative force => repulsive
}
public Vector this[int id0, int id1]
{
get
{
HDebug.Assert(forceij != null);
if (forceij[id0, id1] == null)
{
forceij[id0, id1] = new double[3];
}
return(forceij[id0, id1]);
}
set
{
HDebug.Assert(forceij != null);
forceij[id0, id1] = value;
}
}
public static Pdb CopyPdbOccupancyForMergedPsf(Pdb copyto, Pdb copyfrom1, Pdb copyfrom2)
{
KDTreeDLL.KDTree <Pdb.Atom> kdtree = new KDTreeDLL.KDTree <Pdb.Atom>(3);
foreach (var atom in copyfrom1.atoms)
{
kdtree.insert(atom.coord, atom);
}
foreach (var atom in copyfrom2.atoms)
{
kdtree.insert(atom.coord, atom);
}
Pdb pdb = copyto.Clone();
List <string> nlines = new List <string>();
for (int i = 0; i < pdb.elements.Length; i++)
{
var elemi = pdb.elements[i];
if ((elemi is Pdb.Atom) == false)
{
nlines.Add(elemi.line);
}
else
{
var atomi = elemi as Pdb.Atom;
var atomx = kdtree.nearest(atomi.coord);
HDebug.Assert(atomi.coord[0] == atomx.coord[0]);
HDebug.Assert(atomi.coord[1] == atomx.coord[1]);
HDebug.Assert(atomi.coord[2] == atomx.coord[2]);
/// 55 - 60 Real(6.2) occupancy Occupancy.
char[] line = atomi.line.ToCharArray();
line[55 - 1] = atomx.line[55 - 1];
line[56 - 1] = atomx.line[56 - 1];
line[57 - 1] = atomx.line[57 - 1];
line[58 - 1] = atomx.line[58 - 1];
line[59 - 1] = atomx.line[59 - 1];
line[60 - 1] = atomx.line[60 - 1];
string nline = line.HToString();
nlines.Add(nline);
Pdb.Atom natomi = Pdb.Atom.FromString(nline);
pdb.elements[i] = natomi;
}
}
return(pdb);
}
public static MixHessInfo GetHessMixEAnm(Universe univ, IList <Vector> coords, ILinAlg la
, IList <ResInfo> lstResAllAtom, double anmCutoff, out string errmsg
, bool bGetIntmInfo, string strBkbnReso
)
{
HDebug.Assert(anmCutoff >= 0);
var anmSprcstCutoffAll = new Tuple <double, double>(1, anmCutoff);
var anmSprcstCutoffCoarse = new Tuple <double, double>(1, anmCutoff);
var anmSprcstCutoffMix = new Tuple <double, double>(1, anmCutoff);
bool bAllowAllToCoarse = true;
bool bOnlyCoarseConnBackbone = false;
MixHessInfo hessinfo = GetHessMixEAnm(univ, coords, la, lstResAllAtom, bAllowAllToCoarse, bOnlyCoarseConnBackbone
, anmSprcstCutoffAll, anmSprcstCutoffMix, anmSprcstCutoffCoarse
, out errmsg, bGetIntmInfo, strBkbnReso);
return(hessinfo);
}
public static void PCA(string pdbpath, string outpathroot, double scaleAnimation)
{
HDebug.ToDo();
Pdb.Atom[] meanconf;
Matrix modes;
Vector freq;
PCA(pdbpath, out meanconf, out modes, out freq);
for (int i = 0; i < freq.Size; i++)
{
string outpath = outpathroot + i.ToString("00") + ".pdb";
Vector[] mode = (modes.GetColVector(i) * scaleAnimation / freq[i]).ToVectors(3);
Pdb.ToFileAnimated(outpath, meanconf, mode);
}
}
public double GetEnergyFromAnisous(IList <Vector> coordsto)
{
HDebug.Assert(size == coordsto.Count);
Vector[] dcoords = new Vector[size];
for (int i = 0; i < size; i++)
{
dcoords[i] = coords[i] - coordsto[i];
}
{
double energy = 0;
for (int i = 0; i < size; i++)
{
energy += LinAlg.VtMV(dcoords[i], hess[i, i], dcoords[i]);
}
return(energy);
}
}
public static Matrix GetCorrMatrix(this IList <Mode> modes)
{
if (HDebug.Selftest())
{
HDebug.Assert(GetCorrMatrix_SelfTest(modes, GetCorrMatrix));
}
Vector[][] eigvecs = new Vector[modes.Count][];
double[] eigvals = new double[modes.Count];
for (int i = 0; i < modes.Count; i++)
{
eigvals[i] = modes[i].eigval;
eigvecs[i] = modes[i].GetEigvecsOfAtoms();
}
int size = modes[0].size;
Matrix Dij = Matrix.Zeros(size, size);
Vector Dii = new double[size];
for (int i = 0; i < eigvals.Length; i++)
{
Vector[] eigvec = eigvecs[i];
double eigval = eigvals[i];
for (int c = 0; c < size; c++)
{
for (int r = 0; r < size; r++)
{
Dij[c, r] += (LinAlg.VtV(eigvec[c], eigvec[r]) / eigval);
}
Dii[c] += (LinAlg.VtV(eigvec[c], eigvec[c]) / eigval);
}
}
Dij = Dij / modes.Count;
Dii = Dii / modes.Count;
// Cij
for (int c = 0; c < size; c++)
{
for (int r = 0; r < size; r++)
{
Dij[c, r] /= Math.Sqrt(Dii[c] * Dii[r]);
}
}
return(Dij);
}
public static double GetTinkerRmsGradient(this Vector[] forcs)
{
double gnorm = 0;
foreach (Vector forc in forcs)
{
HDebug.Assert(forc.Size == 3);
double x2 = forc[0] * forc[0];
double y2 = forc[1] * forc[1];
double z2 = forc[2] * forc[2];
gnorm += (x2 + y2 + z2);
}
gnorm = Math.Sqrt(gnorm);
double grms = gnorm / Math.Sqrt(forcs.Length);
return(grms);
}
public static int FindType(string[] types, params string[] query)
{
int count_X = 0;
foreach (string type in types)
{
if (type == "X")
{
count_X++;
}
}
int length = types.Length;
HDebug.Assert(types.Length == query.Length);
{
int match = 0;
for (int i = 0; i < length; i++)
{
if (types[i] == "X" || types[i] == query[i])
{
match++;
}
}
if (match == length)
{
return(count_X);
}
}
{
int match = 0;
for (int i = 0; i < length; i++)
{
if (types[i] == "X" || types[i] == query[length - i - 1])
{
match++;
}
}
if (match == length)
{
return(count_X);
}
}
// not found
return(-1);
}
public static MatrixByArr GetHessian(this IList <Mode> modes, IList <double> masses, ILinAlg la)
{
/// mode.eigval = mweigval
/// mode.eigvec = mass^-0.5 * mweigvec
///
/// W = [mode(1).eigvec, mode(2).eigvec, ... ]
/// M = masses
/// D = diag([mode(1).eigval, mode(2).eigval, ...])
///
/// mwH = M^-0.5 H M^-0.5
/// [V,D] = eig(mwH)
/// mode.eigval == D
/// mode.eigvec == M^-0.5 V = W
///
/// W D W' = M^-0.5 V D V M^-0.5
/// = M^-0.5 mwH M^-0.5
/// = M^-0.5 (M^-0.5 H M^-0.5) M^-0.5
/// = M^-1 H M^-1
/// H = M (M^-1 H M^-1) M
/// = M (W D W') M
/// = (M W) D (M W)'
HDebug.Assert(modes.CheckModeMassReduced(masses.ToArray(), la, 0.000001));
Vector[] mws = modes.ListEigvec().ToArray();
for (int iv = 0; iv < mws.Length; iv++)
{
for (int i = 0; i < mws[iv].Size; i++)
{
mws[iv][i] = mws[iv][i] * masses[i / 3];
}
}
Vector ds = modes.ListEigval().ToArray();
MatrixByArr hess;
{
var MW = la.ToILMat(mws.ToMatrix());
var D = la.ToILMat(ds).Diag();
var H = la.Mul(MW, D, MW.Tr);
hess = H.ToArray();
MW.Dispose();
D.Dispose();
H.Dispose();
}
return(hess);
}
public static char[] ListSecondStruc <ATOM>(this IList <ATOM> atoms, IList <Pdb.Helix> helix, IList <Pdb.Sheet> sheet)
where ATOM : IAtom
{
Dictionary <ATOM, char> atom_struc = new Dictionary <ATOM, char>();
{
foreach (Tuple <Pdb.Helix[], ATOM[]> helix_atoms in helix.HSelectAtoms(atoms))
{
foreach (ATOM atom in helix_atoms.Item2)
{
if (atom_struc.ContainsKey(atom) == false)
{
atom_struc.Add(atom, 'H');
}
HDebug.Assert(atom_struc[atom] == 'H');
}
}
foreach (Tuple <Pdb.Sheet[], ATOM[]> sheet_atoms in sheet.HSelectAtoms(atoms))
{
foreach (ATOM atom in sheet_atoms.Item2)
{
if (atom_struc.ContainsKey(atom) == false)
{
atom_struc.Add(atom, 'S');
}
HDebug.Assert(atom_struc[atom] == 'S');
}
}
}
int leng = atoms.Count;
char[] secondstruc = new char[leng];
for (int i = 0; i < leng; i++)
{
var atom = atoms[i];
if (atom_struc.ContainsKey(atom))
{
secondstruc[i] = atom_struc[atom];
}
else
{
secondstruc[i] = 'L';
}
}
return(secondstruc);
}
public static List <Atom> CloneByUpdateCoord(this IList <Atom> atoms, IList <Vector> coords, string optNullAtom)
{
HDebug.Assert(optNullAtom == null);
HDebug.Assert(atoms.Count == coords.Count);
int count = Math.Max(atoms.Count, coords.Count);
Atom[] uatoms = new Atom[count];
for (int i = 0; i < count; i++)
{
Atom atom = atoms[i];
if (atom == null)
{
switch (optNullAtom)
{
case null: goto default;
case "if null, set as hydrogen":
{
int maxserial = atoms.HRemoveAll(null).ListSerial().Max();
// "ATOM 2 HT1 ARG A 17 -21.666 -13.812 202.912 0.00 0.00 P1 H"
atom = Atom.FromData
(
serial: maxserial + 1,
name: "H",
resName: uatoms[i - 1].resName,
chainID: uatoms[i - 1].chainID,
resSeq: uatoms[i - 1].resSeq,
x: 0,
y: 0,
z: 0,
element: "H"
);
maxserial++;
}
break;
default:
throw new Exception();
}
}
uatoms[i] = Atom.FromString(atom.GetUpdatedLine(coords[i]));
}
return(uatoms.ToList());
}
public static Trans3 GetTrans(IList <Vector> C1, IList <Vector> C2, HPack <int> optIter = null, HPack <List <double> > optListWeightSum = null)
{
HDebug.Assert(C1.Count == C2.Count);
int size = C1.Count;
if (optIter != null)
{
optIter.value = 0;
}
Trans3 trans0 = new Trans3(new double[3], 1, Quaternion.UnitRotation);
Trans3 trans1 = Geometry.AlignPointPoint.MinRMSD.GetTrans(C2, C1);
if (optListWeightSum != null)
{
optListWeightSum.value = new List <double>();
}
while ((trans0.TransformMatrix - trans1.TransformMatrix).ToArray().HAbs().HMax() > 0.00000001)
{
if (optIter != null)
{
optIter.value++;
}
Vector[] C2trans = trans1.GetTransformed(C2).ToArray();
double[] weight = new double[size];
double[] dist2s = new double[size];
for (int i = 0; i < size; i++)
{
double dist2 = (C1[i] - C2trans[i]).Dist2;
dist2 = HMath.Between(0.001, dist2, double.PositiveInfinity);
weight[i] = 1 / dist2;
dist2s[i] = dist2;
}
if (optListWeightSum != null)
{
optListWeightSum.value.Add(weight.Sum());
}
trans0 = trans1;
trans1 = Geometry.AlignPointPoint.MinRMSD.GetTrans(C2, C1, weight);
}
return(trans1);
}
public static Vector GetBFactor(Matrix hess
, int numIgnoreSmallEigval = 6 // the number to ignore the eigenvalues
, bool zeroForNegEigval = true // set zero for the negative eigen values
)
{
HDebug.Assert(GetBFactorSelfTest());
int n = hess.ColSize / 3;
HDebug.Assert(n * 3 == hess.ColSize);
HDebug.Assert(hess.RowSize == hess.ColSize);
InfoPack lextra = new InfoPack();
Vector[] eigvec;
double[] eigval;
NumericSolver.Eig(hess.ToArray(), out eigvec, out eigval);
double[] abs_eigval = eigval.HAbs();
List <int> idx_sorted_abs_eigval = new List <int>(abs_eigval.HIdxSorted());
for (int i = 0; i < numIgnoreSmallEigval; i++)
{
idx_sorted_abs_eigval.RemoveAt(0);
}
Vector bfactor = new double[n];
foreach (int idx in idx_sorted_abs_eigval)
{
if (eigval[idx] < 0)
{
continue;
}
for (int i = 0; i < n; i++)
{
double dx = eigvec[idx][i * 3 + 0];
double dy = eigvec[idx][i * 3 + 1];
double dz = eigvec[idx][i * 3 + 2];
bfactor[i] += (dx * dx + dy * dy + dz * dz) / eigval[idx];
}
}
return(bfactor);
}
//public static void GetHessAnm(IList<Vector> coords, double cutoff, MatrixSparse<MatrixByArr> hess)
//{
// int n = coords.Count;
//
// MatrixSparse<MatrixByArr> lhess = null;
// if(HDebug.Selftest())
// lhess = new MatrixSparse<MatrixByArr>(n, n, hess.GetDefault);
//
// double cutoff2 = cutoff * cutoff;
// for(int i=0; i<n; i++)
// {
// if(coords[i] == null)
// continue;
// for(int j=0; j<n; j++)
// {
// if(i == j)
// continue;
// if(coords[j] == null)
// continue;
// Vector vec_ij = coords[j] - coords[i];
// double dist2 = vec_ij.Dist2;
// if(dist2 > cutoff2)
// continue;
//
// Vector unit_ij = vec_ij.UnitVector();
// double k_ij = 1;
// MatrixByArr hessij = new double[3, 3];
// hessij[0, 0] = k_ij * unit_ij[0]*unit_ij[0];
// hessij[0, 1] = k_ij * unit_ij[0]*unit_ij[1];
// hessij[0, 2] = k_ij * unit_ij[0]*unit_ij[2];
// hessij[1, 0] = k_ij * unit_ij[1]*unit_ij[0];
// hessij[1, 1] = k_ij * unit_ij[1]*unit_ij[1];
// hessij[1, 2] = k_ij * unit_ij[1]*unit_ij[2];
// hessij[2, 0] = k_ij * unit_ij[2]*unit_ij[0];
// hessij[2, 1] = k_ij * unit_ij[2]*unit_ij[1];
// hessij[2, 2] = k_ij * unit_ij[2]*unit_ij[2];
// hess[i, j] -= hessij;
// hess[i, i] += hessij;
// if(lhess != null)
// {
// lhess[i, j] -= hessij;
// lhess[i, i] += hessij;
// }
// }
// }
//
// if(lhess != null)
// {
// MatrixByArr lhess0 = GetHessAnm(coords, cutoff);
// MatrixByArr lhess1 = MatrixByArr.FromMatrixArray(lhess.ToArray());
// HDebug.AssertTolerance(0.00000000001, lhess0-lhess1);
// }
//}
static HessMatrix GetHessAnm_debug(IList <Vector> coords, Matrix Kij)
{
//Debug.Assert(AnmHessianSelfTest());
int n = coords.Count;
HessMatrix hess = HessMatrixDense.ZerosDense(n * 3, n * 3);
for (int i = 0; i < n; i++)
{
if (coords[i] == null)
{
continue;
}
for (int j = 0; j < n; j++)
{
if (i == j)
{
HDebug.Assert(Kij[i, j] == 0);
continue;
}
if (coords[j] == null)
{
continue;
}
Vector vec_ij = coords[j] - coords[i];
Vector unit_ij = vec_ij.UnitVector();
double k_ij = Kij[i, j];
HDebug.Assert(double.IsNaN(k_ij) == false);
if (k_ij == 0)
{
continue;
}
hess[i * 3 + 0, j *3 + 0] = -k_ij * unit_ij[0] * unit_ij[0]; hess[i * 3 + 0, i *3 + 0] += k_ij * unit_ij[0] * unit_ij[0];
hess[i * 3 + 0, j *3 + 1] = -k_ij * unit_ij[0] * unit_ij[1]; hess[i * 3 + 0, i *3 + 1] += k_ij * unit_ij[0] * unit_ij[1];
hess[i * 3 + 0, j *3 + 2] = -k_ij * unit_ij[0] * unit_ij[2]; hess[i * 3 + 0, i *3 + 2] += k_ij * unit_ij[0] * unit_ij[2];
hess[i * 3 + 1, j *3 + 0] = -k_ij * unit_ij[1] * unit_ij[0]; hess[i * 3 + 1, i *3 + 0] += k_ij * unit_ij[1] * unit_ij[0];
hess[i * 3 + 1, j *3 + 1] = -k_ij * unit_ij[1] * unit_ij[1]; hess[i * 3 + 1, i *3 + 1] += k_ij * unit_ij[1] * unit_ij[1];
hess[i * 3 + 1, j *3 + 2] = -k_ij * unit_ij[1] * unit_ij[2]; hess[i * 3 + 1, i *3 + 2] += k_ij * unit_ij[1] * unit_ij[2];
hess[i * 3 + 2, j *3 + 0] = -k_ij * unit_ij[2] * unit_ij[0]; hess[i * 3 + 2, i *3 + 0] += k_ij * unit_ij[2] * unit_ij[0];
hess[i * 3 + 2, j *3 + 1] = -k_ij * unit_ij[2] * unit_ij[1]; hess[i * 3 + 2, i *3 + 1] += k_ij * unit_ij[2] * unit_ij[1];
hess[i * 3 + 2, j *3 + 2] = -k_ij * unit_ij[2] * unit_ij[2]; hess[i * 3 + 2, i *3 + 2] += k_ij * unit_ij[2] * unit_ij[2];
}
}
return(hess);
}
public static double[] GetBFactor(Mode[] modes, double[] mass = null)
{
if (HDebug.Selftest())
#region selftest
{
using (new Matlab.NamedLock("SELFTEST"))
{
Matlab.Clear("SELFTEST");
Matlab.Execute("SELFTEST.hess = rand(30);");
Matlab.Execute("SELFTEST.hess = SELFTEST.hess + SELFTEST.hess';");
Matlab.Execute("SELFTEST.invhess = inv(SELFTEST.hess);");
Matlab.Execute("SELFTEST.bfactor3 = diag(SELFTEST.invhess);");
Matlab.Execute("SELFTEST.bfactor = SELFTEST.bfactor3(1:3:end) + SELFTEST.bfactor3(2:3:end) + SELFTEST.bfactor3(3:3:end);");
MatrixByArr selftest_hess = Matlab.GetMatrix("SELFTEST.hess");
Mode[] selftest_mode = Hess.GetModesFromHess(selftest_hess);
Vector selftest_bfactor = BFactor.GetBFactor(selftest_mode);
Vector selftest_check = Matlab.GetVector("SELFTEST.bfactor");
Vector selftest_diff = selftest_bfactor - selftest_check;
HDebug.AssertTolerance(0.00000001, selftest_diff);
Matlab.Clear("SELFTEST");
}
}
#endregion
int size = modes[0].size;
if (mass != null)
{
HDebug.Assert(size == mass.Length);
}
double[] bfactor = new double[size];
for (int i = 0; i < size; i++)
{
foreach (Mode mode in modes)
{
bfactor[i] += mode.eigvec[i * 3 + 0] * mode.eigvec[i * 3 + 0] / mode.eigval;
bfactor[i] += mode.eigvec[i * 3 + 1] * mode.eigvec[i * 3 + 1] / mode.eigval;
bfactor[i] += mode.eigvec[i * 3 + 2] * mode.eigvec[i * 3 + 2] / mode.eigval;
}
if (mass != null)
{
bfactor[i] /= mass[i];
}
}
return(bfactor);
}
public static Matrix GetCorrMatrixMatlab(this IList <Mode> modes)
{
if (HDebug.Selftest())
{
HDebug.Assert(GetCorrMatrix_SelfTest(modes, GetCorrMatrixMatlab));
}
// Dii = zeros(n, 1);
// For[i=1, i<=nmodes, i++,
// Dii = Dii + Table[Dot[vec,vec],{vec,modei}]/eigvi;
// ];
// Dij = zeros(n, n);
// For[i=1, i<=nmodes, i++,
// Dijx = Dijx + modei_x.Transpose[modei_x] / eigvi;
// Dijy = Dijy + modei_y.Transpose[modei_y] / eigvi;
// Dijz = Dijz + modei_z.Transpose[modei_z] / eigvi;
// Dii = Dii + Table[Dot[vec,vec],{vec,modei}]/eigvi;
// ];
// Dij = Dij / nmodes;
// Dii = Dii / nmodes;
// Cij = Dij / Sqrt[Transpose[{Dii}].{Dii}];
// corr = Cij;
Matrix MD = modes.ListEigvec().ToMatrix();
Vector EV = modes.ListEigval().ToArray();
Matrix corrmat;
using (new Matlab.NamedLock(""))
{
Matlab.Clear();
Matlab.PutMatrix("MD", MD, true);
Matlab.PutVector("EV", EV);
Matlab.Execute("nmodes = length(EV);");
Matlab.Execute("iEV = diag(1 ./ EV);");
Matlab.Execute("Dijx = MD(1:3:end,:); Dijx = Dijx*iEV*Dijx'; Dij= Dijx; clear Dijx;");
Matlab.Execute("Dijy = MD(2:3:end,:); Dijy = Dijy*iEV*Dijy'; Dij=Dij+Dijy; clear Dijy;");
Matlab.Execute("Dijz = MD(3:3:end,:); Dijz = Dijz*iEV*Dijz'; Dij=Dij+Dijz; clear Dijz;");
Matlab.Execute("clear MD; clear EV; clear iEV;");
Matlab.Execute("Dij = Dij / nmodes;");
Matlab.Execute("Dii = diag(Dij);");
Matlab.Execute("Dij = Dij ./ sqrt(Dii*Dii');");
corrmat = Matlab.GetMatrix("Dij", true);
}
return(corrmat);
}
public double GetGetTorsionalAngle(Atom atom1, Atom atom2)
{
List <double> torangle = new List <double>();
foreach (Dihedral dihedral in dihedrals)
{
if ((dihedral.atoms[1].ID == atom1.ID) && (dihedral.atoms[2].ID == atom2.ID))
{
torangle.Add(Geometry.TorsionalAngle(atoms[0].Coord, atoms[1].Coord, atoms[2].Coord, atoms[3].Coord));
}
if ((dihedral.atoms[2].ID == atom1.ID) && (dihedral.atoms[1].ID == atom2.ID))
{
torangle.Add(Geometry.TorsionalAngle(atoms[3].Coord, atoms[2].Coord, atoms[1].Coord, atoms[0].Coord));
}
}
HDebug.Assert(torangle.Count == 1);
return(torangle.Average());
}
public static bool CheckEckartConditions(Universe univ, List <RotableInfo> rotInfos, MatrixByArr[,] J)
{
int n = univ.atoms.Count;
int m = rotInfos.Count;
//
for (int a = 0; a < m; a++)
{
MatrixByArr mJ = new double[3, 1];
for (int i = 0; i < n; i++)
{
mJ += univ.atoms[i].Mass * J[i, a];
}
HDebug.AssertTolerance(0.00001, mJ);
}
return(true);
}
public Vector GetMasses(int dim = 1)
{
Vector masses = atoms.ToArray().GetMasses(dim);
if (HDebug.IsDebuggerAttached)
{
double[] tmasses = new double[size * dim];
for (int i = 0; i < size; i++)
{
for (int j = 0; j < dim; j++)
{
tmasses[i * dim + j] = atoms[i].Mass;
}
}
HDebug.AssertTolerance(0, masses - tmasses);
}
return(masses);
}