Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members

PmeKSpace.C File Reference

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

Go to the source code of this file.

Defines

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

Functions

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

Define 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 19 of file PmeKSpace.C.

Referenced by ProxyMgr::recvNodeAwareSpanningTree().

Function Documentation

void compute_b_moduli (  double *  bm,
int  K,
int  order
)  [static]
 

Definition at line 41 of file PmeKSpace.C.

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

Referenced by PmeKSpace::PmeKSpace().

00041                                                            {
00042   int i;
00043   double fr[3];
00044 
00045   double *M = new double[3*order];
00046   double *dM = new double[3*order];
00047   double *scratch = new double[K];
00048 
00049   fr[0]=fr[1]=fr[2]=0.0;
00050   compute_b_spline(fr,M,dM,order);  
00051   for (i=0; i<order; i++) bm[i] = M[i];
00052   for (i=order; i<K; i++) bm[i] = 0.0;
00053   dftmod(scratch, bm, K);
00054   for (i=0; i<K; i++) bm[i] = 1.0/scratch[i];
00055 
00056 
00057   delete [] scratch;
00058   delete [] dM;
00059   delete [] M;
00060 }

void compute_energy_orthogonal_nodehelper (  int  first,
int  last,
void *  result,
int  paraNum,
void *  param
)  [inline, static]
 

Definition at line 213 of file PmeKSpace.C.

References PmeKSpace::compute_energy_orthogonal_subset().

00213                                                                                                                     {
00214     CmiAssert(first==last);
00215     void **params = (void **)param;
00216     PmeKSpace *kspace = (PmeKSpace *)params[0];
00217     float *q_arr = (float *)params[1];
00218     double *recips = (double *)params[2];
00219     double *partialEnergy = (double *)params[3];
00220     double *partialVirial = (double *)params[4];
00221     int *unitDist = (int *)params[5];
00222     
00223     int i = first;
00224     int unit = unitDist[0];
00225     int remains = unitDist[1];
00226     int k1from, k1to;
00227     if(i<remains){
00228         k1from = i*(unit+1);
00229         k1to = k1from+unit;
00230     }else{
00231         k1from = remains*(unit+1)+(i-remains)*unit;
00232         k1to = k1from+unit-1;
00233     }
00234     double *pEnergy = partialEnergy+i;
00235     double *pVirial = partialVirial+i*6;
00236     kspace->compute_energy_orthogonal_subset(q_arr, recips, pVirial, pEnergy, k1from, k1to);
00237 }

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

Definition at line 21 of file PmeKSpace.C.

References j.

Referenced by compute_b_moduli().

00021                                                                {
00022   int j, k;
00023   double twopi, arg, sum1, sum2;
00024   double infft = 1.0/nfft;
00025 /* Computes the modulus of the discrete fourier transform of bsp_arr, */
00026 /*  storing it into bsp_mod */
00027   twopi =  2.0 * M_PI;
00028 
00029   for (k = 0; k <nfft; ++k) {
00030     sum1 = 0.;
00031     sum2 = 0.;
00032     for (j = 0; j < nfft; ++j) {
00033       arg = twopi * k * j * infft;
00034       sum1 += bsp_arr[j] * cos(arg);
00035       sum2 += bsp_arr[j] * sin(arg);
00036     }
00037     bsp_mod[k] = sum1*sum1 + sum2*sum2;
00038   }
00039 }

Generated on Fri May 25 04:07:18 2012 for NAMD by  doxygen 1.3.9.1