#include <LincsSolver.h>

Public Member Functions
void	setUpSolver (atomData , constraintTuple )
	interface to set up the solver with two given arrays of data. More...

void	solve ()
	interface to run the solver with CG. More...

	LincsSolver (int loop=10000, BigReal r=1e-12)

	~LincsSolver ()

Detailed Description

This class is for solving the long-chain constraints for the Martini model with LINCS algorithm by the conjugate gradient method.

Definition at line 13 of file LincsSolver.h.

Constructor & Destructor Documentation

◆ LincsSolver()

LincsSolver::LincsSolver	(	int	loop = `10000`,
		BigReal	r = `1e-12`
	)

inline

The constructor of the class.

Definition at line 52 of file LincsSolver.h.

52 : B(NULL), constraintList(NULL), globalIndex(NULL),

53 patchID(NULL), offset(NULL), inv_mass(NULL), ref(NULL), num_atoms(0), num_constraints(0), maxLoops(loop), tol(r) {}

◆ ~LincsSolver()

LincsSolver::~LincsSolver ( )

inline

Definition at line 54 of file LincsSolver.h.

     {
         destroy();
     }

Member Function Documentation

◆ setUpSolver()

void LincsSolver::setUpSolver	(	atomData *	data,
		constraintTuple *	constraints
	)

interface to set up the solver with two given arrays of data.

Definition at line 419 of file LincsSolver.C.

 {
     destroy();
     copy(data, constraints);
     sortAtom(0, num_atoms-1);
     sortConstraints();   
     buildBMatrix();
     #ifdef DEBUG
     showDataRead(data, constraints);
     checkConvergence();
     #endif
 }

◆ solve()

void LincsSolver::solve ( )

interface to run the solver with CG.

Definition at line 432 of file LincsSolver.C.

References constraintTuple::dist, constraintTuple::i, constraintTuple::j, and Malloc().

 {
     BigReal* b = (BigReal*)Malloc(sizeof(BigReal)*num_constraints);
     BigReal* x = (BigReal*)Malloc(sizeof(BigReal)*num_constraints);
     multiplyR(b, ref);
     for(int i = 0; i < num_constraints; ++i)
         b[i] -= constraintList[i].dist; 
     memset(x, 0 , sizeof(BigReal)*num_constraints);
     conjugateGradient(x, b);
     BigReal* tmp = (BigReal*)Malloc(sizeof(BigReal)*num_atoms*3);
     multiplyC(tmp, x);
     for(int i = 0; i < num_atoms; ++i)
     {
         BigReal m = inv_mass[i];
         ref[3*i+0] -= tmp[3*i+0]*m;
         ref[3*i+1] -= tmp[3*i+1]*m;
         ref[3*i+2] -= tmp[3*i+2]*m;
     }
     multiplyR(b, ref);
     for(int idx = 0; idx < num_constraints; ++idx)
     {
         int i = constraintList[idx].i;
         int j = constraintList[idx].j;
         BigReal d = constraintList[idx].dist;
         int col_i = Map(i);
         int col_j = Map(j);
         BigReal x1, x2, y1, y2, z1, z2;
         x1 = ref[3*col_i+0];
         x2 = ref[3*col_j+0];
         y1 = ref[3*col_i+1];
         y2 = ref[3*col_j+1];
         z1 = ref[3*col_i+2];
         z2 = ref[3*col_j+2];
         BigReal l = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)+(z1-z2)*(z1-z2);
 
         b[idx] -= sqrt(2.0*d*d-l);
     }
     memset(x, 0 , sizeof(BigReal)*num_constraints);
     conjugateGradient(x, b);
     multiplyC(tmp, x);
     for(int i = 0; i < num_atoms; ++i)
     {
         BigReal m = inv_mass[i];
         ref[3*i+0] -= tmp[3*i+0]*m;
         ref[3*i+1] -= tmp[3*i+1]*m;
         ref[3*i+2] -= tmp[3*i+2]*m;
     }
     #ifdef DEBUG
     checkConvergence();
     #endif
     free(b);
     free(x);
     free(tmp); 
 }

The documentation for this class was generated from the following files: