#include <ComputeNonbondedUtil.h>

Inheritance diagram for ComputeNonbondedUtil:

Public Types
enum	{ exclChecksumIndex, pairlistWarningIndex, electEnergyIndex, fullElectEnergyIndex, vdwEnergyIndex, fullVdwEnergyIndex, goNativeEnergyIndex, goNonnativeEnergyIndex, groLJEnergyIndex, groGaussEnergyIndex, electEnergyIndex_s, fullElectEnergyIndex_s, vdwEnergyIndex_s, electEnergyIndex_ti_1, fullElectEnergyIndex_ti_1, vdwEnergyIndex_ti_1, electEnergyIndex_ti_2, fullElectEnergyIndex_ti_2, vdwEnergyIndex_ti_2, TENSOR =(virialIndex), TENSOR =(virialIndex), VECTOR =(pairVDWForceIndex), VECTOR =(pairVDWForceIndex), reductionDataSize }

Public Member Functions
	ComputeNonbondedUtil ()

	~ComputeNonbondedUtil ()

void	calcGBIS (nonbonded params, GBISParamStruct gbisParams)

Static Public Member Functions
static void	select (void)

static void	submitReductionData (BigReal , SubmitReduction )

static void	submitPressureProfileData (BigReal , SubmitReduction )

static BigReal	square (const BigReal &x, const BigReal &y, const BigReal &z)

static void	calc_error (nonbonded *)

static void	calc_pair (nonbonded *)

static void	calc_pair_energy (nonbonded *)

static void	calc_pair_fullelect (nonbonded *)

static void	calc_pair_energy_fullelect (nonbonded *)

static void	calc_pair_merge_fullelect (nonbonded *)

static void	calc_pair_energy_merge_fullelect (nonbonded *)

static void	calc_pair_merge_fullelect_fulldisp (nonbonded *)

static void	calc_pair_energy_merge_fullelect_fulldisp (nonbonded *)

static void	calc_pair_slow_fullelect (nonbonded *)

static void	calc_pair_energy_slow_fullelect (nonbonded *)

static void	calc_self (nonbonded *)

static void	calc_self_energy (nonbonded *)

static void	calc_self_fullelect (nonbonded *)

static void	calc_self_energy_fullelect (nonbonded *)

static void	calc_self_merge_fullelect (nonbonded *)

static void	calc_self_energy_merge_fullelect (nonbonded *)

static void	calc_self_merge_fullelect_fulldisp (nonbonded *)

static void	calc_self_energy_merge_fullelect_fulldisp (nonbonded *)

static void	calc_self_slow_fullelect (nonbonded *)

static void	calc_self_energy_slow_fullelect (nonbonded *)

static void	calc_pair_energy_fep (nonbonded *)

static void	calc_pair_energy_fullelect_fep (nonbonded *)

static void	calc_pair_energy_merge_fullelect_fep (nonbonded *)

static void	calc_pair_energy_slow_fullelect_fep (nonbonded *)

static void	calc_self_energy_fep (nonbonded *)

static void	calc_self_energy_fullelect_fep (nonbonded *)

static void	calc_self_energy_merge_fullelect_fep (nonbonded *)

static void	calc_self_energy_slow_fullelect_fep (nonbonded *)

static void	calc_pair_energy_ti (nonbonded *)

static void	calc_pair_ti (nonbonded *)

static void	calc_pair_energy_fullelect_ti (nonbonded *)

static void	calc_pair_fullelect_ti (nonbonded *)

static void	calc_pair_energy_merge_fullelect_ti (nonbonded *)

static void	calc_pair_merge_fullelect_ti (nonbonded *)

static void	calc_pair_energy_slow_fullelect_ti (nonbonded *)

static void	calc_pair_slow_fullelect_ti (nonbonded *)

static void	calc_self_energy_ti (nonbonded *)

static void	calc_self_ti (nonbonded *)

static void	calc_self_energy_fullelect_ti (nonbonded *)

static void	calc_self_fullelect_ti (nonbonded *)

static void	calc_self_energy_merge_fullelect_ti (nonbonded *)

static void	calc_self_merge_fullelect_ti (nonbonded *)

static void	calc_self_energy_slow_fullelect_ti (nonbonded *)

static void	calc_self_slow_fullelect_ti (nonbonded *)

static void	calc_pair_les (nonbonded *)

static void	calc_pair_energy_les (nonbonded *)

static void	calc_pair_fullelect_les (nonbonded *)

static void	calc_pair_energy_fullelect_les (nonbonded *)

static void	calc_pair_merge_fullelect_les (nonbonded *)

static void	calc_pair_energy_merge_fullelect_les (nonbonded *)

static void	calc_pair_slow_fullelect_les (nonbonded *)

static void	calc_pair_energy_slow_fullelect_les (nonbonded *)

static void	calc_self_les (nonbonded *)

static void	calc_self_energy_les (nonbonded *)

static void	calc_self_fullelect_les (nonbonded *)

static void	calc_self_energy_fullelect_les (nonbonded *)

static void	calc_self_merge_fullelect_les (nonbonded *)

static void	calc_self_energy_merge_fullelect_les (nonbonded *)

static void	calc_self_slow_fullelect_les (nonbonded *)

static void	calc_self_energy_slow_fullelect_les (nonbonded *)

static void	calc_pair_energy_int (nonbonded *)

static void	calc_pair_energy_fullelect_int (nonbonded *)

static void	calc_pair_energy_merge_fullelect_int (nonbonded *)

static void	calc_self_energy_int (nonbonded *)

static void	calc_self_energy_fullelect_int (nonbonded *)

static void	calc_self_energy_merge_fullelect_int (nonbonded *)

static void	calc_pair_pprof (nonbonded *)

static void	calc_pair_energy_pprof (nonbonded *)

static void	calc_pair_fullelect_pprof (nonbonded *)

static void	calc_pair_energy_fullelect_pprof (nonbonded *)

static void	calc_pair_merge_fullelect_pprof (nonbonded *)

static void	calc_pair_energy_merge_fullelect_pprof (nonbonded *)

static void	calc_pair_slow_fullelect_pprof (nonbonded *)

static void	calc_pair_energy_slow_fullelect_pprof (nonbonded *)

static void	calc_self_pprof (nonbonded *)

static void	calc_self_energy_pprof (nonbonded *)

static void	calc_self_fullelect_pprof (nonbonded *)

static void	calc_self_energy_fullelect_pprof (nonbonded *)

static void	calc_self_merge_fullelect_pprof (nonbonded *)

static void	calc_self_energy_merge_fullelect_pprof (nonbonded *)

static void	calc_self_slow_fullelect_pprof (nonbonded *)

static void	calc_self_energy_slow_fullelect_pprof (nonbonded *)

static void	calc_pair_tabener (nonbonded *)

static void	calc_pair_energy_tabener (nonbonded *)

static void	calc_pair_fullelect_tabener (nonbonded *)

static void	calc_pair_energy_fullelect_tabener (nonbonded *)

static void	calc_pair_merge_fullelect_tabener (nonbonded *)

static void	calc_pair_energy_merge_fullelect_tabener (nonbonded *)

static void	calc_pair_slow_fullelect_tabener (nonbonded *)

static void	calc_pair_energy_slow_fullelect_tabener (nonbonded *)

static void	calc_self_tabener (nonbonded *)

static void	calc_self_energy_tabener (nonbonded *)

static void	calc_self_fullelect_tabener (nonbonded *)

static void	calc_self_energy_fullelect_tabener (nonbonded *)

static void	calc_self_merge_fullelect_tabener (nonbonded *)

static void	calc_self_energy_merge_fullelect_tabener (nonbonded *)

static void	calc_self_slow_fullelect_tabener (nonbonded *)

static void	calc_self_energy_slow_fullelect_tabener (nonbonded *)

static void	calc_pair_go (nonbonded *)

static void	calc_pair_energy_go (nonbonded *)

static void	calc_pair_fullelect_go (nonbonded *)

static void	calc_pair_energy_fullelect_go (nonbonded *)

static void	calc_pair_merge_fullelect_go (nonbonded *)

static void	calc_pair_energy_merge_fullelect_go (nonbonded *)

static void	calc_pair_slow_fullelect_go (nonbonded *)

static void	calc_pair_energy_slow_fullelect_go (nonbonded *)

static void	calc_self_go (nonbonded *)

static void	calc_self_energy_go (nonbonded *)

static void	calc_self_fullelect_go (nonbonded *)

static void	calc_self_energy_fullelect_go (nonbonded *)

static void	calc_self_merge_fullelect_go (nonbonded *)

static void	calc_self_energy_merge_fullelect_go (nonbonded *)

static void	calc_self_slow_fullelect_go (nonbonded *)

static void	calc_self_energy_slow_fullelect_go (nonbonded *)

Static Public Attributes
static void(*	calcPair )(nonbonded *)

static void(*	calcPairEnergy )(nonbonded *)

static void(*	calcSelf )(nonbonded *)

static void(*	calcSelfEnergy )(nonbonded *)

static void(*	calcFullPair )(nonbonded *)

static void(*	calcFullPairEnergy )(nonbonded *)

static void(*	calcFullSelf )(nonbonded *)

static void(*	calcFullSelfEnergy )(nonbonded *)

static void(*	calcMergePair )(nonbonded *)

static void(*	calcMergePairEnergy )(nonbonded *)

static void(*	calcMergeSelf )(nonbonded *)

static void(*	calcMergeSelfEnergy )(nonbonded *)

static void(*	calcMergeDispPair )(nonbonded *)

static void(*	calcMergeDispPairEnergy )(nonbonded *)

static void(*	calcMergeDispSelf )(nonbonded *)

static void(*	calcMergeDispSelfEnergy )(nonbonded *)

static void(*	calcSlowPair )(nonbonded *)

static void(*	calcSlowPairEnergy )(nonbonded *)

static void(*	calcSlowSelf )(nonbonded *)

static void(*	calcSlowSelfEnergy )(nonbonded *)

static Bool	commOnly

static Bool	fixedAtomsOn

static Bool	qmForcesOn

static BigReal	cutoff

static BigReal	cutoff2

static float	cutoff2_f

static BigReal	dielectric_1

static const LJTable *	ljTable = 0

static const Molecule *	mol

static BigReal	r2_delta

static BigReal	r2_delta_1

static int	rowsize

static int	columnsize

static int	r2_delta_exp

static BigReal *	table_alloc = 0

static BigReal *	table_ener = 0

static BigReal *	table_short

static BigReal *	table_noshort

static BigReal *	fast_table

static BigReal *	scor_table

static BigReal *	slow_table

static BigReal *	corr_table

static BigReal *	full_table

static BigReal *	vdwa_table

static BigReal *	vdwb_table

static BigReal *	r2_table

static int	table_length

static BigReal	scaling

static BigReal	scale14

static BigReal	switchOn

static BigReal	switchOn_1

static BigReal	switchOn2

static BigReal	v_vdwa

static BigReal	v_vdwb

static BigReal	k_vdwa

static BigReal	k_vdwb

static BigReal	cutoff_3

static BigReal	cutoff_6

static float	v_vdwa_f

static float	v_vdwb_f

static float	k_vdwa_f

static float	k_vdwb_f

static float	cutoff_3_f

static float	cutoff_6_f

static float	switchOn_f

static float	A6_f

static float	B6_f

static float	C6_f

static float	A12_f

static float	B12_f

static float	C12_f

static BigReal	c0

static BigReal	c1

static BigReal	c3

static BigReal	c5

static BigReal	c6

static BigReal	c7

static BigReal	c8

static Bool	alchFepOn

static Bool	alchThermIntOn

static Bool	alchWCAOn

static BigReal	alchVdwShiftCoeff

static Bool	vdwForceSwitching

static Bool	alchDecouple

static Bool	lesOn

static int	lesFactor

static BigReal	lesScaling

static BigReal *	lambda_table = 0

static Bool	pairInteractionOn

static Bool	pairInteractionSelf

static Bool	pressureProfileOn

static int	pressureProfileSlabs

static int	pressureProfileAtomTypes

static BigReal	pressureProfileThickness

static BigReal	pressureProfileMin

static Bool	accelMDOn

static Bool	drudeNbthole

static BigReal	ewaldcof

static BigReal	pi_ewaldcof

static BigReal	LJewaldcof

static int	vdw_switch_mode

static Bool	goGroPair

static Bool	goForcesOn

static int	goMethod

Detailed Description

Definition at line 240 of file ComputeNonbondedUtil.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
exclChecksumIndex
pairlistWarningIndex
electEnergyIndex
fullElectEnergyIndex
vdwEnergyIndex
fullVdwEnergyIndex
goNativeEnergyIndex
goNonnativeEnergyIndex
groLJEnergyIndex
groGaussEnergyIndex
electEnergyIndex_s
fullElectEnergyIndex_s
vdwEnergyIndex_s
electEnergyIndex_ti_1
fullElectEnergyIndex_ti_1
vdwEnergyIndex_ti_1
electEnergyIndex_ti_2
fullElectEnergyIndex_ti_2
vdwEnergyIndex_ti_2
TENSOR
TENSOR
VECTOR
VECTOR
reductionDataSize

Definition at line 274 of file ComputeNonbondedUtil.h.

        { exclChecksumIndex, pairlistWarningIndex,
          electEnergyIndex, fullElectEnergyIndex, vdwEnergyIndex, fullVdwEnergyIndex,
          goNativeEnergyIndex, goNonnativeEnergyIndex, groLJEnergyIndex, groGaussEnergyIndex,
 //sd-db
          electEnergyIndex_s, fullElectEnergyIndex_s, vdwEnergyIndex_s,
          electEnergyIndex_ti_1, fullElectEnergyIndex_ti_1, vdwEnergyIndex_ti_1,
          electEnergyIndex_ti_2, fullElectEnergyIndex_ti_2, vdwEnergyIndex_ti_2,
 //sd-de
          TENSOR(virialIndex), TENSOR(fullElectVirialIndex),
          VECTOR(pairVDWForceIndex), VECTOR(pairElectForceIndex),
          reductionDataSize };

Constructor & Destructor Documentation

◆ ComputeNonbondedUtil()

ComputeNonbondedUtil::ComputeNonbondedUtil ( )

inline

Definition at line 244 of file ComputeNonbondedUtil.h.

244 {}

◆ ~ComputeNonbondedUtil()

ComputeNonbondedUtil::~ComputeNonbondedUtil ( )

inline

Definition at line 245 of file ComputeNonbondedUtil.h.

245 {}

Member Function Documentation

◆ calc_error()

void ComputeNonbondedUtil::calc_error ( nonbonded * )

static

Definition at line 252 of file ComputeNonbondedUtil.C.

References NAMD_bug().

Referenced by select().

                                                  {
   NAMD_bug("Tried to call missing nonbonded compute routine.");
 }

◆ calc_pair()

static void ComputeNonbondedUtil::calc_pair ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy()

static void ComputeNonbondedUtil::calc_pair_energy ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_fep()

static void ComputeNonbondedUtil::calc_pair_energy_fep ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_fullelect()

static void ComputeNonbondedUtil::calc_pair_energy_fullelect ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_fullelect_fep()

static void ComputeNonbondedUtil::calc_pair_energy_fullelect_fep ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_fullelect_go()

static void ComputeNonbondedUtil::calc_pair_energy_fullelect_go ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_fullelect_int()

static void ComputeNonbondedUtil::calc_pair_energy_fullelect_int ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_fullelect_les()

static void ComputeNonbondedUtil::calc_pair_energy_fullelect_les ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_fullelect_pprof()

static void ComputeNonbondedUtil::calc_pair_energy_fullelect_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_fullelect_tabener()

static void ComputeNonbondedUtil::calc_pair_energy_fullelect_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_fullelect_ti()

static void ComputeNonbondedUtil::calc_pair_energy_fullelect_ti ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_go()

static void ComputeNonbondedUtil::calc_pair_energy_go ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_int()

static void ComputeNonbondedUtil::calc_pair_energy_int ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_les()

static void ComputeNonbondedUtil::calc_pair_energy_les ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_merge_fullelect()

static void ComputeNonbondedUtil::calc_pair_energy_merge_fullelect ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_merge_fullelect_fep()

static void ComputeNonbondedUtil::calc_pair_energy_merge_fullelect_fep ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_merge_fullelect_fulldisp()

static void ComputeNonbondedUtil::calc_pair_energy_merge_fullelect_fulldisp ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_merge_fullelect_go()

static void ComputeNonbondedUtil::calc_pair_energy_merge_fullelect_go ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_merge_fullelect_int()

static void ComputeNonbondedUtil::calc_pair_energy_merge_fullelect_int ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_merge_fullelect_les()

static void ComputeNonbondedUtil::calc_pair_energy_merge_fullelect_les ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_merge_fullelect_pprof()

static void ComputeNonbondedUtil::calc_pair_energy_merge_fullelect_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_merge_fullelect_tabener()

static void ComputeNonbondedUtil::calc_pair_energy_merge_fullelect_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_merge_fullelect_ti()

static void ComputeNonbondedUtil::calc_pair_energy_merge_fullelect_ti ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_pprof()

static void ComputeNonbondedUtil::calc_pair_energy_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_slow_fullelect()

static void ComputeNonbondedUtil::calc_pair_energy_slow_fullelect ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_slow_fullelect_fep()

static void ComputeNonbondedUtil::calc_pair_energy_slow_fullelect_fep ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_slow_fullelect_go()

static void ComputeNonbondedUtil::calc_pair_energy_slow_fullelect_go ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_slow_fullelect_les()

static void ComputeNonbondedUtil::calc_pair_energy_slow_fullelect_les ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_slow_fullelect_pprof()

static void ComputeNonbondedUtil::calc_pair_energy_slow_fullelect_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_slow_fullelect_tabener()

static void ComputeNonbondedUtil::calc_pair_energy_slow_fullelect_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_slow_fullelect_ti()

static void ComputeNonbondedUtil::calc_pair_energy_slow_fullelect_ti ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_tabener()

static void ComputeNonbondedUtil::calc_pair_energy_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_pair_energy_ti()

static void ComputeNonbondedUtil::calc_pair_energy_ti ( nonbonded * )

static

Referenced by select().

◆ calc_pair_fullelect()

static void ComputeNonbondedUtil::calc_pair_fullelect ( nonbonded * )

static

Referenced by select().

◆ calc_pair_fullelect_go()

static void ComputeNonbondedUtil::calc_pair_fullelect_go ( nonbonded * )

static

Referenced by select().

◆ calc_pair_fullelect_les()

static void ComputeNonbondedUtil::calc_pair_fullelect_les ( nonbonded * )

static

Referenced by select().

◆ calc_pair_fullelect_pprof()

static void ComputeNonbondedUtil::calc_pair_fullelect_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_pair_fullelect_tabener()

static void ComputeNonbondedUtil::calc_pair_fullelect_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_pair_fullelect_ti()

static void ComputeNonbondedUtil::calc_pair_fullelect_ti ( nonbonded * )

static

Referenced by select().

◆ calc_pair_go()

static void ComputeNonbondedUtil::calc_pair_go ( nonbonded * )

static

Referenced by select().

◆ calc_pair_les()

static void ComputeNonbondedUtil::calc_pair_les ( nonbonded * )

static

Referenced by select().

◆ calc_pair_merge_fullelect()

static void ComputeNonbondedUtil::calc_pair_merge_fullelect ( nonbonded * )

static

Referenced by select().

◆ calc_pair_merge_fullelect_fulldisp()

static void ComputeNonbondedUtil::calc_pair_merge_fullelect_fulldisp ( nonbonded * )

static

Referenced by select().

◆ calc_pair_merge_fullelect_go()

static void ComputeNonbondedUtil::calc_pair_merge_fullelect_go ( nonbonded * )

static

Referenced by select().

◆ calc_pair_merge_fullelect_les()

static void ComputeNonbondedUtil::calc_pair_merge_fullelect_les ( nonbonded * )

static

Referenced by select().

◆ calc_pair_merge_fullelect_pprof()

static void ComputeNonbondedUtil::calc_pair_merge_fullelect_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_pair_merge_fullelect_tabener()

static void ComputeNonbondedUtil::calc_pair_merge_fullelect_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_pair_merge_fullelect_ti()

static void ComputeNonbondedUtil::calc_pair_merge_fullelect_ti ( nonbonded * )

static

Referenced by select().

◆ calc_pair_pprof()

static void ComputeNonbondedUtil::calc_pair_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_pair_slow_fullelect()

static void ComputeNonbondedUtil::calc_pair_slow_fullelect ( nonbonded * )

static

Referenced by select().

◆ calc_pair_slow_fullelect_go()

static void ComputeNonbondedUtil::calc_pair_slow_fullelect_go ( nonbonded * )

static

Referenced by select().

◆ calc_pair_slow_fullelect_les()

static void ComputeNonbondedUtil::calc_pair_slow_fullelect_les ( nonbonded * )

static

Referenced by select().

◆ calc_pair_slow_fullelect_pprof()

static void ComputeNonbondedUtil::calc_pair_slow_fullelect_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_pair_slow_fullelect_tabener()

static void ComputeNonbondedUtil::calc_pair_slow_fullelect_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_pair_slow_fullelect_ti()

static void ComputeNonbondedUtil::calc_pair_slow_fullelect_ti ( nonbonded * )

static

Referenced by select().

◆ calc_pair_tabener()

static void ComputeNonbondedUtil::calc_pair_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_pair_ti()

static void ComputeNonbondedUtil::calc_pair_ti ( nonbonded * )

static

Referenced by select().

◆ calc_self()

static void ComputeNonbondedUtil::calc_self ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy()

static void ComputeNonbondedUtil::calc_self_energy ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_fep()

static void ComputeNonbondedUtil::calc_self_energy_fep ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_fullelect()

static void ComputeNonbondedUtil::calc_self_energy_fullelect ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_fullelect_fep()

static void ComputeNonbondedUtil::calc_self_energy_fullelect_fep ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_fullelect_go()

static void ComputeNonbondedUtil::calc_self_energy_fullelect_go ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_fullelect_int()

static void ComputeNonbondedUtil::calc_self_energy_fullelect_int ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_fullelect_les()

static void ComputeNonbondedUtil::calc_self_energy_fullelect_les ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_fullelect_pprof()

static void ComputeNonbondedUtil::calc_self_energy_fullelect_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_fullelect_tabener()

static void ComputeNonbondedUtil::calc_self_energy_fullelect_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_fullelect_ti()

static void ComputeNonbondedUtil::calc_self_energy_fullelect_ti ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_go()

static void ComputeNonbondedUtil::calc_self_energy_go ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_int()

static void ComputeNonbondedUtil::calc_self_energy_int ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_les()

static void ComputeNonbondedUtil::calc_self_energy_les ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_merge_fullelect()

static void ComputeNonbondedUtil::calc_self_energy_merge_fullelect ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_merge_fullelect_fep()

static void ComputeNonbondedUtil::calc_self_energy_merge_fullelect_fep ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_merge_fullelect_fulldisp()

static void ComputeNonbondedUtil::calc_self_energy_merge_fullelect_fulldisp ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_merge_fullelect_go()

static void ComputeNonbondedUtil::calc_self_energy_merge_fullelect_go ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_merge_fullelect_int()

static void ComputeNonbondedUtil::calc_self_energy_merge_fullelect_int ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_merge_fullelect_les()

static void ComputeNonbondedUtil::calc_self_energy_merge_fullelect_les ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_merge_fullelect_pprof()

static void ComputeNonbondedUtil::calc_self_energy_merge_fullelect_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_merge_fullelect_tabener()

static void ComputeNonbondedUtil::calc_self_energy_merge_fullelect_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_merge_fullelect_ti()

static void ComputeNonbondedUtil::calc_self_energy_merge_fullelect_ti ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_pprof()

static void ComputeNonbondedUtil::calc_self_energy_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_slow_fullelect()

static void ComputeNonbondedUtil::calc_self_energy_slow_fullelect ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_slow_fullelect_fep()

static void ComputeNonbondedUtil::calc_self_energy_slow_fullelect_fep ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_slow_fullelect_go()

static void ComputeNonbondedUtil::calc_self_energy_slow_fullelect_go ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_slow_fullelect_les()

static void ComputeNonbondedUtil::calc_self_energy_slow_fullelect_les ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_slow_fullelect_pprof()

static void ComputeNonbondedUtil::calc_self_energy_slow_fullelect_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_slow_fullelect_tabener()

static void ComputeNonbondedUtil::calc_self_energy_slow_fullelect_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_slow_fullelect_ti()

static void ComputeNonbondedUtil::calc_self_energy_slow_fullelect_ti ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_tabener()

static void ComputeNonbondedUtil::calc_self_energy_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_self_energy_ti()

static void ComputeNonbondedUtil::calc_self_energy_ti ( nonbonded * )

static

Referenced by select().

◆ calc_self_fullelect()

static void ComputeNonbondedUtil::calc_self_fullelect ( nonbonded * )

static

Referenced by select().

◆ calc_self_fullelect_go()

static void ComputeNonbondedUtil::calc_self_fullelect_go ( nonbonded * )

static

Referenced by select().

◆ calc_self_fullelect_les()

static void ComputeNonbondedUtil::calc_self_fullelect_les ( nonbonded * )

static

Referenced by select().

◆ calc_self_fullelect_pprof()

static void ComputeNonbondedUtil::calc_self_fullelect_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_self_fullelect_tabener()

static void ComputeNonbondedUtil::calc_self_fullelect_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_self_fullelect_ti()

static void ComputeNonbondedUtil::calc_self_fullelect_ti ( nonbonded * )

static

Referenced by select().

◆ calc_self_go()

static void ComputeNonbondedUtil::calc_self_go ( nonbonded * )

static

Referenced by select().

◆ calc_self_les()

static void ComputeNonbondedUtil::calc_self_les ( nonbonded * )

static

Referenced by select().

◆ calc_self_merge_fullelect()

static void ComputeNonbondedUtil::calc_self_merge_fullelect ( nonbonded * )

static

Referenced by select().

◆ calc_self_merge_fullelect_fulldisp()

static void ComputeNonbondedUtil::calc_self_merge_fullelect_fulldisp ( nonbonded * )

static

Referenced by select().

◆ calc_self_merge_fullelect_go()

static void ComputeNonbondedUtil::calc_self_merge_fullelect_go ( nonbonded * )

static

Referenced by select().

◆ calc_self_merge_fullelect_les()

static void ComputeNonbondedUtil::calc_self_merge_fullelect_les ( nonbonded * )

static

Referenced by select().

◆ calc_self_merge_fullelect_pprof()

static void ComputeNonbondedUtil::calc_self_merge_fullelect_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_self_merge_fullelect_tabener()

static void ComputeNonbondedUtil::calc_self_merge_fullelect_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_self_merge_fullelect_ti()

static void ComputeNonbondedUtil::calc_self_merge_fullelect_ti ( nonbonded * )

static

Referenced by select().

◆ calc_self_pprof()

static void ComputeNonbondedUtil::calc_self_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_self_slow_fullelect()

static void ComputeNonbondedUtil::calc_self_slow_fullelect ( nonbonded * )

static

Referenced by select().

◆ calc_self_slow_fullelect_go()

static void ComputeNonbondedUtil::calc_self_slow_fullelect_go ( nonbonded * )

static

Referenced by select().

◆ calc_self_slow_fullelect_les()

static void ComputeNonbondedUtil::calc_self_slow_fullelect_les ( nonbonded * )

static

Referenced by select().

◆ calc_self_slow_fullelect_pprof()

static void ComputeNonbondedUtil::calc_self_slow_fullelect_pprof ( nonbonded * )

static

Referenced by select().

◆ calc_self_slow_fullelect_tabener()

static void ComputeNonbondedUtil::calc_self_slow_fullelect_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_self_slow_fullelect_ti()

static void ComputeNonbondedUtil::calc_self_slow_fullelect_ti ( nonbonded * )

static

Referenced by select().

◆ calc_self_tabener()

static void ComputeNonbondedUtil::calc_self_tabener ( nonbonded * )

static

Referenced by select().

◆ calc_self_ti()

static void ComputeNonbondedUtil::calc_self_ti ( nonbonded * )

static

Referenced by select().

◆ calcGBIS()

void ComputeNonbondedUtil::calcGBIS	(	nonbonded *	params,
		GBISParamStruct *	gbisParams
	)

Definition at line 261 of file ComputeGBIS.C.

References GBISParamStruct::a_cut, GBISParamStruct::bornRad, CalcDHPair(), CalcHPair(), CompAtom::charge, COULOMB, GBISParamStruct::cutoff, DA, DB, DC, DD, DE, GBISParamStruct::dEdaSum, GBISParamStruct::dHdrPrefix, GBISParamStruct::doEnergy, GBISParamStruct::doFullElectrostatics, GBISParamStruct::doSmoothing, GBISParamStruct::epsilon_p, GBISParamStruct::epsilon_s, nonbonded::ff, FS_MAX, nonbonded::fullf, GBISParamStruct::gbInterEnergy, GBISParamStruct::gbisPhase, GBISParamStruct::gbisStepPairlists, GBISParamStruct::gbSelfEnergy, h1(), h2(), CompAtomExt::id, GBISParamStruct::intRad, GBISParamStruct::kappa, nonbonded::minPart, Pairlists::nextlist(), CompAtom::nonbondedGroupSize, nonbonded::numAtoms, nonbonded::numParts, GBISParamStruct::numPatches, nonbonded::offset, nonbonded::p, pairlistFromAll(), nonbonded::pExt, CompAtom::position, GBISParamStruct::psiSum, Pairlists::reset(), scaling, GBISParamStruct::sequence, TA, TB, TC, TD, TE, Vector::x, Vector::y, Vector::z, and ZERO.

Referenced by ComputeNonbondedPair::doForce(), and ComputeNonbondedSelf::doForce().

                                                                                   {
 //CkPrintf("SEQ%03i, P%i, CID%05i(%02i,%02i) ENTER\n",gbisParams->sequence,gbisParams->gbisPhase,gbisParams->cid,gbisParams->patchID[0],gbisParams->patchID[1]);
 #if CHECK_PRIORITIES
 CkPrintf("PE%i, S%09i, P%i\n",CkMyPe(),gbisParams->sequence,gbisParams->gbisPhase);
 #endif
   if (params->numAtoms[0] == 0 || params->numAtoms[1] == 0) return;
 
   const BigReal offset_x = params->offset.x;
   const BigReal offset_y = params->offset.y;
   const BigReal offset_z = params->offset.z;
 
   int partSize = params->numAtoms[0] / params->numParts;
   int minIg = 0;
   for (int s = 0; s < params->minPart; s++) {
     minIg+=params->p[0][minIg].nonbondedGroupSize;
   }
   int maxI = params->numAtoms[0];
   int strideIg = params->numParts;
 
   int unique = (gbisParams->numPatches == 1) ? 1 : 0;//should inner loop be unique from ourter loop
   int numGBISPairlists = 4;
   float r_cut = gbisParams->cutoff;
   float fsMax = FS_MAX; // gbisParams->fsMax;//FS_MAX;
   float a_cut = gbisParams->a_cut-fsMax;
   float a_cut2 = a_cut*a_cut;
   float a_cut_ps = a_cut + fsMax;//max screen radius
   float r_cut2 = r_cut*r_cut;
   float a_cut_ps2 = a_cut_ps*a_cut_ps;
   //put PL pointer back to beginning of lists
   for (int k = 0; k < numGBISPairlists; k++)
     gbisParams->gbisStepPairlists[k]->reset();
       
 
 /***********************************************************
 * GBIS Phase 1
 ***********************************************************/
 if (gbisParams->gbisPhase == 1) {
 //CkPrintf("SEQ%03i, P%i, CID%05i(%02i,%02i):[%03i,%03i]\n",gbisParams->sequence,gbisParams->gbisPhase,gbisParams->cid,gbisParams->patchID[0],gbisParams->patchID[1],minI,maxI);
 
   pairlistFromAll(params,gbisParams,minIg,strideIg,maxI);
 
 #ifdef BENCHMARK
   int nops = 0;
   int domains[] = {0, 0, 0, 0, 0, 0, 0, 0};
   int numDom = 7;
   double t1 = 1.0*clock()/CLOCKS_PER_SEC;
 #endif
   register GBReal psiI;
 
   register float dr;
   register float r2;
   register float r, r_i, r2_i;
   float rhoi0, rhois, rhojs, rhoj0;
   Position ri, rj;
   register int j;
   int numPairs;
   register float ta = TA;
   register float tb = TB;
   register float tc = TC;
   register float td = TD;
   register float te = TE;
 
   register float hij,hji;
   int dij,dji;
   float k;
   float rhois2, rhojs2;
 
   //calculate piecewise-22 Pairs
   int c = 0;
   for (int ngi = minIg; ngi < maxI;  ) {
     int iGroupSize = params->p[0][ngi].nonbondedGroupSize;
   for (int i = ngi; i < ngi+iGroupSize; i++) {
     ri = params->p[0][i].position;
     ri.x += offset_x;
     ri.y += offset_y;
     ri.z += offset_z;
     rhoi0 = gbisParams->intRad[0][2*i+0];
     rhois = gbisParams->intRad[0][2*i+1];
     rhois2 = rhois*rhois;
     psiI = ZERO;
     plint *pairs;
     gbisParams->gbisStepPairlists[c]->nextlist(&pairs,&numPairs);
     for (register int jj = 0; jj < numPairs; jj++) {
 #ifdef BENCHMARK
       nops++;
 #endif
       j = pairs[jj];
       rj = params->p[1][j].position;
 
       dr = (ri.x - rj.x);
       r2 = dr*dr;
       dr = (ri.y - rj.y);
       r2 += dr*dr;
       dr = (ri.z - rj.z);
       r2 += dr*dr;
       r2_i = 1.0/r2;
 
       rhoj0 = gbisParams->intRad[1][2*j+0];
       rhojs = gbisParams->intRad[1][2*j+1];
       rhojs2 = rhojs*rhojs;
 
       k = rhojs2*r2_i;//k=(rs/r)^2
       hij = rhojs*r2_i*k*(ta+k*(tb+k*(tc+k*(td+k*te))));
 
       k = rhois2*r2_i;//k=(rs/r)^2
       hji = rhois*r2_i*k*(ta+k*(tb+k*(tc+k*(td+k*te))));
 
 //#if 1
 #ifdef PRINT_COMP
       int id1 = params->pExt[0][i].id;
       int id2 = params->pExt[1][j].id;
       float h1 = hij;
       float h2 = hji;
       float r10 = rhoi0;
       float r1s = rhojs;
       float r20 = rhoj0;
       float r2s = rhois;
 /*printf("PSIPAIR %05i %05i%9.5f%6.3f%6.3f%2i% 13.5e\n",
 id1,id2,sqrt(r2),
 rhoi0, rhojs,
 2,hij);
 printf("PSIPAIR %05i %05i%9.5f%6.3f%6.3f%2i% 13.5e\n",
 id2,id1,sqrt(r2),
 rhoj0, rhois,
 2,hji);
 */
       if (id1 > id2) {
         int tmp = id1;
         id1 = id2;
         id2 = tmp;
         h1 = hji;
         h2 = hij;
         r20 = rhoi0;
         r2s = rhojs;
         r10 = rhoj0;
         r1s = rhois;
       }
 //      CkPrintf("PSIPAIR%5i%5i%10.5f%5i%14.8f%7.4f%7.4f\n",id1,id2,sqrt(r2),2,h1,r10,r1s);
 //      CkPrintf("PSIPAIR%5i%5i%10.5f%5i%14.8f%7.4f%7.4f\n",id2,id1,sqrt(r2),2,h2,r20,r2s);
       //CkPrintf("PPSI(%04i)[%04i,%04i] = 22\n",gbisParams->cid,id1,id2);
 #endif
 
       psiI += hij;
       gbisParams->psiSum[1][j] += hji;
     }//end inner j
     gbisParams->psiSum[0][i] += psiI;
   }//end outer i
   for (int s = 0; s < strideIg; s++) {
     ngi+=params->p[0][ngi].nonbondedGroupSize;
   }
   }
 #ifdef BENCHMARK
   double t2 = 1.0*clock()/CLOCKS_PER_SEC;
   //nops *= (9 + 2*DIV_FLOPS+SQRT_FLOPS) + (14 + 0*DIV_FLOPS + 0*LOG_FLOPS);
   //double flops = 1.0 * nops / (t2 - t1);
   //double gflops = flops / 1000000000.0;
   CkPrintf("PHASE1.1: %8.3f ms @ %8.3f ns/iter for %i iter\n",1000.0*(t2-t1), 1000000000.0*(t2-t1)/nops, nops);
 nops = 0;
   t1 = 1.0*clock()/CLOCKS_PER_SEC;
   nops = 0;
 #endif
 
   float rmris, rmrjs;
   float rmrsi;
   float rmrs2;
   float rs2;
   float logri, logrj;
   float rci2;
   float a_cut_i = 1.0 / a_cut;
   float a_cut_i2 = a_cut_i*a_cut_i;
 
   //calculate piecewise-11 pairs
   c = 1;
   for (int ngi = minIg; ngi < maxI;  ) {
     int iGroupSize = params->p[0][ngi].nonbondedGroupSize;
   for (int i = ngi; i < ngi+iGroupSize; i++) {
     ri = params->p[0][i].position;
     ri.x += offset_x;
     ri.y += offset_y;
     ri.z += offset_z;
     rhoi0 = gbisParams->intRad[0][2*i+0];
     rhois = gbisParams->intRad[0][2*i+1];
     psiI = ZERO;
     plint *pairs;
     gbisParams->gbisStepPairlists[c]->nextlist(&pairs,&numPairs);
     for (register int jj = 0; jj < numPairs; jj++) {
       j = pairs[jj];
       rj = params->p[1][j].position;
 
       dr = (ri.x - rj.x);
       r2 = dr*dr;
       dr = (ri.y - rj.y);
       r2 += dr*dr;
       dr = (ri.z - rj.z);
       r2 += dr*dr;
       r_i = 1.0/sqrt(r2);
       r = r2*r_i;
 
       rhoj0 = gbisParams->intRad[1][2*j+0];
       rhojs = gbisParams->intRad[1][2*j+1];
 
       float tmp1 = 0.125*r_i;
       float tmp2 = r2 - 4.0*a_cut*r;
       float rr = 2.0*r;
 
 
       rmrjs = r-rhojs;
       rmris = r-rhois;
       logri = log(rmris*a_cut_i);
       logrj = log(rmrjs*a_cut_i);
 
       rmrsi = 1.0/rmrjs;
       //rmrs2 = rmrjs*rmrjs;
       rs2 = rhojs*rhojs;
       hij = /*0.125*r_i*/tmp1*(1 + rr*rmrsi +
         a_cut_i2*(/*r2 - 4.0*a_cut*r*/tmp2 - rs2) + logrj+logrj);
 
 
       rmrsi = 1.0/rmris;
       //rmrs2 = rmris*rmris;
       rs2 = rhois*rhois;
       hji = /*0.125*r_i*/tmp1*(1 + rr*rmrsi +
         a_cut_i2*(/*r2 - 4.0*a_cut*r*/tmp2 - rs2) + 2.0* logri);
 //#if 1
 #ifdef PRINT_COMP
       int id1 = params->pExt[0][i].id;
       int id2 = params->pExt[1][j].id;
       float h1 = hij;
       float h2 = hji;
       float r10 = rhoi0;
       float r1s = rhojs;
       float r20 = rhoj0;
       float r2s = rhois;
 /*printf("PSIPAIR %05i %05i%9.5f%6.3f%6.3f%2i% 13.5e\n",
 id1,id2,sqrt(r2),
 rhoi0, rhojs,
 1,hij);
 printf("PSIPAIR %05i %05i%9.5f%6.3f%6.3f%2i% 13.5e\n",
 id2,id1,sqrt(r2),
 rhoj0, rhois,
 1,hji);*/
       if (id1 > id2) {
         int tmp = id1;
         id1 = id2;
         id2 = tmp;
         h1 = hji;
         h2 = hij;
         r20 = rhoi0;
         r2s = rhojs;
         r10 = rhoj0;
         r1s = rhois;
       }
 //      CkPrintf("PSIPAIR%5i%5i%10.5f%5i%14.8f%7.4f%7.4f\n",id1,id2,sqrt(r2),1,h1,r10,r1s);
 //      CkPrintf("PSIPAIR%5i%5i%10.5f%5i%14.8f%7.4f%7.4f\n",id2,id1,sqrt(r2),1,h2,r20,r2s);
       //CkPrintf("PSI(%04i)[%04i,%04i] = 11 % .4e % .4e\n",gbisParams->sequence,id1,id2,h1, h2);
       //CkPrintf("PPSI(%04i)[%04i,%04i] = 11\n",gbisParams->cid,id1,id2);
 #endif
 
 #ifdef BENCHMARK
       nops++;
 #endif
           
       psiI += hij;
       gbisParams->psiSum[1][j] += hji;
     }//end inner j
     gbisParams->psiSum[0][i] += psiI;
   }//end outer i
   for (int s = 0; s < strideIg; s++) {
     ngi+=params->p[0][ngi].nonbondedGroupSize;
   }
   }
 #ifdef BENCHMARK
   t2 = 1.0*clock()/CLOCKS_PER_SEC;
   CkPrintf("PHASE1.2: %8.3f ms @ %8.3f ns/iter for %i iter\n",1000.0*(t2-t1), 1000000000.0*(t2-t1)/nops, nops);
 nops = 0;
   t1 = 1.0*clock()/CLOCKS_PER_SEC;
   nops = 0;
 #endif
 
   //calculate all other piecewise pairs
   c = 2;
   for (int ngi = minIg; ngi < maxI;  ) {
     int iGroupSize = params->p[0][ngi].nonbondedGroupSize;
   for (int i = ngi; i < ngi+iGroupSize; i++) {
     ri = params->p[0][i].position;
     ri.x += offset_x;
     ri.y += offset_y;
     ri.z += offset_z;
     rhoi0 = gbisParams->intRad[0][2*i+0];
     rhois = gbisParams->intRad[0][2*i+1];
     psiI = ZERO;
     plint *pairs;
     gbisParams->gbisStepPairlists[c]->nextlist(&pairs,&numPairs);
     for (register int jj = 0; jj < numPairs; jj++) {
       j = pairs[jj];
       rj = params->p[1][j].position;
 
       dr = (ri.x - rj.x);
       r2 = dr*dr;
       dr = (ri.y - rj.y);
       r2 += dr*dr;
       dr = (ri.z - rj.z);
       r2 += dr*dr;
       rhojs = gbisParams->intRad[1][2*j+1];
       rhoj0 = gbisParams->intRad[1][2*j+0];
       r_i = 1.0/sqrt(r2);
       r = r2 * r_i;
 
       CalcHPair(r,r2,r_i,a_cut,
           rhoi0, rhojs,
           rhoj0, rhois,
           dij,dji,hij,hji);
 //#if 1
 #ifdef PRINT_COMP
       int id1 = params->pExt[0][i].id;
       int id2 = params->pExt[1][j].id;
       float h1 = hij;
       float h2 = hji;
       int d1 = dij;
       int d2 = dji;
       float r10 = rhoi0;
       float r1s = rhojs;
       float r20 = rhoj0;
       float r2s = rhois;
 /*  if (dij > 0 ) {
 printf("PSIPAIR %05i %05i%9.5f%6.3f%6.3f%2i% 13.5e\n",
 id1,id2,sqrt(r2),
 rhoi0, rhojs,
 dij,hij);
   }
   if (dji > 0 ) {
 printf("PSIPAIR %05i %05i%9.5f%6.3f%6.3f%2i% 13.5e\n",
 id2,id1,sqrt(r2),
 rhoj0, rhois,
 dji,hji);
   }*/
 //      CkPrintf("PSIPAIR%5i%5i%10.5f%5i%14.8f%7.4f%7.4f\n",id1,id2,sqrt(r2),d1,h1,r10,r1s);
       if (id1 > id2) {
         int tmp = id1;
         id1 = id2;
         id2 = tmp;
         h1 = hji;
         h2 = hij;
         d1 = dji;
         d2 = dij;
         r20 = rhoi0;
         r2s = rhojs;
         r10 = rhoj0;
         r1s = rhois;
       }
 //      CkPrintf("PSIPAIR%5i%5i%10.5f%5i%14.8f%7.4f%7.4f\n",id2,id1,sqrt(r2),d2,h2,r20,r2s);
       //CkPrintf("PSI(%04i)[%04i,%04i] = %i%i % .4e % .4e\n",gbisParams->sequence,id1,id2,d1,d2,h1, h2);
       //CkPrintf("PPSI(%04i)[%04i,%04i] = %i%i\n",gbisParams->cid,id1,id2,d1,d2);
 #endif
 
 #ifdef BENCHMARK
       nops++;
 #endif
       psiI += hij;
       gbisParams->psiSum[1][j] += hji;
     }//end inner j
     gbisParams->psiSum[0][i] += psiI;
   }//end outer i
   for (int s = 0; s < strideIg; s++) {
     ngi+=params->p[0][ngi].nonbondedGroupSize;
   }
   }
 
 #ifdef BENCHMARK
   t2 = 1.0*clock()/CLOCKS_PER_SEC;
   CkPrintf("PHASE1.3: %8.3f ms @ %8.3f ns/iter for %i iter\n",1000.0*(t2-t1), 1000000000.0*(t2-t1)/nops,nops);
 #endif
 
 /***********************************************************
 * GBIS Phase 2
 ***********************************************************/
 } else if (gbisParams->gbisPhase == 2) {
 
   float epsilon_s = gbisParams->epsilon_s;
   float epsilon_p = gbisParams->epsilon_p;
   float epsilon_s_i = 1/epsilon_s;
   float epsilon_p_i = 1/epsilon_p;
   float kappa = gbisParams->kappa;
 
   //values used in loop
   float r_cut_2 = 1.0 / r_cut2;
   float r_cut_4 = 4.0*r_cut_2*r_cut_2;
   float coulEij=0,ddrCoulEij=0,gbEij=0,ddrGbEij=0;
   float dEdai=0,dEdaj=0, qiqj=0;
   float scale=0, ddrScale=0;
   float rnx=0,rny=0,rnz=0;
   float fx=0,fy=0,fz=0,forceCoul=0, forcedEdr=0;
 
   int nops = 0;
   double t1 = 1.0*clock()/CLOCKS_PER_SEC;
   float r2;
   float dr;
   BigReal dx, dy, dz;
   float r, r_i, ratio;
   float fIx, fIy, fIz;
   GBReal dEdaSumI;
   float bornRadI, bornRadJ;
   float qi;
   Position ri, rj;
   float aiaj,expr2aiaj4,fij,f_i,expkappa,Dij;
   float aiaj4,ddrDij,ddrf_i,ddrfij,tmp_dEda;
 
   for (int c = 0; c < 4/*dEdrPLs*/; c++) {
   for (int ngi = minIg; ngi < maxI;  ) {
     int iGroupSize = params->p[0][ngi].nonbondedGroupSize;
   for (int i = ngi; i < ngi+iGroupSize; i++) {
     ri = params->p[0][i].position;
     ri.x += offset_x;
     ri.y += offset_y;
     ri.z += offset_z;
     qi = - COULOMB * params->p[0][i].charge * scaling;
   //printf("ATOM(%05i) %.3e %.3e %.3e\n", params->pExt[0][i].id, params->p[0][i].charge, COULOMB, scaling);
     int numPairs;
     plint *pairs;
     gbisParams->gbisStepPairlists[c]->nextlist(&pairs,&numPairs);
     fIx = fIy = fIz = 0.0;
     dEdaSumI = 0.0;
     bornRadI = gbisParams->bornRad[0][i];
     for (int jj = 0; jj < numPairs; jj++) {
       int j = pairs[jj];
       rj = params->p[1][j].position;
 
       //distance
       dx = (ri.x - rj.x);
       dy = (ri.y - rj.y);
       dz = (ri.z - rj.z);
       r2 = dx*dx + dy*dy + dz*dz;
       if (r2 > r_cut2) continue;
       qiqj = qi*params->p[1][j].charge;
       bornRadJ = gbisParams->bornRad[1][j];
       r_i = 1.0/sqrt(r2);
       r = r2 * r_i;
 
       //pairwise calculation
 /*      Phase2_Pair(r, r2, r_i, qiqj,
           bornRadI,
           bornRadJ,
           epsilon_p_i, epsilon_s_i,
           kappa, gbisParams->doFullElectrostatics,
           gbEij, ddrGbEij, dEdai, dEdaj);
 */
 
   //calculate GB energy
   aiaj = bornRadI*bornRadJ;
   aiaj4 = 4*aiaj;
   expr2aiaj4 = exp(-r2/aiaj4);
   fij = sqrt(r2+aiaj*expr2aiaj4);
   f_i = 1/fij;
   expkappa = (kappa > 0) ? exp(-kappa*fij) : 1.0;
   Dij = epsilon_p_i - expkappa*epsilon_s_i;
   gbEij = qiqj*Dij*f_i;
 
   //calculate energy derivatives
   ddrfij = r*f_i*(1 - 0.25*expr2aiaj4);
   ddrf_i = -ddrfij*f_i*f_i;
   ddrDij = kappa*expkappa*ddrfij*epsilon_s_i;
   ddrGbEij = qiqj*(ddrDij*f_i+Dij*ddrf_i);
 
   //calc dEda
       //NAMD smoothing function
       scale = 1;
       ddrScale = 0;
       if (gbisParams->doSmoothing) {
         scale = r2 * r_cut_2 - 1;
         scale *= scale;
         ddrScale = r*(r2-r_cut2)*r_cut_4;
         //CkPrintf("SCALE %f %f\n",scale,ddrScale);
         gbisParams->gbInterEnergy += gbEij * scale;
         forcedEdr = -(ddrGbEij)*scale-(gbEij)*ddrScale;
       } else {
         gbisParams->gbInterEnergy += gbEij;
         forcedEdr = -ddrGbEij;
       }
 
       //add dEda
       if (gbisParams->doFullElectrostatics) {
         //gbisParams->dEdaSum[0][i] += dEdai*scale;
         tmp_dEda = 0.5*qiqj*f_i*f_i
                       *(kappa*epsilon_s_i*expkappa-Dij*f_i)
                       *(aiaj+0.25*r2)*expr2aiaj4;//0
         dEdai = tmp_dEda/bornRadI;
         dEdaj = tmp_dEda/bornRadJ;
         dEdaSumI += dEdai*scale;
         gbisParams->dEdaSum[1][j] += dEdaj*scale;
       }
 
 #if 1
 //#ifdef PRINT_COMP
       int id1 = params->pExt[0][i].id;
       int id2 = params->pExt[1][j].id;
       float deda1 = dEdai;
       float deda2 = dEdaj;
       float bR1 = bornRadI;
       float bR2 = bornRadJ;
       if (id1 > id2) {
         int tmp = id1;
         id1 = id2;
         id2 = tmp;
         deda1 = dEdaj;
         deda2 = dEdai;
         bR1 = bornRadJ;
         bR2 = bornRadI;
       }
       //CkPrintf("DEDR(%04i)[%04i,%04i] = % .4e\n",gbisParams->sequence,id1,id2,forcedEdr);
       //CkPrintf("DASM(%04i)[%04i,%04i] = % .4e % .4e\n",gbisParams->sequence,id1, id2, deda1,deda2);
       //CkPrintf("P2RM(%04i)[%04i,%04i] = % .4e % .4e % .4e % .4e % .4e\n",gbisParams->sequence,id1, id2, r, bR1,bR2,epsilon_p_i,epsilon_s_i,kappa);
 /*CkPrintf("P2PAIR %05i %05i%9.5f%6.3f%6.3f% 13.5e% 13.5e% 13.5e% 13.5e% 13.5e\n",
 params->pExt[0][i].id, params->pExt[1][j].id,sqrt(r2),
 bornRadI, bornRadJ, forcedEdr, dEdai, qiqj, Dij, scale
 );
 CkPrintf("P2PAIR %05i %05i%9.5f%6.3f%6.3f% 13.5e% 13.5e% 13.5e% 13.5e% 13.5e\n",
 params->pExt[1][j].id, params->pExt[0][i].id,sqrt(r2),
 bornRadJ, bornRadI, forcedEdr, dEdaj, qiqj, Dij, scale
 );*/
 #endif
 
       forcedEdr *= r_i;
       fx = dx*forcedEdr;
       fy = dy*forcedEdr;
       fz = dz*forcedEdr;
 
       params->ff[1][j].x -= fx;
       params->ff[1][j].y -= fy;
       params->ff[1][j].z -= fz;
 
       fIx += fx;
       fIy += fy;
       fIz += fz;
 
 #ifdef BENCHMARK
       nops ++;//= (59 + 4*DIV_FLOPS + 2*EXP_FLOPS+SQRT_FLOPS);//56 w/o nops
 #endif
 
     }//end inner j
     gbisParams->dEdaSum[0][i] += dEdaSumI;
     params->ff[0][i].x += fIx;
     params->ff[0][i].y += fIy;
     params->ff[0][i].z += fIz;
 
     //self energy of each atom
     if (c == 0 && gbisParams->doEnergy && gbisParams->numPatches == 1) {
       float fij = bornRadI;//inf
       float expkappa = exp(-kappa*fij);//0
       float Dij = epsilon_p_i - expkappa*epsilon_s_i;
       float gbEij = qi*params->p[0][i].charge*Dij/fij;
       gbisParams->gbSelfEnergy += 0.5*gbEij;//self energy
     }
   }// end outer i
   for (int s = 0; s < strideIg; s++) {
     ngi+=params->p[0][ngi].nonbondedGroupSize;
   }//end i
   }//end ig
   }//end c
 #ifdef BENCHMARK
   double t2 = 1.0*clock()/CLOCKS_PER_SEC;
   //double flops = 1.0 * nops / (t2 - t1);
   //double gflops = flops / 1000000000.0;
   
   CkPrintf("PHASE2.0: %8.3f ms @ %8.3f ns/iter for %i iter\n",1000.0*(t2-t1), 1000000000.0*(t2-t1)/nops,nops);
 #endif
 
 /***********************************************************
 * GBIS Phase 3
 ***********************************************************/
 } else if (gbisParams->gbisPhase == 3 && gbisParams->doFullElectrostatics) {
 
 #ifdef BENCHMARK
   //int domains[] = {0, 0, 0, 0, 0, 0, 0, 0};
   double t1 = 1.0*clock()/CLOCKS_PER_SEC;
   double t2;
   int nops = 0;
 #endif
   //CkPrintf("GBIS(%3i)[%2i]::P3 %3i(%3i) %3i(%3i)\n",gbisParams->sequence,gbisParams->cid, gbisParams->patchID[0],params->numAtoms[0],gbisParams->patchID[1],params->numAtoms[1]);
 
   register BigReal dx, dy, dz;
   register float  r2;
   register float r, r_i;
   register float rhoi0, rhois;
   float rhojs, rhoj0;
   float fx, fy, fz;
   float forceAlpha;
   register float fIx, fIy, fIz;
 
   float dhij;
   float dhji;
   int dij;
   int dji;
   register float dHdrPrefixI;
   float dHdrPrefixJ;
   register Position ri;
   register Position rj;
   register int c, numPairs, jj, j;
   register float k;
   register float da = DA;
   register float db = DB;
   register float dc = DC;
   register float dd = DD;
   register float de = DE;
   float r_i3;
 
   //piecewise 22
   c = 0;
   for (int ngi = minIg; ngi < maxI;  ) {
     int iGroupSize = params->p[0][ngi].nonbondedGroupSize;
   for (int i = ngi; i < ngi+iGroupSize; i++) {
     ri = params->p[0][i].position;
     ri.x += offset_x;
     ri.y += offset_y;
     ri.z += offset_z;
     rhois = gbisParams->intRad[0][2*i+1];
     plint *pairs;
     gbisParams->gbisStepPairlists[c]->nextlist(&pairs,&numPairs);
     fIx = fIy = fIz = 0.0;
     dHdrPrefixI = gbisParams->dHdrPrefix[0][i];
     for (jj = 0; jj < numPairs; jj++) {
       j = pairs[jj];
       rj = params->p[1][j].position;
 
       dx = (ri.x - rj.x);
       dy = (ri.y - rj.y);
       dz = (ri.z - rj.z);
       r2 = dx*dx + dy*dy + dz*dz;
       dHdrPrefixJ = gbisParams->dHdrPrefix[1][j];
 
       r_i = 1.0/sqrt(r2);//rptI takes 50% of loop time
       r_i3 = r_i*r_i*r_i;
 
       rhojs = gbisParams->intRad[1][2*j+1];
 
       k = rhojs*r_i; k*=k;//k=(rs/r)^2
       dhij = -rhojs*r_i3*k*
               (da+k*(db+k*(dc+k*(dd+k*de))));
 
       k = rhois*r_i; k*=k;//k=(rs/r)^2
       dhji = -rhois*r_i3*k*
               (da+k*(db+k*(dc+k*(dd+k*de))));
 
       //add dEda*dadr force
       forceAlpha = -r_i*(dHdrPrefixI*dhij+dHdrPrefixJ*dhji);
       fx = dx * forceAlpha;
       fy = dy * forceAlpha;
       fz = dz * forceAlpha;
 
       params->fullf[1][j].x -= fx;
       params->fullf[1][j].y -= fy;
       params->fullf[1][j].z -= fz;
 
       fIx += fx;
       fIy += fy;
       fIz += fz;
 
 #if 1
 //#ifdef PRINT_COMP
       int id1 = params->pExt[0][i].id;
       int id2 = params->pExt[1][j].id;
       float h1 = dhij;
       float h2 = dhji;
       if (id1 > id2) {
         int tmp = id1;
         id1 = id2;
         id2 = tmp;
         h1 = dhji;
         h2 = dhij;
       }
 /*CkPrintf("P3PAIR %05i %05i%9.5f% 13.5e% 13.5e% 13.5e% 13.5e% 13.5e %i\n",
 params->pExt[0][i].id, params->pExt[1][j].id,sqrt(r2),
 dHdrPrefixI, dHdrPrefixJ, dhij, dhji, forceAlpha, 2
 );
 CkPrintf("P3PAIR %05i %05i%9.5f% 13.5e% 13.5e% 13.5e% 13.5e% 13.5e %i\n",
 params->pExt[1][j].id, params->pExt[0][i].id,sqrt(r2),
 dHdrPrefixJ, dHdrPrefixI, dhji, dhij, forceAlpha, 2
 );*/
       //CkPrintf("DEDA(%04i)[%04i,%04i] = 22 % .4e % .4e % .4e\n",gbisParams->sequence,id1,id2,h1,h2, forceAlpha);
 #endif
 
 #ifdef BENCHMARK
       nops++;//= (24 + 2*DIV_FLOPS+SQRT_FLOPS);// 8 w/o nops
 #endif
 
     }//end inner j
     params->fullf[0][i].x += fIx;
     params->fullf[0][i].y += fIy;
     params->fullf[0][i].z += fIz;
   }//end outer i
   for (int s = 0; s < strideIg; s++) {
     ngi+=params->p[0][ngi].nonbondedGroupSize;
   }
   }
 
 #ifdef BENCHMARK
   t2 = 1.0*clock()/CLOCKS_PER_SEC;
   CkPrintf("PHASE3.1: %8.3f ms @ %8.3f ns/iter for %i iter\n",1000.0*(t2-t1), 1000000000.0*(t2-t1)/nops,nops);
 nops = 0;
   t1 = 1.0*clock()/CLOCKS_PER_SEC;
   nops = 0;
 #endif
 
   float a_cut_i = 1.0/a_cut;
   float a_cut_i2 = a_cut_i*a_cut_i;
   float a_cut2 = a_cut*a_cut;
   float rmrs;
   float rmrsi;
   float rmrs2;
   float rhois2, rhojs2;
   float logri, logrj;
   float r_i2;
 
   //piecewise 11
   c = 1;
   for (int ngi = minIg; ngi < maxI;  ) {
     int iGroupSize = params->p[0][ngi].nonbondedGroupSize;
   for (int i = ngi; i < ngi+iGroupSize; i++) {
     ri = params->p[0][i].position;
     ri.x += offset_x;
     ri.y += offset_y;
     ri.z += offset_z;
     rhois = gbisParams->intRad[0][2*i+1];
     rhois2 = rhois*rhois;
     plint *pairs;
     gbisParams->gbisStepPairlists[c]->nextlist(&pairs,&numPairs);
     fIx = fIy = fIz = 0.0;
     dHdrPrefixI = gbisParams->dHdrPrefix[0][i];
     for (jj = 0; jj < numPairs; jj++) {
       j = pairs[jj];
       rj = params->p[1][j].position;
       dHdrPrefixJ = gbisParams->dHdrPrefix[1][j];
 
       dx = (ri.x - rj.x);
       dy = (ri.y - rj.y);
       dz = (ri.z - rj.z);
       r2 = dx*dx + dy*dy + dz*dz;
       r_i = 1.0/sqrt(r2);//rptI
       r = r2* r_i;
       r_i2 = r_i*r_i;
 
       rhojs = gbisParams->intRad[1][2*j+1];
       rhojs2 = rhojs*rhojs;
 
 
       rmrs = r-rhojs;// 4 times
       rmrsi = 1.0/rmrs;
       rmrs2 = rmrs*rmrs;
       logrj = log(rmrs*a_cut_i);
       dhij = r_i2*(-0.25*logrj - (a_cut2 - rmrs2)*(rhojs2 + r2)*0.125*a_cut_i2*rmrsi*rmrsi);
 
 
       rmrs = r-rhois;// 4 times
       rmrsi = 1.0/rmrs;
       rmrs2 = rmrs*rmrs;
       logri = log(rmrs*a_cut_i);
       dhji = r_i2*(-0.25*logri - (a_cut2 - rmrs2)*(rhois2 + r2)*0.125*a_cut_i2*rmrsi*rmrsi);
 
       //add dEda*dadr force
       forceAlpha = -r_i*(dHdrPrefixI*dhij+dHdrPrefixJ*dhji);
       fx = dx * forceAlpha;
       fy = dy * forceAlpha;
       fz = dz * forceAlpha;
 
       params->fullf[1][j].x -= fx;
       params->fullf[1][j].y -= fy;
       params->fullf[1][j].z -= fz;
 
       fIx += fx;
       fIy += fy;
       fIz += fz;
 
 #if 1
 //#ifdef PRINT_COMP
       int id1 = params->pExt[0][i].id;
       int id2 = params->pExt[1][j].id;
       float h1 = dhij;
       float h2 = dhji;
       if (id1 > id2) {
         int tmp = id1;
         id1 = id2;
         id2 = tmp;
         h1 = dhji;
         h2 = dhij;
       }
       //CkPrintf("DEDA(%04i)[%04i,%04i] = 11 % .4e % .4e % .4e\n",gbisParams->sequence,id1,id2,h1,h2, forceAlpha);
 /*CkPrintf("P3PAIR %05i %05i%9.5f% 13.5e% 13.5e% 13.5e% 13.5e% 13.5e %i\n",
 params->pExt[0][i].id, params->pExt[1][j].id,sqrt(r2),
 dHdrPrefixI, dHdrPrefixJ, dhij, dhji, forceAlpha, 1
 );
 CkPrintf("P3PAIR %05i %05i%9.5f% 13.5e% 13.5e% 13.5e% 13.5e% 13.5e %i\n",
 params->pExt[1][j].id, params->pExt[0][i].id,sqrt(r2),
 dHdrPrefixJ, dHdrPrefixI, dhji, dhij, forceAlpha, 1
 );*/
 #endif
 
 #ifdef BENCHMARK
       nops++;
 #endif
 
     }//end inner j
     params->fullf[0][i].x += fIx;
     params->fullf[0][i].y += fIy;
     params->fullf[0][i].z += fIz;
   }//end outer i
   for (int s = 0; s < strideIg; s++) {
     ngi+=params->p[0][ngi].nonbondedGroupSize;
   }
   }
 
 #ifdef BENCHMARK
   t2 = 1.0*clock()/CLOCKS_PER_SEC;
   CkPrintf("PHASE3.2: %8.3f ms @ %8.3f ns/iter for %i iter\n",1000.0*(t2-t1), 1000000000.0*(t2-t1)/nops,nops);
 nops = 0;
   t1 = 1.0*clock()/CLOCKS_PER_SEC;
   nops = 0;
 #endif
 
   //piecewise all others
   c = 2;
   for (int ngi = minIg; ngi < maxI;  ) {
     int iGroupSize = params->p[0][ngi].nonbondedGroupSize;
   for (int i = ngi; i < ngi+iGroupSize; i++) {
     ri = params->p[0][i].position;
     ri.x += offset_x;
     ri.y += offset_y;
     ri.z += offset_z;
     rhoi0 = gbisParams->intRad[0][2*i+0];
     rhois = gbisParams->intRad[0][2*i+1];
     plint *pairs;
     gbisParams->gbisStepPairlists[c]->nextlist(&pairs,&numPairs);
     fIx = fIy = fIz = 0.0;
     dHdrPrefixI = gbisParams->dHdrPrefix[0][i];
     for (jj = 0; jj < numPairs; jj++) {
       j = pairs[jj];
       rj = params->p[1][j].position;
       dHdrPrefixJ = gbisParams->dHdrPrefix[1][j];
 
       dx = (ri.x - rj.x);
       dy = (ri.y - rj.y);
       dz = (ri.z - rj.z);
       r2 = dx*dx + dy*dy + dz*dz;
 
       r_i = 1.0/sqrt(r2);//rptI
       r = r2* r_i;
 
       rhojs = gbisParams->intRad[1][2*j+1];
       rhoj0 = gbisParams->intRad[1][2*j+0];
 
       CalcDHPair(r,r2,r_i,a_cut,
           rhoi0,rhojs,
           rhoj0,rhois,
           dij,dji,dhij,dhji);
 
       //add dEda*dadr force
       forceAlpha = -r_i*(dHdrPrefixI*dhij+dHdrPrefixJ*dhji); // *scaling ?
       fx = dx * forceAlpha;
       fy = dy * forceAlpha;
       fz = dz * forceAlpha;
 
       fIx += fx;
       fIy += fy;
       fIz += fz;
 
       params->fullf[1][j].x -= fx;
       params->fullf[1][j].y -= fy;
       params->fullf[1][j].z -= fz;
 
 #if 1
 //#ifdef PRINT_COMP
       int id1 = params->pExt[0][i].id;
       int id2 = params->pExt[1][j].id;
       int d1 = dij;
       int d2 = dji;
       float h1 = dhij;
       float h2 = dhji;
       if (id1 > id2) {
         int tmp = id1;
         id1 = id2;
         id2 = tmp;
         d1 = dji;
         d2 = dij;
         h1 = dhji;
         h2 = dhij;
       }
 //      CkPrintf("DEDA(%04i)[%04i,%04i] = %i%i % .4e % .4e % .4e\n",gbisParams->sequence,id1,id2,d1,d2,h1,h2, forceAlpha);
 //      CkPrintf("DEDA(%04i)[%04i,%04i] = %i%i % .4e % .4e % .4e\n",gbisParams->sequence,id1,id2,d1,d2,h1,h2, forceAlpha);
 /*if ( dij > 0 ) {
 CkPrintf("P3PAIR %05i %05i%9.5f% 13.5e% 13.5e% 13.5e% 13.5e% 13.5e %i\n",
 params->pExt[0][i].id, params->pExt[1][j].id,sqrt(r2),
 dHdrPrefixI, dHdrPrefixJ, dhij, dhji, forceAlpha, dij
 );
 }
 if ( dji > 0 ) {
 CkPrintf("P3PAIR %05i %05i%9.5f% 13.5e% 13.5e% 13.5e% 13.5e% 13.5e %i\n",
 params->pExt[1][j].id, params->pExt[0][i].id,sqrt(r2),
 dHdrPrefixJ, dHdrPrefixI, dhji, dhij, forceAlpha, dji
 );
 }*/
 #endif
 
 #ifdef BENCHMARK
       nops++;
 #endif
 
     }//end inner j
     params->fullf[0][i].x += fIx;
     params->fullf[0][i].y += fIy;
     params->fullf[0][i].z += fIz;
   }//end outer i
   for (int s = 0; s < strideIg; s++) {
     ngi+=params->p[0][ngi].nonbondedGroupSize;
   }
   }
 
 
 #ifdef BENCHMARK
   t2 = 1.0*clock()/CLOCKS_PER_SEC;
   CkPrintf("PHASE3.3: %8.3f ms @ %8.3f ns/iter for %i iter\n",1000.0*(t2-t1), 1000000000.0*(t2-t1)/nops, nops);
 #endif
 
 }//end if gbisPhase
 
 }//end calcGBIS

