mgrid.h

Go to the documentation of this file.

/*
 * Copyright (C) 2004-2005 by David J. Hardy.  All rights reserved.
 */

#ifndef MGRID_H
#define MGRID_H

#include "mdapi/mdtypes.h"
#include "mgrid/lattice.h"

#ifdef __cplusplus
extern "C" {
#endif

  /****************************************************************************
   * internal definitions
   ****************************************************************************/

  typedef struct MgridCell_tag {
    /* cells for geometric hashing, implement as cursor linked list */
    int32 head;          /* index of first atom in this cell */
    int32 cnt;           /* count number of atoms in this cell */
    int32 nnbrs;         /* length of neighbor cell list */
    int32 nbr[14];       /* up to half-shell of neighbors, including self */
    MD_Dvec offset[14];  /* offset for neighbors that are periodic images */
  } MgridCell;


  /****************************************************************************
   * user interface
   ****************************************************************************/

  /* error return value */
  enum {
    MGRID_FAIL = -1     
  };


  /* boundary */
  enum MgridBoundary_tag {
    MGRID_BOUNDARY_BEGIN = 0,
    MGRID_PERIODIC,     
    MGRID_NONPERIODIC,  
    MGRID_BOUNDARY_END
  };


  /* choice of grid approximation */
  enum MgridApprox_tag {
    MGRID_APPROX_BEGIN = 0,
    MGRID_CUBIC,
    MGRID_BSPLINE,
    MGRID_QUINTIC1,
    MGRID_QUINTIC2,
    MGRID_HEPTIC1,
    MGRID_HEPTIC3,
    MGRID_NONIC1,
    MGRID_NONIC4,
    MGRID_HERMITE,
    MGRID_APPROX_END
  };


  /* choice of splitting */
  enum MgridSplit_tag {
    MGRID_SPLIT_BEGIN = 0,
    MGRID_TAYLOR1,
    MGRID_TAYLOR2,
    MGRID_TAYLOR3,
    MGRID_TAYLOR4,
    MGRID_TAYLOR5,
    MGRID_TAYLOR6,
    MGRID_TAYLOR7,
    MGRID_TAYLOR8,
    MGRID_ERRMIN3,
    MGRID_EXSELF1,
    MGRID_EXSELF2,
    MGRID_EXSELF3,
    MGRID_EXSELF7,
    MGRID_ODDPR1,
    MGRID_ODDPR2,
    MGRID_ODDPR3,
    MGRID_ODDPR4,
    MGRID_ODDPR5,
    MGRID_ODDPR6,
    MGRID_ODDPR7,
    MGRID_ODDPR8,
    MGRID_SPLIT_END
  };


  typedef struct MgridParam_tag {
    MD_Dvec center;  
    double length;   
    double cutoff;   
    double spacing;  
    int32 nspacings; 
    int32 nlevels;   
    int32 boundary;  
    int32 natoms;    
    int32 approx;    
    int32 split;     
  } MgridParam;


  /* compute forces using system data */
  typedef struct MgridSystem_tag {

  /* output, user supplies arrays */
    double u_elec;
    double u_short;
    double u_long;
    MD_Dvec *f_elec;
    MD_Dvec *f_short;
    MD_Dvec *f_long;
  /* input */
    MD_Dvec *pos;
    double *charge;
  /* input, have mgrid process exclusions */
    int32 **excl_list;
    int32 **scaled14_list;
    double scaling14;
  } MgridSystem;


  /* contents opaque to user */
  typedef struct Mgrid_tag {
    MgridParam param;     /* copy user parameters */


    int (*short_force)(struct Mgrid_tag *, MgridSystem *);
      /* short range force evaluation "virtual" method */

    void (*short_done)(struct Mgrid_tag *);
      /* short range destructor "virtual" method */

    MD_Dvec lo;           /* lowest corner of grid cell lattice */
    double inv_cellsize;  /* inv_cellsize=(1/cellsize) */
    double inv_cutoff;    /* inv_cutoff=(1/cutoff) */

    int32 *next;          /* next "pointer" for cursor linked list */
      /* length is natoms, points to next atom within this grid cell */

    MgridCell *cell;      /* lattice of grid cells */
    int32 ncells;         /* total number of grid cells */
    int32 ndimcells;      /* number of grid cells in each dimension */
      /* (ncells == ndimcells * ndimcells * ndimcells) */

    int32 is_split_even_powers;
      /* splitting has even powers of r/a, for choosing evaluation routine */

    int (*cell_interactions)(struct Mgrid_tag *, MgridSystem *);
      /* evaluation routine for short range part */


    /*** long range force contribution ***/

    int (*long_force)(struct Mgrid_tag *, MgridSystem *);
      /* long range force evaluation "virtual" method */

    void (*long_done)(struct Mgrid_tag *);
      /* long range destructor "virtual" method */

    MD_Dvec origin;       /* lowest corner of domain, (0,0,0) of lattice */
    double inv_spacing;   /* 1/h, where h = lattice spacing */
    double u_self;        /* self potential */
    double g_zero;        /* smoothing g(r) evaluated at r=0 */

    MgridLattice *qgrid;  /* array of lattice of charge, length nlevels */

    MgridLattice *egrid;  /* array of lattice of potential, length nlevels */

    /* for interpolation schemes using only function values */
    double *scaling;      /* array of scaling for direct sum, length nlevels */

    MgridLattice gdsum;   /* direct sum weights for lattice cutoff parts */
    int32 gdsum_radius;   /* radius of lattice point "sphere" */

    MgridLattice glast;   /* last level direct sum weights */
    int32 glast_radius;   /* radius of lattice point "sphere" */

    /* for interpolation schemes using function values and derivatives */
    MgridLattice *gdsum_list;  /* direct sum weights, for each level */
    int32 *gdsum_radius_list;  /* radius of "sphere", for each level */

  } Mgrid;


  /* help user choose suitable params */

  int mgrid_param_config(MgridParam *p);


  /* convert between types and strings */

  int mgrid_string_to_boundary(const char *);

  const char *mgrid_boundary_to_string(int);

  int mgrid_string_to_approx(const char *);

  const char *mgrid_approx_to_string(int);

  int mgrid_string_to_split(const char *);

  const char *mgrid_split_to_string(int);


  /* methods for Mgrid */

  int mgrid_init(Mgrid *);

  int mgrid_setup(Mgrid *, const MgridSystem *s, const MgridParam *p);

  int mgrid_force(Mgrid *, MgridSystem *s);

  void mgrid_done(Mgrid *);


  /* validate atom positions within bounding cell */

  int mgrid_system_validate(const Mgrid *, const MgridSystem *s);


  /* compute exact smoothed part (for nonperiodic boundaries) */

  int mgrid_exact_smooth(Mgrid *, MgridSystem *s);


  /* internal methods for Mgrid */
  int mgrid_short_setup(Mgrid *);
  int mgrid_ncubic_setup(Mgrid *, const MgridSystem *);
  int mgrid_pcubic_setup(Mgrid *, const MgridSystem *);
  int mgrid_nbspline_setup(Mgrid *, const MgridSystem *);
  int mgrid_pbspline_setup(Mgrid *, const MgridSystem *);
  int mgrid_nquintic1_setup(Mgrid *, const MgridSystem *);
  int mgrid_pquintic1_setup(Mgrid *, const MgridSystem *);
  int mgrid_nquintic2_setup(Mgrid *, const MgridSystem *);
  int mgrid_pquintic2_setup(Mgrid *, const MgridSystem *);
  int mgrid_nheptic1_setup(Mgrid *, const MgridSystem *);
  int mgrid_pheptic1_setup(Mgrid *, const MgridSystem *);
  int mgrid_nheptic3_setup(Mgrid *, const MgridSystem *);
  int mgrid_pheptic3_setup(Mgrid *, const MgridSystem *);
  int mgrid_nnonic1_setup(Mgrid *, const MgridSystem *);
  int mgrid_pnonic1_setup(Mgrid *, const MgridSystem *);
  int mgrid_nnonic4_setup(Mgrid *, const MgridSystem *);
  int mgrid_pnonic4_setup(Mgrid *, const MgridSystem *);
  int mgrid_nhermite_setup(Mgrid *, const MgridSystem *);
  int mgrid_phermite_setup(Mgrid *, const MgridSystem *);
  int mgrid_setup_longrange(Mgrid *, const MgridSystem *);

#ifdef __cplusplus
}
#endif

#endif /* MGRID_H */

---