void ComputeSiteForces ()
{
VecR dr, shift;
real fcVal, rr, rrCut, rri, rri3, uVal;
int j1, j2, m1, m2, ms1, ms2, n, typeSum;
rrCut = Sqr (rCut);
for (n = 0; n < nMol * sitesMol; n ++) VZero (site[n].f);
uSum = 0.;
for (m1 = 0; m1 < nMol - 1; m1 ++) {
for (m2 = m1 + 1; m2 < nMol; m2 ++) {
VSub (dr, mol[m1].r, mol[m2].r);
VZero (shift);
VShiftAll (dr);
VVAdd (dr, shift);
rr = VLenSq (dr);
if (rr < rrCut) {
ms1 = m1 * sitesMol;
ms2 = m2 * sitesMol;
for (j1 = 0; j1 < sitesMol; j1 ++) {
for (j2 = 0; j2 < sitesMol; j2 ++) {
typeSum = mSite[j1].typeF + mSite[j2].typeF;
if (mSite[j1].typeF == mSite[j2].typeF || typeSum == 5) {
VSub (dr, site[ms1 + j1].r, site[ms2 + j2].r);
VVAdd (dr, shift);
rr = VLenSq (dr);
rri = 1. / rr;
switch (typeSum) {
case 2:
rri3 = Cube (rri);
uVal = 4. * rri3 * (rri3 - 1.);
fcVal = 48. * rri3 * (rri3 - 0.5) * rri;
break;
case 4:
uVal = 4. * bCon * sqrt (rri);
fcVal = uVal * rri;
break;
case 5:
uVal = -2. * bCon * sqrt (rri);
fcVal = uVal * rri;
break;
case 6:
uVal = bCon * sqrt (rri);
fcVal = uVal * rri;
break;
}
VVSAdd (site[ms1 + j1].f, fcVal, dr);
VVSAdd (site[ms2 + j2].f, - fcVal, dr);
uSum += uVal;
}
}
}
}
}
}
}
void EvalRdf ()
{
VecR dr, shift;
real deltaR, normFac, rr;
int j1, j2, k, m1, m2, ms1, ms2, n, rdfType, typeSum;
if (countRdf == 0) {
for (k = 0; k < 3; k ++) {
for (n = 0; n < sizeHistRdf; n ++) histRdf[k][n] = 0.;
}
}
deltaR = rangeRdf / sizeHistRdf;
for (m1 = 0; m1 < nMol - 1; m1 ++) {
for (m2 = m1 + 1; m2 < nMol; m2 ++) {
VSub (dr, mol[m1].r, mol[m2].r);
VZero (shift);
VShiftAll (dr);
VVAdd (dr, shift);
rr = VLenSq (dr);
if (rr < Sqr (rangeRdf)) {
ms1 = m1 * sitesMol;
ms2 = m2 * sitesMol;
for (j1 = 0; j1 < sitesMol; j1 ++) {
for (j2 = 0; j2 < sitesMol; j2 ++) {
typeSum = mSite[j1].typeRdf + mSite[j2].typeRdf;
if (typeSum >= 2) {
VSub (dr, site[ms1 + j1].r, site[ms2 + j2].r);
VVAdd (dr, shift);
rr = VLenSq (dr);
if (rr < Sqr (rangeRdf)) {
n = sqrt (rr) / deltaR;
if (typeSum == 2) rdfType = 0;
else if (typeSum == 3) rdfType = 1;
else rdfType = 2;
++ histRdf[rdfType][n];
}
}
}
}
}
}
}
++ countRdf;
if (countRdf == limitRdf) {
normFac = VProd (region) / (2. * M_PI * Cube (deltaR) *
Sqr (nMol) * countRdf);
for (k = 0; k < 3; k ++) {
for (n = 0; n < sizeHistRdf; n ++)
histRdf[k][n] *= normFac / Sqr (n - 0.5);
}
PrintRdf (stdout);
countRdf = 0;
}
}
void SingleEvent ()
{
real vvSum;
int n;
NextEvent ();
if (evIdB < MOL_LIMIT) {
ProcessCollision ();
EvalFreePath ();
++ collCount;
} else if (evIdB >= MOL_LIMIT + 100) {
ProcessCellCrossing ();
++ crossCount;
} else if (evIdB == MOL_LIMIT + 6) {
UpdateSystem ();
nextSumTime += intervalSum;
ScheduleEvent (0, MOL_LIMIT + 6, nextSumTime);
VZero (vSum);
vvSum = 0.;
DO_MOL {
VVAdd (vSum, mol[n].rv);
vvSum += VLenSq (mol[n].rv);
}
kinEnVal = vvSum * 0.5 / nMol;
PrintSummary (stdout);
}
void SingleEvent ()
{
real vvSum;
real sp;
int n;
NextEvent ();
if (evIdB < MOL_LIMIT) {
ProcessCollision ();
++ collCount;
} else if (evIdB < MOL_LIMIT + NDIM * 2 || evIdB >= MOL_LIMIT + 100) {
ProcessCellCrossing ();
++ crossCount;
} else if (evIdB == MOL_LIMIT + 6) {
UpdateSystem ();
nextSumTime += intervalSum;
ScheduleEvent (0, MOL_LIMIT + 6, nextSumTime);
VZero (vSum);
vvSum = 0.;
sp = 0.;
DO_MOL {
VVAdd (vSum, mol[n].rv);
vvSum += VLenSq (mol[n].rv);
sp += VDot (mol[n].r, gravField);
}
kinEnVal = vvSum * 0.5 / nMol;
totEnVal = kinEnVal - sp / nMol;
PrintSummary (stdout);
} else if (evIdB == MOL_LIMIT + 7) {
void ComputeTorqs ()
{
RMat rMat;
VecR dr, t, torqS;
int j, n;
DO_MOL {
VZero (mol[n].ra);
VZero (torqS);
for (j = 0; j < sitesMol; j ++) {
VVAdd (mol[n].ra, site[n * sitesMol + j].f);
VSub (dr, site[n * sitesMol + j].r, mol[n].r);
VCross (t, dr, site[n * sitesMol + j].f);
VVAdd (torqS, t);
}
BuildRotMatrix (&rMat, &mol[n].q, 0);
MVMul (mol[n].torq, rMat.u, torqS);
}
}
void ComputeTorqs ()
{
VecR dr, t, torqS, waB;
int j, n;
DO_MOL {
VZero (mol[n].ra);
VZero (torqS);
for (j = 0; j < sitesMol; j ++) {
VVAdd (mol[n].ra, site[n * sitesMol + j].f);
VSub (dr, site[n * sitesMol + j].r, mol[n].r);
VCross (t, dr, site[n * sitesMol + j].f);
VVAdd (torqS, t);
}
MVMulT (waB, mol[n].rMatT.u, torqS);
VDiv (waB, waB, mInert);
MVMul (mol[n].wa, mol[n].rMatT.u, waB);
}
}
void InitVels ()
{
int n;
VZero (vSum);
DO_MOL {
VRand (&mol[n].rv);
VScale (mol[n].rv, velMag);
VVAdd (vSum, mol[n].rv);
}
DO_MOL VVSAdd (mol[n].rv, - 1. / nMol, vSum);
}
void EvalProps ()
{
VecR w;
int n;
VZero (vSum);
vvSum = 0.;
DO_MOL {
VVAdd (vSum, mol[n].rv);
vvSum += VLenSq (mol[n].rv);
}
vvqSum = 0.;
DO_MOL {
ComputeAngVel (n, &w);
vvqSum += VWLenSq (mInert, w);
}
vvSum += vvqSum;
kinEnergy.val = 0.5 * vvSum / nMol;
totEnergy.val = kinEnergy.val + uSum / nMol;
}
void EvalProps ()
{
VecR w;
int n;
VZero (vSum);
vvSum = 0.;
DO_MOL {
VVAdd (vSum, mol[n].rv);
vvSum += VLenSq (mol[n].rv);
}
vvsSum = 0.;
DO_MOL vvsSum += mInert * VLenSq (mol[n].sv);
vvSum += vvsSum;
kinEnergy.val = 0.5 * vvSum / nMol;
totEnergy.val = kinEnergy.val + uSum / nMol;
VZero (w);
DO_MOL VVAdd (w, mol[n].s);
dipoleOrder.val = VLen (w) / nMol;
}
void ComputeForcesDipoleR ()
{
VecR dr, w;
real a1, a2, a3, alpha2, d, irPi, rr, rrCut, rri, sr1, sr2, ss, t;
int j1, j2, n;
rrCut = Sqr (0.5 * region.x);
irPi = 1. / sqrt (M_PI);
alpha2 = Sqr (alpha);
DO_MOL VZero (mol[n].sa);
for (j1 = 0; j1 < nMol - 1; j1 ++) {
for (j2 = j1 + 1; j2 < nMol; j2 ++) {
VSub (dr, mol[j1].r, mol[j2].r);
VWrapAll (dr);
rr = VLenSq (dr);
if (rr < rrCut) {
d = sqrt (rr);
rri = 1. / rr;
t = 2. * dipoleInt * alpha * exp (- alpha2 * rr) * rri * irPi;
a1 = dipoleInt * erfc (alpha * d) * rri / d + t;
a2 = 3. * a1 * rri + 2. * alpha2 * t;
a3 = 5. * a2 * rri + 4. * Sqr (alpha2) * t;
ss = VDot (mol[j1].s, mol[j2].s);
sr1 = VDot (mol[j1].s, dr);
sr2 = VDot (mol[j2].s, dr);
VSSAdd (w, sr2, mol[j1].s, sr1, mol[j2].s);
t = (a2 * ss - a3 * sr1 * sr2);
VSSAdd (w, t, dr, a2, w);
VVAdd (mol[j1].ra, w);
VVSub (mol[j2].ra, w);
VVSAdd (mol[j1].sa, - a1, mol[j2].s);
VVSAdd (mol[j1].sa, a2 * sr2, dr);
VVSAdd (mol[j2].sa, - a1, mol[j1].s);
VVSAdd (mol[j2].sa, a2 * sr1, dr);
uSum += a1 * ss - a2 * sr1 * sr2;
}
}
}
uSum -= 2. * dipoleInt * Cube (alpha) * nMol * irPi / 3.;
}