◆ select()

void ComputeNonbondedUtil::select ( void )

static

Definition at line 256 of file ComputeNonbondedUtil.C.

Referenced by SimParameters::nonbonded_select(), and SimParameters::scriptSet().

 {
   if ( CkMyRank() ) return;
 
   // These defaults die cleanly if nothing appropriate is assigned.
   ComputeNonbondedUtil::calcPair = calc_error;
   ComputeNonbondedUtil::calcPairEnergy = calc_error;
   ComputeNonbondedUtil::calcSelf = calc_error;
   ComputeNonbondedUtil::calcSelfEnergy = calc_error;
   ComputeNonbondedUtil::calcFullPair = calc_error;
   ComputeNonbondedUtil::calcFullPairEnergy = calc_error;
   ComputeNonbondedUtil::calcFullSelf = calc_error;
   ComputeNonbondedUtil::calcFullSelfEnergy = calc_error;
   ComputeNonbondedUtil::calcMergePair = calc_error;
   ComputeNonbondedUtil::calcMergePairEnergy = calc_error;
   ComputeNonbondedUtil::calcMergeSelf = calc_error;
   ComputeNonbondedUtil::calcMergeSelfEnergy = calc_error;
   ComputeNonbondedUtil::calcSlowPair = calc_error;
   ComputeNonbondedUtil::calcSlowPairEnergy = calc_error;
   ComputeNonbondedUtil::calcSlowSelf = calc_error;
   ComputeNonbondedUtil::calcSlowSelfEnergy = calc_error;
 
   SimParameters * simParams = Node::Object()->simParameters;
   Parameters * params = Node::Object()->parameters;
 
   table_ener = params->table_ener;
   rowsize = params->rowsize;
   columnsize = params->columnsize;
 
   commOnly = simParams->commOnly;
   fixedAtomsOn = ( simParams->fixedAtomsOn && ! simParams->fixedAtomsForces );
 
   qmForcesOn = simParams->qmForcesOn ;
   
   cutoff = simParams->cutoff;
   cutoff2 = cutoff*cutoff;
   cutoff2_f = cutoff2;
 
 //fepb
   alchFepOn = simParams->alchFepOn;
   alchThermIntOn = simParams->alchThermIntOn;
   alchWCAOn = simParams->alchWCAOn;
   alchDecouple = simParams->alchDecouple;
 
   lesOn = simParams->lesOn;
   lesScaling = lesFactor = 0;
 
   Bool tabulatedEnergies = simParams->tabulatedEnergies;
   alchVdwShiftCoeff = simParams->alchVdwShiftCoeff;
   vdwForceSwitching = simParams->vdwForceSwitching;
 
   delete [] lambda_table;
   lambda_table = 0;
 
   pairInteractionOn = simParams->pairInteractionOn;
   pairInteractionSelf = simParams->pairInteractionSelf;
   pressureProfileOn = simParams->pressureProfileOn;
 
   // Ported by JLai -- Original JE - Go
   goGroPair = simParams->goGroPair;
   goForcesOn = simParams->goForcesOn;
   goMethod = simParams->goMethod; 
   // End of port
 
   accelMDOn = simParams->accelMDOn;
 
   drudeNbthole = simParams->drudeOn && (simParams->drudeNbtholeCut > 0.0);
 
   if ( drudeNbthole ) {
 // #if defined(NAMD_CUDA) || defined(NAMD_HIP)
 //     NAMD_die("drudeNbthole is not supported in CUDA version");
 // #endif
     if ( lesOn )
       NAMD_die("drudeNbthole is not supported with locally enhanced sampling");
     if ( pairInteractionOn )
       NAMD_die("drudeNbthole is not supported with pair interaction calculation");
     if ( pressureProfileOn )
       NAMD_die("drudeNbthole is not supported with pressure profile calculation");
   }
 
   if ( alchFepOn ) {
     ComputeNonbondedUtil::calcPair = calc_pair_energy_fep;
     ComputeNonbondedUtil::calcPairEnergy = calc_pair_energy_fep;
     ComputeNonbondedUtil::calcSelf = calc_self_energy_fep;
     ComputeNonbondedUtil::calcSelfEnergy = calc_self_energy_fep;
     ComputeNonbondedUtil::calcFullPair = calc_pair_energy_fullelect_fep;
     ComputeNonbondedUtil::calcFullPairEnergy = calc_pair_energy_fullelect_fep;
     ComputeNonbondedUtil::calcFullSelf = calc_self_energy_fullelect_fep;
     ComputeNonbondedUtil::calcFullSelfEnergy = calc_self_energy_fullelect_fep;
     ComputeNonbondedUtil::calcMergePair = calc_pair_energy_merge_fullelect_fep;
     ComputeNonbondedUtil::calcMergePairEnergy = calc_pair_energy_merge_fullelect_fep;
     ComputeNonbondedUtil::calcMergeSelf = calc_self_energy_merge_fullelect_fep;
     ComputeNonbondedUtil::calcMergeSelfEnergy = calc_self_energy_merge_fullelect_fep;
     ComputeNonbondedUtil::calcSlowPair = calc_pair_energy_slow_fullelect_fep;
     ComputeNonbondedUtil::calcSlowPairEnergy = calc_pair_energy_slow_fullelect_fep;
     ComputeNonbondedUtil::calcSlowSelf = calc_self_energy_slow_fullelect_fep;
     ComputeNonbondedUtil::calcSlowSelfEnergy = calc_self_energy_slow_fullelect_fep;
   }  else if ( alchThermIntOn ) {
     ComputeNonbondedUtil::calcPair = calc_pair_ti;
     ComputeNonbondedUtil::calcPairEnergy = calc_pair_energy_ti;
     ComputeNonbondedUtil::calcSelf = calc_self_ti;
     ComputeNonbondedUtil::calcSelfEnergy = calc_self_energy_ti;
     ComputeNonbondedUtil::calcFullPair = calc_pair_fullelect_ti;
     ComputeNonbondedUtil::calcFullPairEnergy = calc_pair_energy_fullelect_ti;
     ComputeNonbondedUtil::calcFullSelf = calc_self_fullelect_ti;
     ComputeNonbondedUtil::calcFullSelfEnergy = calc_self_energy_fullelect_ti;
     ComputeNonbondedUtil::calcMergePair = calc_pair_merge_fullelect_ti;
     ComputeNonbondedUtil::calcMergePairEnergy = calc_pair_energy_merge_fullelect_ti;
     ComputeNonbondedUtil::calcMergeSelf = calc_self_merge_fullelect_ti;
     ComputeNonbondedUtil::calcMergeSelfEnergy = calc_self_energy_merge_fullelect_ti;
     ComputeNonbondedUtil::calcSlowPair = calc_pair_slow_fullelect_ti;
     ComputeNonbondedUtil::calcSlowPairEnergy = calc_pair_energy_slow_fullelect_ti;
     ComputeNonbondedUtil::calcSlowSelf = calc_self_slow_fullelect_ti;
     ComputeNonbondedUtil::calcSlowSelfEnergy = calc_self_energy_slow_fullelect_ti;
   } else if ( lesOn ) {
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
     NAMD_die("Locally enhanced sampling is not supported in CUDA version");
 #endif
     lesFactor = simParams->lesFactor;
     lesScaling = 1.0 / (double)lesFactor;
     lambda_table = new BigReal[(lesFactor+1)*(lesFactor+1)];
     for ( int ip=0; ip<=lesFactor; ++ip ) {
       for ( int jp=0; jp<=lesFactor; ++jp ) {
         BigReal lambda_pair = 1.0;
         if (ip || jp ) {
           if (ip && jp && ip != jp) {
             lambda_pair = 0.0;
           } else {
             lambda_pair = lesScaling;
           }
         }
         lambda_table[(lesFactor+1)*ip+jp] = lambda_pair;
       }
     }
     ComputeNonbondedUtil::calcPair = calc_pair_les;
     ComputeNonbondedUtil::calcPairEnergy = calc_pair_energy_les;
     ComputeNonbondedUtil::calcSelf = calc_self_les;
     ComputeNonbondedUtil::calcSelfEnergy = calc_self_energy_les;
     ComputeNonbondedUtil::calcFullPair = calc_pair_fullelect_les;
     ComputeNonbondedUtil::calcFullPairEnergy = calc_pair_energy_fullelect_les;
     ComputeNonbondedUtil::calcFullSelf = calc_self_fullelect_les;
     ComputeNonbondedUtil::calcFullSelfEnergy = calc_self_energy_fullelect_les;
     ComputeNonbondedUtil::calcMergePair = calc_pair_merge_fullelect_les;
     ComputeNonbondedUtil::calcMergePairEnergy = calc_pair_energy_merge_fullelect_les;
     ComputeNonbondedUtil::calcMergeSelf = calc_self_merge_fullelect_les;
     ComputeNonbondedUtil::calcMergeSelfEnergy = calc_self_energy_merge_fullelect_les;
     ComputeNonbondedUtil::calcSlowPair = calc_pair_slow_fullelect_les;
     ComputeNonbondedUtil::calcSlowPairEnergy = calc_pair_energy_slow_fullelect_les;
     ComputeNonbondedUtil::calcSlowSelf = calc_self_slow_fullelect_les;
     ComputeNonbondedUtil::calcSlowSelfEnergy = calc_self_energy_slow_fullelect_les;
   } else if ( pressureProfileOn) {
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
     NAMD_die("Pressure profile calculation is not supported in CUDA version");
 #endif
     pressureProfileSlabs = simParams->pressureProfileSlabs;
     pressureProfileAtomTypes = simParams->pressureProfileAtomTypes;
 
     ComputeNonbondedUtil::calcPair = calc_pair_pprof;
     ComputeNonbondedUtil::calcPairEnergy = calc_pair_energy_pprof;
     ComputeNonbondedUtil::calcSelf = calc_self_pprof;
     ComputeNonbondedUtil::calcSelfEnergy = calc_self_energy_pprof;
     ComputeNonbondedUtil::calcFullPair = calc_pair_fullelect_pprof;
     ComputeNonbondedUtil::calcFullPairEnergy = calc_pair_energy_fullelect_pprof;
     ComputeNonbondedUtil::calcFullSelf = calc_self_fullelect_pprof;
     ComputeNonbondedUtil::calcFullSelfEnergy = calc_self_energy_fullelect_pprof;
     ComputeNonbondedUtil::calcMergePair = calc_pair_merge_fullelect_pprof;
     ComputeNonbondedUtil::calcMergePairEnergy = calc_pair_energy_merge_fullelect_pprof;
     ComputeNonbondedUtil::calcMergeSelf = calc_self_merge_fullelect_pprof;
     ComputeNonbondedUtil::calcMergeSelfEnergy = calc_self_energy_merge_fullelect_pprof;
     ComputeNonbondedUtil::calcSlowPair = calc_pair_slow_fullelect_pprof;
     ComputeNonbondedUtil::calcSlowPairEnergy = calc_pair_energy_slow_fullelect_pprof;
     ComputeNonbondedUtil::calcSlowSelf = calc_self_slow_fullelect_pprof;
     ComputeNonbondedUtil::calcSlowSelfEnergy = calc_self_energy_slow_fullelect_pprof;
   } else if ( pairInteractionOn ) {
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
     NAMD_die("Pair interaction calculation is not supported in CUDA version");
 #endif
     ComputeNonbondedUtil::calcPairEnergy = calc_pair_energy_int;
     ComputeNonbondedUtil::calcSelfEnergy = calc_self_energy_int;
     ComputeNonbondedUtil::calcFullPairEnergy = calc_pair_energy_fullelect_int;
     ComputeNonbondedUtil::calcFullSelfEnergy = calc_self_energy_fullelect_int;
     ComputeNonbondedUtil::calcMergePairEnergy = calc_pair_energy_merge_fullelect_int;
     ComputeNonbondedUtil::calcMergeSelfEnergy = calc_self_energy_merge_fullelect_int;
   } else if ( tabulatedEnergies ) {
 #if defined(NAMD_CUDA) || defined(NAMD_HIP)
     NAMD_die("Tabulated energies is not supported in CUDA version");
 #endif
     ComputeNonbondedUtil::calcPair = calc_pair_tabener;
     ComputeNonbondedUtil::calcPairEnergy = calc_pair_energy_tabener;
     ComputeNonbondedUtil::calcSelf = calc_self_tabener;
     ComputeNonbondedUtil::calcSelfEnergy = calc_self_energy_tabener;
     ComputeNonbondedUtil::calcFullPair = calc_pair_fullelect_tabener;
     ComputeNonbondedUtil::calcFullPairEnergy = calc_pair_energy_fullelect_tabener;
     ComputeNonbondedUtil::calcFullSelf = calc_self_fullelect_tabener;
     ComputeNonbondedUtil::calcFullSelfEnergy = calc_self_energy_fullelect_tabener;
     ComputeNonbondedUtil::calcMergePair = calc_pair_merge_fullelect_tabener;
     ComputeNonbondedUtil::calcMergePairEnergy = calc_pair_energy_merge_fullelect_tabener;
     ComputeNonbondedUtil::calcMergeSelf = calc_self_merge_fullelect_tabener;
     ComputeNonbondedUtil::calcMergeSelfEnergy = calc_self_energy_merge_fullelect_tabener;
     ComputeNonbondedUtil::calcSlowPair = calc_pair_slow_fullelect_tabener;
     ComputeNonbondedUtil::calcSlowPairEnergy = calc_pair_energy_slow_fullelect_tabener;
     ComputeNonbondedUtil::calcSlowSelf = calc_self_slow_fullelect_tabener;
     ComputeNonbondedUtil::calcSlowSelfEnergy = calc_self_energy_slow_fullelect_tabener;
   } else if ( goForcesOn ) {
 #ifdef NAMD_CUDA
     NAMD_die("Go forces is not supported in CUDA version");
 #endif
     ComputeNonbondedUtil::calcPair = calc_pair_go;
     ComputeNonbondedUtil::calcPairEnergy = calc_pair_energy_go;
     ComputeNonbondedUtil::calcSelf = calc_self_go;
     ComputeNonbondedUtil::calcSelfEnergy = calc_self_energy_go;
     ComputeNonbondedUtil::calcFullPair = calc_pair_fullelect_go;
     ComputeNonbondedUtil::calcFullPairEnergy = calc_pair_energy_fullelect_go;
     ComputeNonbondedUtil::calcFullSelf = calc_self_fullelect_go;
     ComputeNonbondedUtil::calcFullSelfEnergy = calc_self_energy_fullelect_go;
     ComputeNonbondedUtil::calcMergePair = calc_pair_merge_fullelect_go;
     ComputeNonbondedUtil::calcMergePairEnergy = calc_pair_energy_merge_fullelect_go;
     ComputeNonbondedUtil::calcMergeSelf = calc_self_merge_fullelect_go;
     ComputeNonbondedUtil::calcMergeSelfEnergy = calc_self_energy_merge_fullelect_go;
     ComputeNonbondedUtil::calcSlowPair = calc_pair_slow_fullelect_go;
     ComputeNonbondedUtil::calcSlowPairEnergy = calc_pair_energy_slow_fullelect_go;
     ComputeNonbondedUtil::calcSlowSelf = calc_self_slow_fullelect_go;
     ComputeNonbondedUtil::calcSlowSelfEnergy = calc_self_energy_slow_fullelect_go;
   } else {
     ComputeNonbondedUtil::calcPair = calc_pair;
     ComputeNonbondedUtil::calcPairEnergy = calc_pair_energy;
     ComputeNonbondedUtil::calcSelf = calc_self;
     ComputeNonbondedUtil::calcSelfEnergy = calc_self_energy;
     ComputeNonbondedUtil::calcFullPair = calc_pair_fullelect;
     ComputeNonbondedUtil::calcFullPairEnergy = calc_pair_energy_fullelect;
     ComputeNonbondedUtil::calcFullSelf = calc_self_fullelect;
     ComputeNonbondedUtil::calcFullSelfEnergy = calc_self_energy_fullelect;
     ComputeNonbondedUtil::calcMergePair = calc_pair_merge_fullelect;
     ComputeNonbondedUtil::calcMergePairEnergy = calc_pair_energy_merge_fullelect;
     ComputeNonbondedUtil::calcMergeDispPair = calc_pair_merge_fullelect_fulldisp;
     ComputeNonbondedUtil::calcMergeDispPairEnergy = calc_pair_energy_merge_fullelect_fulldisp;
     ComputeNonbondedUtil::calcMergeSelf = calc_self_merge_fullelect;
     ComputeNonbondedUtil::calcMergeSelfEnergy = calc_self_energy_merge_fullelect;
     ComputeNonbondedUtil::calcMergeDispSelf = calc_self_merge_fullelect_fulldisp;
     ComputeNonbondedUtil::calcMergeDispSelfEnergy = calc_self_energy_merge_fullelect_fulldisp;
     ComputeNonbondedUtil::calcSlowPair = calc_pair_slow_fullelect;
     ComputeNonbondedUtil::calcSlowPairEnergy = calc_pair_energy_slow_fullelect;
     ComputeNonbondedUtil::calcSlowSelf = calc_self_slow_fullelect;
     ComputeNonbondedUtil::calcSlowSelfEnergy = calc_self_energy_slow_fullelect;
   }
 
 //fepe
 
   dielectric_1 = 1.0/simParams->dielectric;
   if ( simParams->soluteScalingOn ) {
     delete ljTable;
     ljTable = 0;
   }
   if ( ! ljTable ) ljTable = new LJTable;
   mol = Node::Object()->molecule;
   scaling = simParams->nonbondedScaling;
   if ( simParams->exclude == SCALED14 )
   {
     scale14 = simParams->scale14;
   }
   else
   {
     scale14 = 1.;
   }
   if ( simParams->switchingActive )
   {
     switchOn = simParams->switchingDist;
     switchOn_1 = 1.0/switchOn;
     // d0 = 1.0/(cutoff-switchOn);
     switchOn2 = switchOn*switchOn;
     c0 = 1.0/(cutoff2-switchOn2);
 
     if ( simParams->vdwForceSwitching ) {
       double switchOn3 = switchOn * switchOn2;
       double cutoff3 = cutoff * cutoff2;
       double switchOn6 = switchOn3 * switchOn3;
       double cutoff6 = cutoff3 * cutoff3;
       v_vdwa_f = v_vdwa = -1. / ( switchOn6 * cutoff6 );
       v_vdwb_f = v_vdwb = -1. / ( switchOn3 * cutoff3 );
       k_vdwa_f = k_vdwa = cutoff6 / ( cutoff6 - switchOn6 );
       k_vdwb_f = k_vdwb = cutoff3 / ( cutoff3 - switchOn3 );
       cutoff_3_f = cutoff_3 = 1. / cutoff3;
       cutoff_6_f = cutoff_6 = 1. / cutoff6;
 
     } else if ( simParams->martiniSwitching ) { // switching fxn for Martini RBCG
 
       BigReal p6 = 6;
       BigReal A6 = p6 * ((p6+1)*switchOn-(p6+4)*cutoff)/(pow(cutoff,p6+2)*pow(cutoff-switchOn,2));
       BigReal B6 = -p6 * ((p6+1)*switchOn-(p6+3)*cutoff)/(pow(cutoff,p6+2)*pow(cutoff-switchOn,3));        
       BigReal C6 = 1.0/pow(cutoff,p6)-A6/3.0*pow(cutoff-switchOn,3)-B6/4.0*pow(cutoff-switchOn,4);
 
       BigReal p12 = 12;
       BigReal A12 = p12 * ((p12+1)*switchOn-(p12+4)*cutoff)/(pow(cutoff,p12+2)*pow(cutoff-switchOn,2));
       BigReal B12 = -p12 * ((p12+1)*switchOn-(p12+3)*cutoff)/(pow(cutoff,p12+2)*pow(cutoff-switchOn,3));
       BigReal C12 = 1.0/pow(cutoff,p12)-A12/3.0*pow(cutoff-switchOn,3)-B12/4.0*pow(cutoff-switchOn,4);
 
       A6_f =  A6;  B6_f  = B6;  C6_f =  C6;
       A12_f = A12; B12_f = B12; C12_f = C12;
       switchOn_f = switchOn;
 
     }
 
   }
   else
   {
     switchOn = cutoff;
     switchOn_1 = 1.0/switchOn;
     // d0 = 0.;  // avoid division by zero
     switchOn2 = switchOn*switchOn;
     c0 = 0.;  // avoid division by zero
   }
   c1 = c0*c0*c0;
   c3 = 3.0 * (cutoff2 - switchOn2);
   c5 = 0;
   c6 = 0;
   c7 = 0;
   c8 = 0;
 
   const int PMEOn = simParams->PMEOn;
   const int LJPMEOn = simParams->LJPMEOn;
   const int MSMOn = simParams->MSMOn;
   const int MSMSplit = simParams->MSMSplit;
 
   if ( PMEOn ) {
     ewaldcof = simParams->PMEEwaldCoefficient;
     BigReal TwoBySqrtPi = 1.12837916709551;
     pi_ewaldcof = TwoBySqrtPi * ewaldcof;
   }
   if ( LJPMEOn ) {
     LJewaldcof = simParams->LJPMEEwaldCoefficient;
   }
 
   int splitType = SPLIT_NONE;
   if ( simParams->switchingActive ) splitType = SPLIT_SHIFT;
   if ( simParams->martiniSwitching ) splitType = SPLIT_MARTINI;
   if ( simParams->fullDirectOn || simParams->FMAOn || PMEOn || MSMOn ||
       simParams->FMMOn ) {
     switch ( simParams->longSplitting ) {
       case C2:
       splitType = SPLIT_C2;
       break;
 
       case C1:
       splitType = SPLIT_C1;
       break;
 
       case XPLOR:
       NAMD_die("Sorry, XPLOR splitting not supported.");
       break;
 
       case SHARP:
       NAMD_die("Sorry, SHARP splitting not supported.");
       break;
 
       default:
       NAMD_die("Unknown splitting type found!");
 
     }
   }
 
   BigReal r2_tol = 0.1;
   
   r2_delta = 1.0;
   r2_delta_exp = 0;
   while ( r2_delta > r2_tol ) { r2_delta /= 2.0; r2_delta_exp += 1; }
   r2_delta_1 = 1.0 / r2_delta;
 
   if ( ! CkMyPe() ) {
     iout << iINFO << "NONBONDED TABLE R-SQUARED SPACING: " <<
                                 r2_delta << "\n" << endi;
   }
 
   BigReal r2_tmp = 1.0;
   int cutoff2_exp = 0;
   while ( (cutoff2 + r2_delta) > r2_tmp ) { r2_tmp *= 2.0; cutoff2_exp += 1; }
 
   int i;
   int n = (r2_delta_exp + cutoff2_exp) * 64 + 1;
   table_length = n;
   #if defined(NAMD_MIC)
     int n_16 = (n + 15) & (~15);
   #endif
 
   if ( ! CkMyPe() ) {
     iout << iINFO << "NONBONDED TABLE SIZE: " <<
                                 n << " POINTS\n" << endi;
   }
 
   if ( table_alloc ) delete [] table_alloc;
   #if defined(NAMD_MIC)
     table_alloc = new BigReal[61*n_16+16];
     BigReal *table_align = table_alloc;
     while ( ((long)table_align) % 128 ) ++table_align;
     mic_table_base_ptr = table_align;
     mic_table_n = n;
     mic_table_n_16 = n_16;
     table_noshort = table_align;
     table_short = table_align + 16*n_16;
     slow_table = table_align + 32*n_16;
     fast_table = table_align + 36*n_16;
     scor_table = table_align + 40*n_16;
     corr_table = table_align + 44*n_16;
     full_table = table_align + 48*n_16;
     vdwa_table = table_align + 52*n_16;
     vdwb_table = table_align + 56*n_16;
     r2_table = table_align + 60*n_16;
   #else
   table_alloc = new BigReal[61*n+16];
   BigReal *table_align = table_alloc;
   while ( ((long)table_align) % 128 ) ++table_align;
   table_noshort = table_align;
   table_short = table_align + 16*n;
   slow_table = table_align + 32*n;
   fast_table = table_align + 36*n;
   scor_table = table_align + 40*n;
   corr_table = table_align + 44*n;
   full_table = table_align + 48*n;
   vdwa_table = table_align + 52*n;
   vdwb_table = table_align + 56*n;
   r2_table = table_align + 60*n;
   #endif
   BigReal *fast_i = fast_table + 4;
   BigReal *scor_i = scor_table + 4;
   BigReal *slow_i = slow_table + 4;
   BigReal *vdwa_i = vdwa_table + 4;
   BigReal *vdwb_i = vdwb_table + 4;
   BigReal *r2_i = r2_table;  *(r2_i++) = r2_delta;
   BigReal r2_limit = simParams->limitDist * simParams->limitDist;
   if ( r2_limit < r2_delta ) r2_limit = r2_delta;
   int r2_delta_i = 0;  // entry for r2 == r2_delta
 
 #ifdef NAMD_AVXTILES
   {
     avxTilesMode = 1;
     if (!simParams->useAVXTiles)
       avxTilesMode = 0;
     if (avxTilesMode) {
       if (simParams->vdwGeometricSigma) avxTilesMode = 2;
       if ( simParams->fullDirectOn || simParams->FMAOn || PMEOn || MSMOn ||
            simParams->FMMOn ) {
         if ( simParams->longSplitting != C1)
           avxTilesMode = 3;
       } else
         avxTilesMode = 3;
       if (avxTilesMode == 1) {
         const int table_dim = ljTable->get_table_dim();
         Real A, B, A14, B14;
         for (int i = 0; i < table_dim; i++)
           for (int j = i+1; j < table_dim; j++)
             if (params->get_vdw_pair_params(i, j, &A, &B, &A14, &B14)) 
               avxTilesMode = 2;
       }
       if (avxTilesMode > 1)
         iout << iINFO << "AVX-512 TILES WILL USE SHORT-RANGE INTERPOLATION ("
              << avxTilesMode << ")\n";
       else {
         Parameters *params = Node::Object()->parameters;
         const int num_params = params->get_num_vdw_params();
         if ( avx_tiles_eps4_sigma ) delete [] avx_tiles_eps4_sigma;
         if ( avx_tiles_eps4_sigma_14 ) delete [] avx_tiles_eps4_sigma_14;
         avx_tiles_eps4_sigma = new float[num_params*2];
         avx_tiles_eps4_sigma_14 = new float[num_params*2];
         for (int i = 0; i < num_params; i++) {
           Real sigma, sigma_14, epsilon, epsilon_14;
           params->get_vdw_params(&sigma, &epsilon, &sigma_14,
                                  &epsilon_14,i);
     // Set the epsilon and epsilon_14 to zero if we do LJ-PME
 //if (simParams->LJPMESerialOn) {
     if (simParams->LJPMEOn) {
       epsilon = epsilon_14 = 0.0;
     }
 //}
           avx_tiles_eps4_sigma[i*2] = 4.0 * scaling * epsilon;
           avx_tiles_eps4_sigma[i*2 + 1] = sigma;
           avx_tiles_eps4_sigma_14[i*2] = 4.0 * scaling * epsilon_14;
           avx_tiles_eps4_sigma_14[i*2 + 1] = sigma_14;
         }
       }
     }
   }
 #endif
 #if defined(NAMD_KNL) || defined(NAMD_AVXTILES)
   if ( knl_table_alloc ) delete [] knl_table_alloc;
   if ( KNL_TABLE_MAX_R_1 < 1.f || KNL_TABLE_FACTOR < 1 ||
        KNL_TABLE_FACTOR != 
        static_cast<int>(1.0 / KNL_TABLE_MAX_R_1 * KNL_TABLE_SIZE))
     NAMD_bug("Inconsistent KNL preprocessor settings.");
 #ifdef NAMD_KNL
   knl_table_alloc = new float[10*KNL_TABLE_SIZE];
 #else
   knl_table_alloc = new float[8*KNL_TABLE_SIZE];
 #endif
  knl_fast_ener_table = knl_table_alloc;
  knl_fast_grad_table = knl_table_alloc + KNL_TABLE_SIZE;
  knl_scor_ener_table = knl_table_alloc + 2*KNL_TABLE_SIZE;
  knl_scor_grad_table = knl_table_alloc + 3*KNL_TABLE_SIZE;
  knl_slow_ener_table = knl_table_alloc + 4*KNL_TABLE_SIZE;
  knl_slow_grad_table = knl_table_alloc + 5*KNL_TABLE_SIZE;
  knl_excl_ener_table = knl_table_alloc + 6*KNL_TABLE_SIZE;
  knl_excl_grad_table = knl_table_alloc + 7*KNL_TABLE_SIZE;
  knl_fast_ener_table[0] = 0.;
  knl_fast_grad_table[0] = 0.;
  knl_scor_ener_table[0] = 0.;
  knl_scor_grad_table[0] = 0.;
  knl_slow_ener_table[0] = 0.;
  knl_slow_grad_table[0] = 0.;
  knl_excl_ener_table[0] = 0.;
  knl_excl_grad_table[0] = 0.;
 #ifdef NAMD_KNL
  knl_corr_ener_table = knl_table_alloc + 8*KNL_TABLE_SIZE;
  knl_corr_grad_table = knl_table_alloc + 9*KNL_TABLE_SIZE;
  knl_corr_ener_table[0] = 0.;
  knl_corr_grad_table[0] = 0.;
 #endif
  for ( int knl_table = 0; knl_table < 2; ++knl_table ) {
   int nn = n;
   if ( knl_table ) {
     nn = KNL_TABLE_SIZE-1;
   }
   for ( i=1; i<nn; ++i ) {
 #else
   // fill in the table, fix up i==0 (r2==0) below
   for ( i=1; i<n; ++i ) {
 #endif
 
     const BigReal r2_base = r2_delta * ( 1 << (i/64) );
     const BigReal r2_del = r2_base / 64.0;
     BigReal r2 = r2_base - r2_delta + r2_del * (i%64);
 
     BigReal r = sqrt(r2);
 
 #if defined(NAMD_KNL) || defined(NAMD_AVXTILES)
     if ( knl_table ) {
       r = (double)(KNL_TABLE_FACTOR-2)/(double)(i);
       r2 = r*r;
     } else
 #endif
     if ( r2 <= r2_limit ) r2_delta_i = i;
 
     const BigReal r_1 = 1.0/r;
     const BigReal r_2 = 1.0/r2;
 
     // fast_ is defined as (full_ - slow_)
     // corr_ and fast_ are both zero at the cutoff, full_ is not
     // all three are approx 1/r at short distances
 
     // for actual interpolation, we use fast_ for fast forces and
     // scor_ = slow_ + corr_ - full_ and slow_ for slow forces
     // since these last two are of small magnitude
 
     BigReal fast_energy, fast_gradient;
     BigReal scor_energy, scor_gradient;
     BigReal slow_energy, slow_gradient;
 
     // corr_ is PME direct sum, or similar correction term
     // corr_energy is multiplied by r until later
     // corr_gradient is multiplied by -r^2 until later
     BigReal corr_energy, corr_gradient;
 
     
     if ( PMEOn ) {
       BigReal tmp_a = r * ewaldcof;
       BigReal tmp_b = erfc(tmp_a);
       corr_energy = tmp_b;
       corr_gradient = pi_ewaldcof*exp(-(tmp_a*tmp_a))*r + tmp_b;
     } else if ( MSMOn ) {
       BigReal a_1 = 1.0/cutoff;
       BigReal r_a = r * a_1;
       BigReal g, dg;
       SPOLY(&g, &dg, r_a, MSMSplit);
       corr_energy = 1 - r_a * g;
       corr_gradient = 1 + r_a*r_a * dg;
     } else {
       corr_energy = corr_gradient = 0;
     }
 
     switch(splitType) {
       case SPLIT_NONE:
         fast_energy = 1.0/r;
         fast_gradient = -1.0/r2;
         scor_energy = scor_gradient = 0;
         slow_energy = slow_gradient = 0;
         break;
       case SPLIT_SHIFT: {
         BigReal shiftVal = r2/cutoff2 - 1.0;
         shiftVal *= shiftVal;
         BigReal dShiftVal = 2.0 * (r2/cutoff2 - 1.0) * 2.0*r/cutoff2;
         fast_energy = shiftVal/r;
         fast_gradient = dShiftVal/r - shiftVal/r2;
         scor_energy = scor_gradient = 0;
         slow_energy = slow_gradient = 0;
         } 
         break;
       case SPLIT_MARTINI: { 
         // in Martini, the Coulomb switching distance is zero
         const BigReal COUL_SWITCH = 0.;
         // Gromacs shifting function
         const BigReal p1 = 1.;
         BigReal A1 = p1 * ((p1+1)*COUL_SWITCH-(p1+4)*cutoff)/(pow(cutoff,p1+2)*pow(cutoff-COUL_SWITCH,2));
         BigReal B1 = -p1 * ((p1+1)*COUL_SWITCH-(p1+3)*cutoff)/(pow(cutoff,p1+2)*pow(cutoff-COUL_SWITCH,3));
         BigReal X1 = 1.0/pow(cutoff,p1)-A1/3.0*pow(cutoff-COUL_SWITCH,3)-B1/4.0*pow(cutoff-COUL_SWITCH,4);
         BigReal r12 = (r-COUL_SWITCH)*(r-COUL_SWITCH);
         BigReal r13 = (r-COUL_SWITCH)*(r-COUL_SWITCH)*(r-COUL_SWITCH);
         BigReal shiftVal = -(A1/3.0)*r13 - (B1/4.0)*r12*r12 - X1;
         BigReal dShiftVal = -A1*r12 - B1*r13;
         fast_energy = (1/r) + shiftVal;
         fast_gradient = -1/(r2) + dShiftVal;
         scor_energy = scor_gradient = 0;
         slow_energy = slow_gradient = 0;
         } 
         break;
       case SPLIT_C1:
         // calculate actual energy and gradient
         slow_energy = 0.5/cutoff * (3.0 - (r2/cutoff2));
         slow_gradient = -1.0/cutoff2 * (r/cutoff);
         // calculate scor from slow and corr
         scor_energy = slow_energy + (corr_energy - 1.0)/r;
         scor_gradient = slow_gradient - (corr_gradient - 1.0)/r2;
         // calculate fast from slow
         fast_energy = 1.0/r - slow_energy;
         fast_gradient = -1.0/r2 - slow_gradient;
         break;
       case SPLIT_C2:
         //
         // Quintic splitting function contributed by
         // Bruce Berne, Ruhong Zhou, and Joe Morrone
         //
         // calculate actual energy and gradient
         slow_energy = r2/(cutoff*cutoff2) * (6.0 * (r2/cutoff2)
             - 15.0*(r/cutoff) + 10.0);
         slow_gradient = r/(cutoff*cutoff2) * (24.0 * (r2/cutoff2)
             - 45.0 *(r/cutoff) + 20.0);
         // calculate scor from slow and corr
         scor_energy = slow_energy + (corr_energy - 1.0)/r;
         scor_gradient = slow_gradient - (corr_gradient - 1.0)/r2;
         // calculate fast from slow
         fast_energy = 1.0/r - slow_energy;
         fast_gradient = -1.0/r2 - slow_gradient;
         break;
     }
 
     // foo_gradient is calculated as ( d foo_energy / d r )
     // and now divided by 2r to get ( d foo_energy / d r2 )
 
     fast_gradient *= 0.5 * r_1;
     scor_gradient *= 0.5 * r_1;
     slow_gradient *= 0.5 * r_1;
 
     // let modf be 1 if excluded, 1-scale14 if modified, 0 otherwise,
     // add scor_ - modf * slow_ to slow terms and
     // add fast_ - modf * fast_ to fast terms.
 
     BigReal vdwa_energy, vdwa_gradient;
     BigReal vdwb_energy, vdwb_gradient;
 
     const BigReal r_6 = r_2*r_2*r_2;
     const BigReal r_12 = r_6*r_6;
 
     // Lennard-Jones switching function
   if ( simParams->vdwForceSwitching ) {  // switch force
     vdw_switch_mode = VDW_SWITCH_MODE_FORCE;
 
     // from Steinbach & Brooks, JCC 15, pgs 667-683, 1994, eqns 10-13
     if ( r2 > switchOn2 ) {
       BigReal tmpa = r_6 - cutoff_6;
       vdwa_energy = k_vdwa * tmpa * tmpa;
       BigReal tmpb = r_1 * r_2 - cutoff_3;
       vdwb_energy = k_vdwb * tmpb * tmpb;
       vdwa_gradient = -6.0 * k_vdwa * tmpa * r_2 * r_6;
       vdwb_gradient = -3.0 * k_vdwb * tmpb * r_2 * r_2 * r_1;
     } else {
       vdwa_energy = r_12 + v_vdwa;
       vdwb_energy = r_6 + v_vdwb;
       vdwa_gradient = -6.0 * r_2 * r_12;
       vdwb_gradient = -3.0 * r_2 * r_6;
     }
   } else if ( simParams->martiniSwitching ) { // switching fxn for Martini RBCG
     vdw_switch_mode = VDW_SWITCH_MODE_MARTINI;
 
     BigReal r12 = (r-switchOn)*(r-switchOn);        BigReal r13 = (r-switchOn)*(r-switchOn)*(r-switchOn);
 
     BigReal p6 = 6;
     BigReal A6 = p6 * ((p6+1)*switchOn-(p6+4)*cutoff)/(pow(cutoff,p6+2)*pow(cutoff-switchOn,2));
     BigReal B6 = -p6 * ((p6+1)*switchOn-(p6+3)*cutoff)/(pow(cutoff,p6+2)*pow(cutoff-switchOn,3));        
     BigReal C6 = 1.0/pow(cutoff,p6)-A6/3.0*pow(cutoff-switchOn,3)-B6/4.0*pow(cutoff-switchOn,4);
 
     BigReal p12 = 12;
     BigReal A12 = p12 * ((p12+1)*switchOn-(p12+4)*cutoff)/(pow(cutoff,p12+2)*pow(cutoff-switchOn,2));
     BigReal B12 = -p12 * ((p12+1)*switchOn-(p12+3)*cutoff)/(pow(cutoff,p12+2)*pow(cutoff-switchOn,3));
     BigReal C12 = 1.0/pow(cutoff,p12)-A12/3.0*pow(cutoff-switchOn,3)-B12/4.0*pow(cutoff-switchOn,4);
 
     BigReal LJshifttempA = -(A12/3)*r13 - (B12/4)*r12*r12 - C12;
     BigReal LJshifttempB = -(A6/3)*r13 - (B6/4)*r12*r12 - C6;
     const BigReal shiftValA =         // used for Lennard-Jones
                         ( r2 > switchOn2 ? LJshifttempA : -C12);
     const BigReal shiftValB =         // used for Lennard-Jones
                         ( r2 > switchOn2 ? LJshifttempB : -C6);
 
     BigReal LJdshifttempA = -A12*r12 - B12*r13;
     BigReal LJdshifttempB = -A6*r12 - B6*r13;
     const BigReal dshiftValA =         // used for Lennard-Jones
                         ( r2 > switchOn2 ? LJdshifttempA*0.5*r_1 : 0 );
     const BigReal dshiftValB =         // used for Lennard-Jones
                         ( r2 > switchOn2 ? LJdshifttempB*0.5*r_1 : 0 );
 
 
 
 
     //have not addressed r > cutoff
 
     //  dshiftValA*= 0.5*r_1;
     //  dshiftValB*= 0.5*r_1;
 
     vdwa_energy = r_12 + shiftValA;
     vdwb_energy = r_6 + shiftValB;
    
     vdwa_gradient = -6/pow(r,14) + dshiftValA ;
     vdwb_gradient = -3/pow(r,8) + dshiftValB;
 
   } else {  // switch energy
     vdw_switch_mode = VDW_SWITCH_MODE_ENERGY;
 
     const BigReal c2 = cutoff2-r2;
     const BigReal c4 = c2*(c3-2.0*c2);
     const BigReal switchVal =         // used for Lennard-Jones
                         ( r2 > switchOn2 ? c2*c4*c1 : 1.0 );
     const BigReal dSwitchVal =        // d switchVal / d r2
                         ( r2 > switchOn2 ? 2*c1*(c2*c2-c4) : 0.0 );
 
     vdwa_energy = switchVal * r_12;
     vdwb_energy = switchVal * r_6;
 
     vdwa_gradient = ( dSwitchVal - 6.0 * switchVal * r_2 ) * r_12;
     vdwb_gradient = ( dSwitchVal - 3.0 * switchVal * r_2 ) * r_6;
   }
 
 
 #if defined(NAMD_KNL) || defined(NAMD_AVXTILES)
    if ( knl_table ) {
     knl_fast_ener_table[i] = -1.*fast_energy;
     knl_fast_grad_table[i] = -2.*fast_gradient;
     knl_scor_ener_table[i] = -1.*scor_energy;
     knl_scor_grad_table[i] = -2.*scor_gradient;
     knl_slow_ener_table[i] = (-1.*scor_energy - (scale14-1)*slow_energy) /
       scale14;
     knl_slow_grad_table[i] = (-2.*scor_gradient - 
                               (scale14-1)*2.*slow_gradient) / scale14;
     knl_excl_ener_table[i] = slow_energy - scor_energy;
     knl_excl_grad_table[i] = 2.*(slow_gradient - scor_gradient);
 #ifdef NAMD_KNL
     knl_corr_ener_table[i] = -1.*(fast_energy + scor_energy);
     knl_corr_grad_table[i] = -2.*(fast_gradient + scor_gradient);
 #endif
     if ( i == nn-1 ) {
       knl_fast_ener_table[nn] = knl_fast_ener_table[i];
       knl_fast_grad_table[nn] = knl_fast_grad_table[i];
       knl_scor_ener_table[nn] = knl_scor_ener_table[i];
       knl_scor_grad_table[nn] = knl_scor_grad_table[i];
       knl_slow_ener_table[nn] = knl_slow_ener_table[i];
       knl_slow_grad_table[nn] = knl_slow_grad_table[i];
       knl_excl_ener_table[nn] = knl_excl_ener_table[i];
       knl_excl_grad_table[nn] = knl_excl_grad_table[i];
 #ifdef NAMD_KNL
       knl_corr_ener_table[nn] = knl_corr_ener_table[i];
       knl_corr_grad_table[nn] = knl_corr_grad_table[i];
 #endif
     }
    } else {
 #endif
     *(fast_i++) = fast_energy;
     *(fast_i++) = fast_gradient;
     *(fast_i++) = 0;
     *(fast_i++) = 0;
     *(scor_i++) = scor_energy;
     *(scor_i++) = scor_gradient;
     *(scor_i++) = 0;
     *(scor_i++) = 0;
     *(slow_i++) = slow_energy;
     *(slow_i++) = slow_gradient;
     *(slow_i++) = 0;
     *(slow_i++) = 0;
     *(vdwa_i++) = vdwa_energy;
     *(vdwa_i++) = vdwa_gradient;
     *(vdwa_i++) = 0;
     *(vdwa_i++) = 0;
     *(vdwb_i++) = vdwb_energy;
     *(vdwb_i++) = vdwb_gradient;
     *(vdwb_i++) = 0;
     *(vdwb_i++) = 0;
     *(r2_i++) = r2 + r2_delta;
 #if defined(NAMD_KNL) || defined(NAMD_AVXTILES)
    }
 #endif
 
   }
 #if defined(NAMD_KNL) || defined(NAMD_AVXTILES)
  } // knl_table loop
 #endif
 
   if ( ! r2_delta_i ) {
     NAMD_bug("Failed to find table entry for r2 == r2_limit\n");
   }
   if ( r2_table[r2_delta_i] > r2_limit + r2_delta ) {
     NAMD_bug("Found bad table entry for r2 == r2_limit\n");
   }
 
   int j;
   const char *table_name = "XXXX";
   int smooth_short = 0;
   for ( j=0; j<5; ++j ) {
     BigReal *t0 = 0;
     switch (j) {
       case 0: 
         t0 = fast_table;
         table_name = "FAST";
         smooth_short = 1;
       break;
       case 1: 
         t0 = scor_table;
         table_name = "SCOR";
         smooth_short = 0;
       break;
       case 2: 
         t0 = slow_table;
         table_name = "SLOW";
         smooth_short = 0;
       break;
       case 3: 
         t0 = vdwa_table;
         table_name = "VDWA";
         smooth_short = 1;
       break;
       case 4: 
         t0 = vdwb_table;
         table_name = "VDWB";
         smooth_short = 1;
       break;
     }
     // patch up data for i=0
     t0[0] = t0[4] - t0[5] * ( r2_delta / 64.0 );  // energy
     t0[1] = t0[5];  // gradient
     t0[2] = 0;
     t0[3] = 0;
     if ( smooth_short ) {
       BigReal energy0 = t0[4*r2_delta_i];
       BigReal gradient0 = t0[4*r2_delta_i+1];
       BigReal r20 = r2_table[r2_delta_i];
       t0[0] = energy0 - gradient0 * (r20 - r2_table[0]);  // energy
       t0[1] = gradient0;  // gradient
     }
     BigReal *t;
     for ( i=0,t=t0; i<(n-1); ++i,t+=4 ) {
       BigReal x = ( r2_delta * ( 1 << (i/64) ) ) / 64.0;
       if ( r2_table[i+1] != r2_table[i] + x ) {
         NAMD_bug("Bad table delta calculation.\n");
       }
       if ( smooth_short && i+1 < r2_delta_i ) {
         BigReal energy0 = t0[4*r2_delta_i];
         BigReal gradient0 = t0[4*r2_delta_i+1];
         BigReal r20 = r2_table[r2_delta_i];
         t[4] = energy0 - gradient0 * (r20 - r2_table[i+1]);  // energy
         t[5] = gradient0;  // gradient
       }
       BigReal v1 = t[0];
       BigReal g1 = t[1];
       BigReal v2 = t[4];
       BigReal g2 = t[5];
       // explicit formulas for v1 + g1 x + c x^2 + d x^3
       BigReal c = ( 3.0 * (v2 - v1) - x * (2.0 * g1 + g2) ) / ( x * x );
       BigReal d = ( -2.0 * (v2 - v1) + x * (g1 + g2) ) / ( x * x * x );
       // since v2 - v1 is imprecise, we refine c and d numerically
       // important because we need accurate forces (more than energies!)
       for ( int k=0; k < 2; ++k ) {
         BigReal dv = (v1 - v2) + ( ( d * x + c ) * x + g1 ) * x;
         BigReal dg = (g1 - g2) + ( 3.0 * d * x + 2.0 * c ) * x;
         c -= ( 3.0 * dv - x * dg ) / ( x * x );
         d -= ( -2.0 * dv + x * dg ) / ( x * x * x );
       }
       // store in the array;
       t[2] = c;  t[3] = d;
     }
 
     if ( ! CkMyPe() ) {
     BigReal dvmax = 0;
     BigReal dgmax = 0;
     BigReal dvmax_r = 0;
     BigReal dgmax_r = 0;
     BigReal fdvmax = 0;
     BigReal fdgmax = 0;
     BigReal fdvmax_r = 0;
     BigReal fdgmax_r = 0;
     BigReal dgcdamax = 0;
     BigReal dgcdimax = 0;
     BigReal dgcaimax = 0;
     BigReal dgcdamax_r = 0;
     BigReal dgcdimax_r = 0;
     BigReal dgcaimax_r = 0;
     BigReal fdgcdamax = 0;
     BigReal fdgcdimax = 0;
     BigReal fdgcaimax = 0;
     BigReal fdgcdamax_r = 0;
     BigReal fdgcdimax_r = 0;
     BigReal fdgcaimax_r = 0;
     BigReal gcm = fabs(t0[1]);  // gradient magnitude running average
     for ( i=0,t=t0; i<(n-1); ++i,t+=4 ) {
       const BigReal r2_base = r2_delta * ( 1 << (i/64) );
       const BigReal r2_del = r2_base / 64.0;
       const BigReal r2 = r2_base - r2_delta + r2_del * (i%64);
       const BigReal r = sqrt(r2);
       if ( r > cutoff ) break;
       BigReal x = r2_del;
       BigReal dv = ( ( t[3] * x + t[2] ) * x + t[1] ) * x + t[0] - t[4];
       BigReal dg = ( 3.0 * t[3] * x + 2.0 * t[2] ) * x + t[1] - t[5];
       if ( t[4] != 0. && fabs(dv/t[4]) > fdvmax ) {
         fdvmax = fabs(dv/t[4]); fdvmax_r = r;
       }
       if ( fabs(dv) > dvmax ) {
         dvmax = fabs(dv); dvmax_r = r;
       }
       if ( t[5] != 0. && fabs(dg/t[5]) > fdgmax ) {
         fdgmax = fabs(dg/t[5]); fdgmax_r = r;
       }
       if ( fabs(dg) > dgmax ) {
         dgmax = fabs(dg); dgmax_r = r;
       }
       BigReal gcd = (t[4] - t[0]) / x;  // centered difference gradient
       BigReal gcd_prec = (fabs(t[0]) + fabs(t[4])) * 1.e-15 / x;  // roundoff
       gcm = 0.9 * gcm + 0.1 * fabs(t[5]);  // magnitude running average
       BigReal gca = 0.5  * (t[1] + t[5]);  // centered average gradient
       BigReal gci = ( 0.75 * t[3] * x + t[2] ) * x + t[1];  // interpolated
       BigReal rc = sqrt(r2 + 0.5 * x);
       BigReal dgcda = gcd - gca;
       if ( dgcda != 0. && fabs(dgcda) < gcd_prec ) {
         // CkPrintf("ERROR %g < PREC %g AT %g AVG VAL %g\n", dgcda, gcd_prec, rc, gca);
         dgcda = 0.;
       }
       BigReal dgcdi = gcd - gci;
       if ( dgcdi != 0. && fabs(dgcdi) < gcd_prec ) {
         // CkPrintf("ERROR %g < PREC %g AT %g INT VAL %g\n", dgcdi, gcd_prec, rc, gci);
         dgcdi = 0.;
       }
       BigReal dgcai = gca - gci;
       if ( t[1]*t[5] > 0. && gcm != 0. && fabs(dgcda/gcm) > fdgcdamax ) {
         fdgcdamax = fabs(dgcda/gcm); fdgcdamax_r = rc;
       }
       if ( fabs(dgcda) > fdgcdamax ) {
         dgcdamax = fabs(dgcda); dgcdamax_r = rc;
       }
       if ( t[1]*t[5] > 0. && gcm != 0. && fabs(dgcdi/gcm) > fdgcdimax ) {
         fdgcdimax = fabs(dgcdi/gcm); fdgcdimax_r = rc;
       }
       if ( fabs(dgcdi) > fdgcdimax ) {
         dgcdimax = fabs(dgcdi); dgcdimax_r = rc;
       }
       if ( t[1]*t[5] > 0. && gcm != 0. && fabs(dgcai/gcm) > fdgcaimax ) {
         fdgcaimax = fabs(dgcai/gcm); fdgcaimax_r = rc;
       }
       if ( fabs(dgcai) > fdgcaimax ) {
         dgcaimax = fabs(dgcai); dgcaimax_r = rc;
       }
 #if 0
       CkPrintf("TABLE %s %g %g %g %g\n",table_name,rc,dgcda/gcm,dgcda,gci);
       if (dv != 0.) CkPrintf("TABLE %d ENERGY ERROR %g AT %g (%d)\n",j,dv,r,i);
       if (dg != 0.) CkPrintf("TABLE %d FORCE ERROR %g AT %g (%d)\n",j,dg,r,i);
 #endif
     }
     if ( dvmax != 0.0 ) {
       iout << iINFO << "ABSOLUTE IMPRECISION IN " << table_name <<
         " TABLE ENERGY: " << dvmax << " AT " << dvmax_r << "\n" << endi;
     }
     if ( fdvmax != 0.0 ) {
       iout << iINFO << "RELATIVE IMPRECISION IN " << table_name <<
         " TABLE ENERGY: " << fdvmax << " AT " << fdvmax_r << "\n" << endi;
     }
     if ( dgmax != 0.0 ) {
       iout << iINFO << "ABSOLUTE IMPRECISION IN " << table_name <<
         " TABLE FORCE: " << dgmax << " AT " << dgmax_r << "\n" << endi;
     }
     if ( fdgmax != 0.0 ) {
       iout << iINFO << "RELATIVE IMPRECISION IN " << table_name <<
         " TABLE FORCE: " << fdgmax << " AT " << fdgmax_r << "\n" << endi;
     }
     if (fdgcdamax != 0.0 ) {
       iout << iINFO << "INCONSISTENCY IN " << table_name <<
         " TABLE ENERGY VS FORCE: " << fdgcdamax << " AT " << fdgcdamax_r << "\n" << endi;
       if ( fdgcdamax > 0.1 ) {
         iout << iERROR << "\n";
         iout << iERROR << "CALCULATED " << table_name <<
           " FORCE MAY NOT MATCH ENERGY! POSSIBLE BUG!\n";
         iout << iERROR << "\n";
       }
     }
     if (0 && fdgcdimax != 0.0 ) {
       iout << iINFO << "INCONSISTENCY IN " << table_name <<
         " TABLE ENERGY VS FORCE: " << fdgcdimax << " AT " << fdgcdimax_r << "\n" << endi;
     }
     if ( 0 && fdgcaimax != 0.0 ) {
       iout << iINFO << "INCONSISTENCY IN " << table_name <<
         " TABLE AVG VS INT FORCE: " << fdgcaimax << " AT " << fdgcaimax_r << "\n" << endi;
     }
     }
 
   }
 
   for ( i=0; i<4*n; ++i ) {
     corr_table[i] = fast_table[i] + scor_table[i];
     full_table[i] = fast_table[i] + slow_table[i];
   }
 
 #if 0  
   for ( i=0; i<n; ++i ) {
    for ( int j=0; j<4; ++j ) {
     table_short[16*i+6-2*j] = table_noshort[16*i+6-2*j] = vdwa_table[4*i+j];
     table_short[16*i+7-2*j] = table_noshort[16*i+7-2*j] = vdwb_table[4*i+j];
     table_short[16*i+8+3-j] = fast_table[4*i+j];
     table_short[16*i+12+3-j] = scor_table[4*i+j];
     table_noshort[16*i+8+3-j] = corr_table[4*i+j];
     table_noshort[16*i+12+3-j] = full_table[4*i+j];
    }
   }
 #endif 
 
   for ( i=0; i<n; ++i ) {
     table_short[16*i+0] = table_noshort[16*i+0] = -6.*vdwa_table[4*i+3];
     table_short[16*i+1] = table_noshort[16*i+1] = -4.*vdwa_table[4*i+2];
     table_short[16*i+2] = table_noshort[16*i+2] = -2.*vdwa_table[4*i+1];
     table_short[16*i+3] = table_noshort[16*i+3] = -1.*vdwa_table[4*i+0];
     
     table_short[16*i+4] = table_noshort[16*i+4] = -6.*vdwb_table[4*i+3];
     table_short[16*i+5] = table_noshort[16*i+5] = -4.*vdwb_table[4*i+2];
     table_short[16*i+6] = table_noshort[16*i+6] = -2.*vdwb_table[4*i+1];
     table_short[16*i+7] = table_noshort[16*i+7] = -1.*vdwb_table[4*i+0];
     
     table_short[16*i+8]  = -6.*fast_table[4*i+3];
     table_short[16*i+9]  = -4.*fast_table[4*i+2];
     table_short[16*i+10] = -2.*fast_table[4*i+1];
     table_short[16*i+11] = -1.*fast_table[4*i+0];
 
     table_noshort[16*i+8]  = -6.*corr_table[4*i+3];
     table_noshort[16*i+9]  = -4.*corr_table[4*i+2];
     table_noshort[16*i+10] = -2.*corr_table[4*i+1];
     table_noshort[16*i+11] = -1.*corr_table[4*i+0];
 
     table_short[16*i+12] = -6.*scor_table[4*i+3];
     table_short[16*i+13] = -4.*scor_table[4*i+2];
     table_short[16*i+14] = -2.*scor_table[4*i+1];
     table_short[16*i+15] = -1.*scor_table[4*i+0];
 
     table_noshort[16*i+12] = -6.*full_table[4*i+3];
     table_noshort[16*i+13] = -4.*full_table[4*i+2];
     table_noshort[16*i+14] = -2.*full_table[4*i+1];
     table_noshort[16*i+15] = -1.*full_table[4*i+0];
   }
 
 #if 0
   char fname[100];
   sprintf(fname,"/tmp/namd.table.pe%d.dat",CkMyPe());
   FILE *f = fopen(fname,"w");
   for ( i=0; i<(n-1); ++i ) {
     const BigReal r2_base = r2_delta * ( 1 << (i/64) );
     const BigReal r2_del = r2_base / 64.0;
     const BigReal r2 = r2_base - r2_delta + r2_del * (i%64);
     BigReal *t;
     if ( r2 + r2_delta != r2_table[i] ) fprintf(f,"r2 error! ");
     fprintf(f,"%g",r2);
     t = fast_table + 4*i;
     fprintf(f,"   %g %g %g %g", t[0], t[1], t[2], t[3]);
     t = scor_table + 4*i;
     fprintf(f,"   %g %g %g %g", t[0], t[1], t[2], t[3]);
     t = slow_table + 4*i;
     fprintf(f,"   %g %g %g %g", t[0], t[1], t[2], t[3]);
     t = corr_table + 4*i;
     fprintf(f,"   %g %g %g %g", t[0], t[1], t[2], t[3]);
     t = full_table + 4*i;
     fprintf(f,"   %g %g %g %g", t[0], t[1], t[2], t[3]);
     t = vdwa_table + 4*i;
     fprintf(f,"   %g %g %g %g", t[0], t[1], t[2], t[3]);
     t = vdwb_table + 4*i;
     fprintf(f,"   %g %g %g %g", t[0], t[1], t[2], t[3]);
     fprintf(f,"\n");
   }
   fclose(f);
 #endif
 
   //Flip slow table to match table_four_i
   for ( i=0; i<n; ++i ) {
     BigReal tmp0, tmp1, tmp2, tmp3;
     tmp0 = slow_table [i*4 + 0];
     tmp1 = slow_table [i*4 + 1];
     tmp2 = slow_table [i*4 + 2];
     tmp3 = slow_table [i*4 + 3];
 
     slow_table [i*4 + 0] = tmp3;
     slow_table [i*4 + 1] = tmp2;
     slow_table [i*4 + 2] = tmp1;
     slow_table [i*4 + 3] = tmp0;
   }
 
   #ifdef NAMD_MIC
     send_build_mic_force_table();
   #endif
 }

◆ square()

static BigReal ComputeNonbondedUtil::square	(	const BigReal &	x,
		const BigReal &	y,
		const BigReal &	z
	)

inlinestatic

Definition at line 431 of file ComputeNonbondedUtil.h.

         {
         return(x*x+y*y+z*z);
         }

◆ submitPressureProfileData()

void ComputeNonbondedUtil::submitPressureProfileData	(	BigReal *	data,
		SubmitReduction *	reduction
	)

static

Definition at line 221 of file ComputeNonbondedUtil.C.

References SubmitReduction::add(), pressureProfileAtomTypes, and pressureProfileSlabs.

Referenced by ComputeNonbondedPair::doForce(), and ComputeNonbondedSelf::doForce().

 {
   if (!reduction) return;
   int numAtomTypes = pressureProfileAtomTypes;
   // For ease of calculation we stored interactions between types
   // i and j in (ni+j).  For efficiency now we coalesce the
   // cross interactions so that just i<=j are stored.
   const int arraysize = 3*pressureProfileSlabs;
   size_t nelems = arraysize*(numAtomTypes*(numAtomTypes+1))/2;
   BigReal *arr = new BigReal[nelems];
   memset(arr, 0, nelems*sizeof(BigReal));
 
   int i, j;
   for (i=0; i<numAtomTypes; i++) {
     for (j=0; j<numAtomTypes; j++) {
       int ii=i;
       int jj=j;
       if (ii > jj) { int tmp=ii; ii=jj; jj=tmp; }
       const int reductionOffset = (ii*numAtomTypes - (ii*(ii+1))/2 + jj)*arraysize;
       for (int k=0; k<arraysize; k++) {
         arr[reductionOffset+k] += data[k];
       }
       data += arraysize;
     }
   }
   // copy into reduction
   reduction->add(nelems, arr);
   delete [] arr;
 }

◆ submitReductionData()

void ComputeNonbondedUtil::submitReductionData	(	BigReal *	data,
		SubmitReduction *	reduction
	)

static

Definition at line 188 of file ComputeNonbondedUtil.C.

Referenced by ComputeNonbondedPair::doForce(), and ComputeNonbondedSelf::doForce().

 {
   reduction->item(REDUCTION_EXCLUSION_CHECKSUM) += data[exclChecksumIndex];
   reduction->item(REDUCTION_PAIRLIST_WARNINGS) += data[pairlistWarningIndex];
   reduction->item(REDUCTION_ELECT_ENERGY) += data[electEnergyIndex];
   reduction->item(REDUCTION_ELECT_ENERGY_SLOW) += data[fullElectEnergyIndex];
   reduction->item(REDUCTION_LJ_ENERGY) += data[vdwEnergyIndex];
   reduction->item(REDUCTION_LJ_ENERGY_SLOW) += data[fullVdwEnergyIndex];
   // Ported by JLai
   reduction->item(REDUCTION_GRO_LJ_ENERGY) += data[groLJEnergyIndex];
   reduction->item(REDUCTION_GRO_GAUSS_ENERGY) += data[groGaussEnergyIndex];
   reduction->item(REDUCTION_GO_NATIVE_ENERGY) += data[goNativeEnergyIndex];
   reduction->item(REDUCTION_GO_NONNATIVE_ENERGY) += data[goNonnativeEnergyIndex];
   // End of port -- JLai
 //fepb
   reduction->item(REDUCTION_ELECT_ENERGY_F) += data[electEnergyIndex_s];
   reduction->item(REDUCTION_ELECT_ENERGY_SLOW_F) += data[fullElectEnergyIndex_s];
   reduction->item(REDUCTION_LJ_ENERGY_F) += data[vdwEnergyIndex_s];
 
   reduction->item(REDUCTION_ELECT_ENERGY_TI_1) += data[electEnergyIndex_ti_1];
   reduction->item(REDUCTION_ELECT_ENERGY_SLOW_TI_1) += data[fullElectEnergyIndex_ti_1];
   reduction->item(REDUCTION_LJ_ENERGY_TI_1) += data[vdwEnergyIndex_ti_1];
   reduction->item(REDUCTION_ELECT_ENERGY_TI_2) += data[electEnergyIndex_ti_2];
   reduction->item(REDUCTION_ELECT_ENERGY_SLOW_TI_2) += data[fullElectEnergyIndex_ti_2];
   reduction->item(REDUCTION_LJ_ENERGY_TI_2) += data[vdwEnergyIndex_ti_2];
 //fepe
   ADD_TENSOR(reduction,REDUCTION_VIRIAL_NBOND,data,virialIndex);
   ADD_TENSOR(reduction,REDUCTION_VIRIAL_SLOW,data,fullElectVirialIndex);
   ADD_VECTOR(reduction,REDUCTION_PAIR_VDW_FORCE,data,pairVDWForceIndex);
   ADD_VECTOR(reduction,REDUCTION_PAIR_ELECT_FORCE,data,pairElectForceIndex);
   reduction->item(REDUCTION_COMPUTE_CHECKSUM) += 1.;
 }

Member Data Documentation

◆ A12_f

float ComputeNonbondedUtil::A12_f

static

Definition at line 375 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ A6_f

float ComputeNonbondedUtil::A6_f

static

Definition at line 372 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ accelMDOn

Bool ComputeNonbondedUtil::accelMDOn

static

Definition at line 409 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ alchDecouple

Bool ComputeNonbondedUtil::alchDecouple

static

Definition at line 392 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ alchFepOn

Bool ComputeNonbondedUtil::alchFepOn

static

Definition at line 387 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ alchThermIntOn

Bool ComputeNonbondedUtil::alchThermIntOn

static

Definition at line 388 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ alchVdwShiftCoeff

BigReal ComputeNonbondedUtil::alchVdwShiftCoeff

static

Definition at line 390 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ alchWCAOn

Bool ComputeNonbondedUtil::alchWCAOn

static

Definition at line 389 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ B12_f

float ComputeNonbondedUtil::B12_f

static

Definition at line 376 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ B6_f

float ComputeNonbondedUtil::B6_f

static

Definition at line 373 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ c0

BigReal ComputeNonbondedUtil::c0

static

Definition at line 378 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ c1

BigReal ComputeNonbondedUtil::c1

static

Definition at line 379 of file ComputeNonbondedUtil.h.

Referenced by CudaComputeNonbonded::getNonbondedCoef(), and select().

◆ C12_f

float ComputeNonbondedUtil::C12_f

static

Definition at line 377 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ c3

BigReal ComputeNonbondedUtil::c3

static

Definition at line 380 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ c5

BigReal ComputeNonbondedUtil::c5

static

Definition at line 381 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ c6

BigReal ComputeNonbondedUtil::c6

static

Definition at line 382 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ C6_f

float ComputeNonbondedUtil::C6_f

static

Definition at line 374 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ c7

BigReal ComputeNonbondedUtil::c7

static

Definition at line 383 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ c8

BigReal ComputeNonbondedUtil::c8

static

Definition at line 384 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ calcFullPair

void(* ComputeNonbondedUtil::calcFullPair)(nonbonded *)

static

Definition at line 253 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::doForce(), and select().

◆ calcFullPairEnergy

void(* ComputeNonbondedUtil::calcFullPairEnergy)(nonbonded *)

static

Definition at line 254 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::doForce(), and select().

◆ calcFullSelf

void(* ComputeNonbondedUtil::calcFullSelf)(nonbonded *)

static

Definition at line 255 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedSelf::doForce(), and select().

◆ calcFullSelfEnergy

void(* ComputeNonbondedUtil::calcFullSelfEnergy)(nonbonded *)

static

Definition at line 256 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedSelf::doForce(), and select().

◆ calcMergeDispPair

void(* ComputeNonbondedUtil::calcMergeDispPair)(nonbonded *)

static

Definition at line 263 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::doForce(), and select().

◆ calcMergeDispPairEnergy

void(* ComputeNonbondedUtil::calcMergeDispPairEnergy)(nonbonded *)

static

Definition at line 264 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::doForce(), and select().

◆ calcMergeDispSelf

void(* ComputeNonbondedUtil::calcMergeDispSelf)(nonbonded *)

static

Definition at line 265 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedSelf::doForce(), and select().

◆ calcMergeDispSelfEnergy

void(* ComputeNonbondedUtil::calcMergeDispSelfEnergy)(nonbonded *)

static

Definition at line 266 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedSelf::doForce(), and select().

◆ calcMergePair

void(* ComputeNonbondedUtil::calcMergePair)(nonbonded *)

static

Definition at line 258 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::doForce(), and select().

◆ calcMergePairEnergy

void(* ComputeNonbondedUtil::calcMergePairEnergy)(nonbonded *)

static

Definition at line 259 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::doForce(), and select().

◆ calcMergeSelf

void(* ComputeNonbondedUtil::calcMergeSelf)(nonbonded *)

static

Definition at line 260 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedSelf::doForce(), and select().

◆ calcMergeSelfEnergy

void(* ComputeNonbondedUtil::calcMergeSelfEnergy)(nonbonded *)

static

Definition at line 261 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedSelf::doForce(), and select().

◆ calcPair

void(* ComputeNonbondedUtil::calcPair)(nonbonded *)

static

Definition at line 248 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::doForce(), and select().

◆ calcPairEnergy

void(* ComputeNonbondedUtil::calcPairEnergy)(nonbonded *)

static

Definition at line 249 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::doForce(), and select().

◆ calcSelf

void(* ComputeNonbondedUtil::calcSelf)(nonbonded *)

static

Definition at line 250 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedSelf::doForce(), and select().

◆ calcSelfEnergy

void(* ComputeNonbondedUtil::calcSelfEnergy)(nonbonded *)

static

Definition at line 251 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedSelf::doForce(), and select().

◆ calcSlowPair

void(* ComputeNonbondedUtil::calcSlowPair)(nonbonded *)

static

Definition at line 268 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::doForce(), and select().

◆ calcSlowPairEnergy

void(* ComputeNonbondedUtil::calcSlowPairEnergy)(nonbonded *)

static

Definition at line 269 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::doForce(), and select().

◆ calcSlowSelf

void(* ComputeNonbondedUtil::calcSlowSelf)(nonbonded *)

static

Definition at line 270 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedSelf::doForce(), and select().

◆ calcSlowSelfEnergy

void(* ComputeNonbondedUtil::calcSlowSelfEnergy)(nonbonded *)

static

Definition at line 271 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedSelf::doForce(), and select().

◆ columnsize

int ComputeNonbondedUtil::columnsize

static

Definition at line 299 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ commOnly

Bool ComputeNonbondedUtil::commOnly

static

Definition at line 288 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::doForce(), ComputeNonbondedSelf::doForce(), and select().

◆ corr_table

BigReal * ComputeNonbondedUtil::corr_table

static

Definition at line 308 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ cutoff

BigReal ComputeNonbondedUtil::cutoff

static

Definition at line 291 of file ComputeNonbondedUtil.h.

Referenced by buildForceAndEnergyTable(), ComputeNonbondedPair::doForce(), ComputeNonbondedSelf::doForce(), CudaComputeNonbonded::getNonbondedCoef(), CudaComputeNonbonded::launchWork(), and select().

◆ cutoff2

BigReal ComputeNonbondedUtil::cutoff2

static

Definition at line 292 of file ComputeNonbondedUtil.h.

Referenced by ExclElem::computeForce(), CudaComputeNonbonded::getNonbondedCoef(), and select().

◆ cutoff2_f

float ComputeNonbondedUtil::cutoff2_f

static

Definition at line 293 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ cutoff_3

BigReal ComputeNonbondedUtil::cutoff_3

static

Definition at line 363 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ cutoff_3_f

float ComputeNonbondedUtil::cutoff_3_f

static

Definition at line 369 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ cutoff_6

BigReal ComputeNonbondedUtil::cutoff_6

static

Definition at line 364 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ cutoff_6_f

float ComputeNonbondedUtil::cutoff_6_f

static

Definition at line 370 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ dielectric_1

BigReal ComputeNonbondedUtil::dielectric_1

static

Definition at line 294 of file ComputeNonbondedUtil.h.

Referenced by OneFourNbTholeElem::computeForce(), ExclElem::computeForce(), ComputePme::doWork(), ComputeEwald::doWork(), HomePatch::positionsReady(), HomePatch::positionsReady_SOA(), and select().

◆ drudeNbthole

Bool ComputeNonbondedUtil::drudeNbthole

static

Definition at line 411 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ ewaldcof

BigReal ComputeNonbondedUtil::ewaldcof

static

Definition at line 414 of file ComputeNonbondedUtil.h.

Referenced by ComputeEwald::ComputeEwald(), ComputePme::doWork(), CudaComputeNonbonded::getNonbondedCoef(), ComputePmeMgr::gridCalc2R(), CudaPmePencilXYZ::initializeDevice(), CudaPmePencilZ::initializeDevice(), PmeXPencil::pme_kspace(), and select().

◆ fast_table

BigReal * ComputeNonbondedUtil::fast_table

static

Definition at line 305 of file ComputeNonbondedUtil.h.

Referenced by ExclElem::computeForce(), and select().

◆ fixedAtomsOn

Bool ComputeNonbondedUtil::fixedAtomsOn

static

Definition at line 289 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ full_table

BigReal * ComputeNonbondedUtil::full_table

static

Definition at line 309 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ goForcesOn

Bool ComputeNonbondedUtil::goForcesOn

static

Definition at line 426 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ goGroPair

Bool ComputeNonbondedUtil::goGroPair

static

Definition at line 425 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ goMethod

int ComputeNonbondedUtil::goMethod

static

Definition at line 427 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ k_vdwa

BigReal ComputeNonbondedUtil::k_vdwa

static

Definition at line 361 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ k_vdwa_f

float ComputeNonbondedUtil::k_vdwa_f

static

Definition at line 367 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ k_vdwb

BigReal ComputeNonbondedUtil::k_vdwb

static

Definition at line 362 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ k_vdwb_f

float ComputeNonbondedUtil::k_vdwb_f

static

Definition at line 368 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ lambda_table

BigReal * ComputeNonbondedUtil::lambda_table = 0

static

Definition at line 398 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ lesFactor

int ComputeNonbondedUtil::lesFactor

static

Definition at line 395 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ lesOn

Bool ComputeNonbondedUtil::lesOn

static

Definition at line 394 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ lesScaling

BigReal ComputeNonbondedUtil::lesScaling

static

Definition at line 396 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ LJewaldcof

BigReal ComputeNonbondedUtil::LJewaldcof

static

Definition at line 416 of file ComputeNonbondedUtil.h.

Referenced by ComputePme::doWork(), ComputePmeMgr::gridCalc2R(), and select().

◆ ljTable

const LJTable * ComputeNonbondedUtil::ljTable = 0

static

Definition at line 295 of file ComputeNonbondedUtil.h.

Referenced by ExclElem::computeForce(), dumpbench(), and select().

◆ mol

const Molecule * ComputeNonbondedUtil::mol

static

Definition at line 296 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ pairInteractionOn

Bool ComputeNonbondedUtil::pairInteractionOn

static

Definition at line 400 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ pairInteractionSelf

Bool ComputeNonbondedUtil::pairInteractionSelf

static

Definition at line 401 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ pi_ewaldcof

BigReal ComputeNonbondedUtil::pi_ewaldcof

static

Definition at line 415 of file ComputeNonbondedUtil.h.

Referenced by CudaComputeNonbonded::getNonbondedCoef(), and select().

◆ pressureProfileAtomTypes

int ComputeNonbondedUtil::pressureProfileAtomTypes

static

Definition at line 405 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::ComputeNonbondedPair(), ComputeNonbondedSelf::ComputeNonbondedSelf(), ComputeNonbondedPair::doForce(), ComputeNonbondedSelf::doForce(), select(), and submitPressureProfileData().

◆ pressureProfileMin

BigReal ComputeNonbondedUtil::pressureProfileMin

static

Definition at line 407 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::doForce(), and ComputeNonbondedSelf::doForce().

◆ pressureProfileOn

Bool ComputeNonbondedUtil::pressureProfileOn

static

Definition at line 403 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::ComputeNonbondedPair(), ComputeNonbondedSelf::ComputeNonbondedSelf(), ComputeNonbondedPair::doForce(), ComputeNonbondedSelf::doForce(), ComputeNonbondedPair::noWork(), ComputeNonbondedSelf::noWork(), and select().

◆ pressureProfileSlabs

int ComputeNonbondedUtil::pressureProfileSlabs

static

Definition at line 404 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::ComputeNonbondedPair(), ComputeNonbondedSelf::ComputeNonbondedSelf(), ComputeNonbondedPair::doForce(), ComputeNonbondedSelf::doForce(), select(), and submitPressureProfileData().

◆ pressureProfileThickness

BigReal ComputeNonbondedUtil::pressureProfileThickness

static

Definition at line 406 of file ComputeNonbondedUtil.h.

Referenced by ComputeNonbondedPair::doForce(), and ComputeNonbondedSelf::doForce().

◆ qmForcesOn

Bool ComputeNonbondedUtil::qmForcesOn

static

Definition at line 290 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ r2_delta

BigReal ComputeNonbondedUtil::r2_delta

static

Definition at line 297 of file ComputeNonbondedUtil.h.

Referenced by buildForceAndEnergyTable(), ExclElem::computeForce(), and select().

◆ r2_delta_1

BigReal ComputeNonbondedUtil::r2_delta_1

static

Definition at line 297 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ r2_delta_exp

int ComputeNonbondedUtil::r2_delta_exp

static

Definition at line 300 of file ComputeNonbondedUtil.h.

Referenced by buildForceAndEnergyTable(), ExclElem::computeForce(), and select().

◆ r2_table

BigReal * ComputeNonbondedUtil::r2_table

static

Definition at line 312 of file ComputeNonbondedUtil.h.

Referenced by buildForceAndEnergyTable(), ExclElem::computeForce(), and select().

◆ rowsize

int ComputeNonbondedUtil::rowsize

static

Definition at line 298 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ scale14

BigReal ComputeNonbondedUtil::scale14

static

Definition at line 355 of file ComputeNonbondedUtil.h.

Referenced by OneFourNbTholeElem::computeForce(), ExclElem::computeForce(), and select().

◆ scaling

BigReal ComputeNonbondedUtil::scaling

static

Definition at line 354 of file ComputeNonbondedUtil.h.

Referenced by calcGBIS(), OneFourNbTholeElem::computeForce(), ExclElem::computeForce(), ComputePme::doWork(), ComputeEwald::doWork(), HomePatch::positionsReady(), HomePatch::positionsReady_SOA(), and select().

◆ scor_table

BigReal * ComputeNonbondedUtil::scor_table

static

Definition at line 306 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ slow_table

BigReal * ComputeNonbondedUtil::slow_table

static

Definition at line 307 of file ComputeNonbondedUtil.h.

Referenced by ExclElem::computeForce(), and select().

◆ switchOn

BigReal ComputeNonbondedUtil::switchOn

static

Definition at line 356 of file ComputeNonbondedUtil.h.

Referenced by CudaComputeNonbonded::getNonbondedCoef(), and select().

◆ switchOn2

BigReal ComputeNonbondedUtil::switchOn2

static

Definition at line 358 of file ComputeNonbondedUtil.h.

Referenced by ExclElem::computeForce(), CudaComputeNonbonded::getNonbondedCoef(), and select().

◆ switchOn_1

BigReal ComputeNonbondedUtil::switchOn_1

static

Definition at line 357 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ switchOn_f

float ComputeNonbondedUtil::switchOn_f

static

Definition at line 371 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ table_alloc

BigReal * ComputeNonbondedUtil::table_alloc = 0

static

Definition at line 301 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ table_ener

BigReal * ComputeNonbondedUtil::table_ener = 0

static

Definition at line 302 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ table_length

int ComputeNonbondedUtil::table_length

static

Definition at line 313 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ table_noshort

BigReal * ComputeNonbondedUtil::table_noshort

static

Definition at line 304 of file ComputeNonbondedUtil.h.

Referenced by ExclElem::computeForce(), and select().

◆ table_short

BigReal * ComputeNonbondedUtil::table_short

static

Definition at line 303 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ v_vdwa

BigReal ComputeNonbondedUtil::v_vdwa

static

Definition at line 359 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ v_vdwa_f

float ComputeNonbondedUtil::v_vdwa_f

static

Definition at line 365 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ v_vdwb

BigReal ComputeNonbondedUtil::v_vdwb

static

Definition at line 360 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ v_vdwb_f

float ComputeNonbondedUtil::v_vdwb_f

static

Definition at line 366 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ vdw_switch_mode

int ComputeNonbondedUtil::vdw_switch_mode

static

Definition at line 422 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ vdwa_table

BigReal * ComputeNonbondedUtil::vdwa_table

static

Definition at line 310 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ vdwb_table

BigReal * ComputeNonbondedUtil::vdwb_table

static

Definition at line 311 of file ComputeNonbondedUtil.h.

Referenced by select().

◆ vdwForceSwitching

Bool ComputeNonbondedUtil::vdwForceSwitching

static

Definition at line 391 of file ComputeNonbondedUtil.h.

Referenced by select().

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

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ ComputeNonbondedUtil()

◆ ~ComputeNonbondedUtil()

Member Function Documentation

◆ calc_error()

◆ calc_pair()

◆ calc_pair_energy()

◆ calc_pair_energy_fep()

◆ calc_pair_energy_fullelect()

◆ calc_pair_energy_fullelect_fep()

◆ calc_pair_energy_fullelect_go()

◆ calc_pair_energy_fullelect_int()

◆ calc_pair_energy_fullelect_les()

◆ calc_pair_energy_fullelect_pprof()

◆ calc_pair_energy_fullelect_tabener()

◆ calc_pair_energy_fullelect_ti()

◆ calc_pair_energy_go()

◆ calc_pair_energy_int()

◆ calc_pair_energy_les()

◆ calc_pair_energy_merge_fullelect()

◆ calc_pair_energy_merge_fullelect_fep()

◆ calc_pair_energy_merge_fullelect_fulldisp()

◆ calc_pair_energy_merge_fullelect_go()

◆ calc_pair_energy_merge_fullelect_int()

◆ calc_pair_energy_merge_fullelect_les()

◆ calc_pair_energy_merge_fullelect_pprof()

◆ calc_pair_energy_merge_fullelect_tabener()

◆ calc_pair_energy_merge_fullelect_ti()

◆ calc_pair_energy_pprof()

◆ calc_pair_energy_slow_fullelect()

◆ calc_pair_energy_slow_fullelect_fep()

◆ calc_pair_energy_slow_fullelect_go()

◆ calc_pair_energy_slow_fullelect_les()

◆ calc_pair_energy_slow_fullelect_pprof()

◆ calc_pair_energy_slow_fullelect_tabener()

◆ calc_pair_energy_slow_fullelect_ti()

◆ calc_pair_energy_tabener()

◆ calc_pair_energy_ti()

◆ calc_pair_fullelect()

◆ calc_pair_fullelect_go()

◆ calc_pair_fullelect_les()

◆ calc_pair_fullelect_pprof()

◆ calc_pair_fullelect_tabener()

◆ calc_pair_fullelect_ti()

◆ calc_pair_go()

◆ calc_pair_les()

◆ calc_pair_merge_fullelect()

◆ calc_pair_merge_fullelect_fulldisp()

◆ calc_pair_merge_fullelect_go()

◆ calc_pair_merge_fullelect_les()

◆ calc_pair_merge_fullelect_pprof()

◆ calc_pair_merge_fullelect_tabener()

◆ calc_pair_merge_fullelect_ti()

◆ calc_pair_pprof()

◆ calc_pair_slow_fullelect()

◆ calc_pair_slow_fullelect_go()

◆ calc_pair_slow_fullelect_les()

◆ calc_pair_slow_fullelect_pprof()

◆ calc_pair_slow_fullelect_tabener()

◆ calc_pair_slow_fullelect_ti()

◆ calc_pair_tabener()

◆ calc_pair_ti()

◆ calc_self()

◆ calc_self_energy()

◆ calc_self_energy_fep()

◆ calc_self_energy_fullelect()

◆ calc_self_energy_fullelect_fep()

◆ calc_self_energy_fullelect_go()

◆ calc_self_energy_fullelect_int()

◆ calc_self_energy_fullelect_les()

◆ calc_self_energy_fullelect_pprof()

◆ calc_self_energy_fullelect_tabener()

◆ calc_self_energy_fullelect_ti()