PmeKSpace.C File Reference

#include "PmeKSpace.h"
#include <math.h>
#include <stdlib.h>
#include <alloca.h>
#include "PmeBase.inl"
#include "SimParameters.h"
#include "Node.h"
#include "ComputeMoaMgr.decl.h"

Go to the source code of this file.

Macros
#define	ALLOCA(TYPE, NAME, SIZE)   TYPE *NAME = (TYPE *) alloca((SIZE)*sizeof(TYPE))

Functions
static void	dftmod (double *bsp_mod, double *bsp_arr, int nfft)
void	compute_b_moduli (double *bm, int K, int order)
static void	compute_energy_orthogonal_ckloop (int first, int last, void *result, int paraNum, void *param)

Macro Definition Documentation

#define ALLOCA	(		TYPE,
			NAME,
			SIZE
	)		TYPE *NAME = (TYPE *) alloca((SIZE)*sizeof(TYPE))

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

Definition at line 20 of file PmeKSpace.C.

Referenced by PmeKSpace::compute_energy_orthogonal_helper().

Function Documentation

void compute_b_moduli	(	double *	bm,
		int	K,
		int	order
	)

Definition at line 42 of file PmeKSpace.C.

References compute_b_spline(), dftmod(), and order.

Referenced by PmeKSpace::PmeKSpace(), and PmeKSpaceCompute::PmeKSpaceCompute().

                                                    {
  int i;
  double fr[3];

  double *M = new double[3*order];
  double *dM = new double[3*order];
  double *scratch = new double[K];

  fr[0]=fr[1]=fr[2]=0.0;
  compute_b_spline(fr,M,dM,order);  
  for (i=0; i<order; i++) bm[i] = M[i];
  for (i=order; i<K; i++) bm[i] = 0.0;
  dftmod(scratch, bm, K);
  for (i=0; i<K; i++) bm[i] = 1.0/scratch[i];


  delete [] scratch;
  delete [] dM;
  delete [] M;
}

static void compute_energy_orthogonal_ckloop ( int  first, int  last, void *  result, int  paraNum, void *  param  )

inlinestatic

Definition at line 214 of file PmeKSpace.C.

References PmeKSpace::compute_energy_orthogonal_subset().

Referenced by PmeKSpace::compute_energy_orthogonal_helper().

                                                                                                                {
  for ( int i = first; i <= last; ++i ) {
    void **params = (void **)param;
    PmeKSpace *kspace = (PmeKSpace *)params[0];
    float *q_arr = (float *)params[1];
    double *recips = (double *)params[2];
    double *partialEnergy = (double *)params[3];
    double *partialVirial = (double *)params[4];
    int *unitDist = (int *)params[5];
    
    int unit = unitDist[0];
    int remains = unitDist[1];
    int k1from, k1to;
    if(i<remains){
        k1from = i*(unit+1);
        k1to = k1from+unit;
    }else{
        k1from = remains*(unit+1)+(i-remains)*unit;
        k1to = k1from+unit-1;
    }
    double *pEnergy = partialEnergy+i;
    double *pVirial = partialVirial+i*6;
    kspace->compute_energy_orthogonal_subset(q_arr, recips, pVirial, pEnergy, k1from, k1to);
  }
}

static void dftmod ( double *  bsp_mod, double *  bsp_arr, int  nfft  )

static

Definition at line 22 of file PmeKSpace.C.

References M_PI.

Referenced by compute_b_moduli().

                                                               {
  int j, k;
  double twopi, arg, sum1, sum2;
  double infft = 1.0/nfft;
/* Computes the modulus of the discrete fourier transform of bsp_arr, */
/*  storing it into bsp_mod */
  twopi =  2.0 * M_PI;

  for (k = 0; k <nfft; ++k) {
    sum1 = 0.;
    sum2 = 0.;
    for (j = 0; j < nfft; ++j) {
      arg = twopi * k * j * infft;
      sum1 += bsp_arr[j] * cos(arg);
      sum2 += bsp_arr[j] * sin(arg);
    }
    bsp_mod[k] = sum1*sum1 + sum2*sum2;
  }
}