PmeRealSpace Class Reference

#include <PmeRealSpace.h>

Public Member Functions
	PmeRealSpace (PmeGrid grid)
	~PmeRealSpace ()
void	set_num_atoms (int natoms)
void	fill_charges (float **q_arr, float **q_arr_list, int &q_arr_count, int &stray_count, char *f_arr, char *fz_arr, PmeParticle p[])
void	compute_forces (const float *const *q_arr, const PmeParticle p[], Vector f[])
void	compute_forces_order4_partial (int first, int last, const float *const *q_arr, const PmeParticle p[], Vector f[])

Detailed Description

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Definition at line 14 of file PmeRealSpace.h.

Constructor & Destructor Documentation

PmeRealSpace()

PmeRealSpace::PmeRealSpace

(

PmeGrid

grid

)

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Definition at line 13 of file PmeRealSpace.C.

  : myGrid(grid) {
}

~PmeRealSpace()

PmeRealSpace::~PmeRealSpace

(

)

Definition at line 17 of file PmeRealSpace.C.

                            {
}

Member Function Documentation

compute_forces()

void PmeRealSpace::compute_forces	(	const float *const *	q_arr,
		const PmeParticle	p[],
		Vector	f[]
	)

Definition at line 141 of file PmeRealSpace.C.

References NAMD_die(), and PmeGrid::order.

Referenced by ComputePme::ungridForces().

                                                                   {

  switch (myGrid.order) {
  case 4:
    compute_forces_order4(q_arr, p, f);
    break;
  case 6:
    compute_forces_order<6>(q_arr, p, f);
    break;
  case 8:
    compute_forces_order<8>(q_arr, p, f);
    break;
  case 10:
    compute_forces_order<10>(q_arr, p, f);
    break;
  default: NAMD_die("unsupported PMEInterpOrder");
  }

}

compute_forces_order4_partial()

void PmeRealSpace::compute_forces_order4_partial	(	int	first,
		int	last,
		const float *const *	q_arr,
		const PmeParticle	p[],
		Vector	f[]
	)

Definition at line 426 of file PmeRealSpace.C.

References PmeParticle::cg, PmeGrid::dim2, PmeGrid::K1, PmeGrid::K2, PmeGrid::K3, order, Vector::x, Vector::y, and Vector::z.

Referenced by compute_forces_order4_helper().

                                                                   {
  
  int i, j, k, l, stride;
  float f1, f2, f3;
  float *Mi, *dMi;
  int K1, K2, K3, dim2;

  K1=myGrid.K1; K2=myGrid.K2; K3=myGrid.K3; dim2=myGrid.dim2;
  // order = myGrid.order;
  stride=3*order;
  Mi = M; dMi = dM;
 
  for (i=first; i<=last; i++) {
    Mi = M + i*stride;
    dMi = dM + i*stride;
    float q;
    int u1, u2, u2i, u3i;
    q = p[i].cg;
    f1=f2=f3=0.0;
    u1 = (int)(p[i].x);
    u2i = (int)(p[i].y);
    u3i = (int)(p[i].z);
    u1 -= order;
    u2i -= order;
    u3i -= order;
    u3i += 1;
    if ( u3i < 0 ) u3i += K3;
    for (j=0; j<order; j++) {
      float m1, d1;
      int ind1;
      m1=Mi[j]*q;
      d1=K1*dMi[j]*q;
      u1++;
      ind1 = (u1 + (u1 < 0 ? K1 : 0))*dim2; 
      u2 = u2i;
      for (k=0; k<order; k++) {
        float m2, d2, m1m2, m1d2, d1m2;
        int ind2;
        m2=Mi[order+k];
        d2=K2*dMi[order+k];
        m1m2=m1*m2;
        m1d2=m1*d2;
        d1m2=d1*m2;
        u2++;
        ind2 = ind1 + (u2 + (u2 < 0 ? K2 : 0));
        const float *qline = q_arr[ind2];
        if ( ! qline ) continue;
        for (l=0; l<order; l++) {
          float term, m3, d3;
          m3=Mi[2*order+l];
          d3=K3*dMi[2*order+l];
          term = qline[u3i+l];
          f1 -= d1m2 * m3 * term;
          f2 -= m1d2 * m3 * term;
          f3 -= m1m2 * d3 * term;
        }
      }
    }
    f[i].x = f1;
    f[i].y = f2;
    f[i].z = f3;
  }
}

fill_charges()

void PmeRealSpace::fill_charges	(	float **	q_arr,
		float **	q_arr_list,
		int &	q_arr_count,
		int &	stray_count,
		char *	f_arr,
		char *	fz_arr,
		PmeParticle	p[]
	)

Definition at line 47 of file PmeRealSpace.C.

References NAMD_die(), and PmeGrid::order.

Referenced by ComputePme::doWork().

                                                                                     {

  switch (myGrid.order) {
  case 4:
    fill_charges_order4(q_arr, q_arr_list, q_arr_count, stray_count, f_arr, fz_arr, p);
    break;
  case 6:
    fill_charges_order<6>(q_arr, q_arr_list, q_arr_count, stray_count, f_arr, fz_arr, p);
    break;
  case 8:
    fill_charges_order<8>(q_arr, q_arr_list, q_arr_count, stray_count, f_arr, fz_arr, p);
    break;
  case 10:
    fill_charges_order<10>(q_arr, q_arr_list, q_arr_count, stray_count, f_arr, fz_arr, p);
    break;
  default: NAMD_die("unsupported PMEInterpOrder");
  }

}

set_num_atoms()

void PmeRealSpace::set_num_atoms

(

int

natoms

)

Definition at line 20 of file PmeRealSpace.C.

References ResizeArray< Elem >::begin(), PmeGrid::order, order, and ResizeArray< Elem >::resize().

Referenced by ComputePme::doWork().

                                           {
  N = natoms;
  int order = myGrid.order;
  M_alloc.resize(3*N*order);
  M = M_alloc.begin();
  dM_alloc.resize(3*N*order);
  dM = dM_alloc.begin();
}

---

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

• PmeRealSpace.h
• PmeRealSpace.C