# Lattice Class Reference

`#include <Lattice.h>`

List of all members.

## Public Member Functions

Lattice (void)
void set (Vector A, Vector B, Vector C)
void set (Vector A, Vector B, Vector C, Position Origin)
void rescale (Tensor factor)
void rescale (Position &p, Tensor factor) const
Position unscale (ScaledPosition s) const
ScaledPosition scale (Position p) const
Position nearest (Position data, ScaledPosition ref) const
Position nearest (Position data, ScaledPosition ref, Transform *t) const
Position apply_transform (Position data, const Transform &t) const
Position reverse_transform (Position data, const Transform &t) const
Vector delta (const Position &pos1, const Position &pos2) const
Vector delta (const Position &pos1) const
Vector wrap_delta (const Position &pos1) const
Vector wrap_nearest_delta (Position pos1) const
Vector offset (int i) const
Vector a () const
Vector b () const
Vector c () const
int orthogonal () const
Vector origin () const
Vector a_r () const
Vector b_r () const
Vector c_r () const
int a_p () const
int b_p () const
int c_p () const
BigReal volume (void) const

## Static Public Member Functions

static int index (int i=0, int j=0, int k=0)
static int offset_a (int i)
static int offset_b (int i)
static int offset_c (int i)

## Detailed Description

Definition at line 17 of file Lattice.h.

## Constructor & Destructor Documentation

 Lattice::Lattice ( void ) ` [inline]`

Definition at line 20 of file Lattice.h.

```00020                 : a1(0,0,0), a2(0,0,0), a3(0,0,0),
00021                   b1(0,0,0), b2(0,0,0), b3(0,0,0),
00022                   o(0,0,0), p1(0), p2(0), p3(0) {};
```

## Member Function Documentation

 Vector Lattice::a ( ) const` [inline]`

Definition at line 252 of file Lattice.h.

```00252 { return a1; }
```

 int Lattice::a_p ( ) const` [inline]`

Definition at line 273 of file Lattice.h.

```00273 { return p1; }
```

 Vector Lattice::a_r ( ) const` [inline]`

Definition at line 268 of file Lattice.h.

```00268 { return b1; }
```

 Position Lattice::apply_transform ( Position data, const Transform & t ) const` [inline]`

Definition at line 132 of file Lattice.h.

References Transform::i, Transform::j, and Transform::k.

```00133   {
00134     return ( data + t.i*a1 + t.j*a2 + t.k*a3 );
00135   }
```

 Vector Lattice::b ( ) const` [inline]`

Definition at line 253 of file Lattice.h.

```00253 { return a2; }
```

 int Lattice::b_p ( ) const` [inline]`

Definition at line 274 of file Lattice.h.

```00274 { return p2; }
```

 Vector Lattice::b_r ( ) const` [inline]`

Definition at line 269 of file Lattice.h.

```00269 { return b2; }
```

 Vector Lattice::c ( ) const` [inline]`

 int Lattice::c_p ( ) const` [inline]`

Definition at line 275 of file Lattice.h.

```00275 { return p3; }
```

 Vector Lattice::c_r ( ) const` [inline]`

Definition at line 270 of file Lattice.h.

```00270 { return b3; }
```

 Vector Lattice::delta ( const Position & pos1 ) const` [inline]`

Definition at line 195 of file Lattice.h.

References namdnearbyint.

```00196   {
00197     Vector diff = pos1 - o;
00198     Vector result = diff;
00199     if ( p1 ) result -= a1*namdnearbyint(b1*diff);
00200     if ( p2 ) result -= a2*namdnearbyint(b2*diff);
00201     if ( p3 ) result -= a3*namdnearbyint(b3*diff);
00202     return result;
00203   }
```

 Vector Lattice::delta ( const Position & pos1, const Position & pos2 ) const` [inline]`

Definition at line 144 of file Lattice.h.

References namdnearbyint, Vector::x, Vector::y, and Vector::z.

```00145   {
00146     Vector diff = pos1 - pos2;
00147 #ifdef ARCH_POWERPC   //Prevents stack temporaries
00148     Vector result = diff;
00149     if ( p1 ) {
00150       BigReal fval = namdnearbyint(b1*diff);
00151       result.x -= a1.x *fval;
00152       result.y -= a1.y *fval;
00153       result.z -= a1.z *fval;
00154     }
00155     if ( p2 ) {
00156       BigReal fval = namdnearbyint(b2*diff);
00157       result.x -= a2.x * fval;
00158       result.y -= a2.y * fval;
00159       result.z -= a2.z * fval;
00160     }
00161     if ( p3 ) {
00162       BigReal fval = namdnearbyint(b3*diff);
00163       result.x -= a3.x * fval;
00164       result.y -= a3.y * fval;
00165       result.z -= a3.z * fval;
00166     }
00167     return result;
00168 #else
00169     BigReal f1 = p1 ? namdnearbyint(b1*diff) : 0.;
00170     BigReal f2 = p2 ? namdnearbyint(b2*diff) : 0.;
00171     BigReal f3 = p3 ? namdnearbyint(b3*diff) : 0.;
00172     diff.x -= f1*a1.x + f2*a2.x + f3*a3.x;
00173     diff.y -= f1*a1.y + f2*a2.y + f3*a3.y;
00174     diff.z -= f1*a1.z + f2*a2.z + f3*a3.z;
00175     return diff;
00176 #endif
00177   }
```

 static int Lattice::index ( int i = `0`, int j = `0`, int k = `0` ) ` [inline, static]`

Definition at line 25 of file Lattice.h.

References j.

```00026   {
00027     return 9 * (k+1) + 3 * (j+1) + (i+1);
00028   }
```

 Position Lattice::nearest ( Position data, ScaledPosition ref, Transform * t ) const` [inline]`

Definition at line 107 of file Lattice.h.

References Transform::i, Transform::j, Transform::k, namdnearbyint, scale(), unscale(), Vector::x, Vector::y, and Vector::z.

```00108   {
00109     ScaledPosition sn = scale(data);
00110     if ( p1 ) {
00111       BigReal tmp = sn.x - ref.x;
00112       BigReal rit = namdnearbyint(tmp);
00113       sn.x -= rit;
00114       t->i -= (int) rit;
00115     }
00116     if ( p2 ) {
00117       BigReal tmp = sn.y - ref.y;
00118       BigReal rit = namdnearbyint(tmp);
00119       sn.y -= rit;
00120       t->j -= (int) rit;
00121     }
00122     if ( p3 ) {
00123       BigReal tmp = sn.z - ref.z;
00124       BigReal rit = namdnearbyint(tmp);
00125       sn.z -= rit;
00126       t->k -= (int) rit;
00127     }
00128     return unscale(sn);
00129   }
```

 Position Lattice::nearest ( Position data, ScaledPosition ref ) const` [inline]`

Definition at line 90 of file Lattice.h.

References namdnearbyint, scale(), unscale(), Vector::x, Vector::y, and Vector::z.

Referenced by WorkDistrib::createAtomLists(), and HomePatch::depositMigration().

```00091   {
00092     ScaledPosition sn = scale(data);
00093     if ( p1 ) {
00094       sn.x -= namdnearbyint(sn.x - ref.x);
00095     }
00096     if ( p2 ) {
00097       sn.y -= namdnearbyint(sn.y - ref.y);
00098     }
00099     if ( p3 ) {
00100       sn.z -= namdnearbyint(sn.z - ref.z);
00101     }
00102     return unscale(sn);
00103   }
```

 Vector Lattice::offset ( int i ) const` [inline]`

Definition at line 242 of file Lattice.h.

Referenced by ComputeNonbondedPair::doForce().

```00243   {
00244     return ( (i%3-1) * a1 + ((i/3)%3-1) * a2 + (i/9-1) * a3 );
00245   }
```

 static int Lattice::offset_a ( int i ) ` [inline, static]`

Definition at line 247 of file Lattice.h.

Referenced by registerUserEventsForAllComputeObjs().

```00247 { return (i%3-1); }
```

 static int Lattice::offset_b ( int i ) ` [inline, static]`

Definition at line 248 of file Lattice.h.

Referenced by registerUserEventsForAllComputeObjs().

```00248 { return ((i/3)%3-1); }
```

 static int Lattice::offset_c ( int i ) ` [inline, static]`

Definition at line 249 of file Lattice.h.

Referenced by registerUserEventsForAllComputeObjs().

```00249 { return (i/9-1); }
```

 Vector Lattice::origin ( ) const` [inline]`

 int Lattice::orthogonal ( ) const` [inline]`

Definition at line 257 of file Lattice.h.

References Vector::x, Vector::y, and Vector::z.

Referenced by colvarproxy_namd::calculate().

```00257                          {
00258     return ( ! ( a1.y || a1.z || a2.x || a2.z || a3.x || a3.y ) );
00259   }
```

 void Lattice::rescale ( Position & p, Tensor factor ) const` [inline]`

Definition at line 69 of file Lattice.h.

```00070   {
00071     p -= o;
00072     p = factor * p;
00073     p += o;
00074   }
```

 void Lattice::rescale ( Tensor factor ) ` [inline]`

Definition at line 60 of file Lattice.h.

```00061   {
00062     a1 = factor * a1;
00063     a2 = factor * a2;
00064     a3 = factor * a3;
00065     recalculate();
00066   }
```

 Position Lattice::reverse_transform ( Position data, const Transform & t ) const` [inline]`

Definition at line 138 of file Lattice.h.

References Transform::i, Transform::j, and Transform::k.

```00139   {
00140     return ( data - t.i*a1 - t.j*a2 - t.k*a3 );
00141   }
```

 ScaledPosition Lattice::scale ( Position p ) const` [inline]`

Definition at line 83 of file Lattice.h.

```00084   {
00085     p -= o;
00086     return Vector(b1*p,b2*p,b3*p);
00087   }
```

 void Lattice::set ( Vector A, Vector B, Vector C, Position Origin ) ` [inline]`

Definition at line 37 of file Lattice.h.

References A, B, cross(), Vector::length(), Vector::length2(), and volume().

```00038   {
00039     a1 = A; a2 = B; a3 = C; o = Origin;
00040     p1 = ( a1.length2() ? 1 : 0 );
00041     p2 = ( a2.length2() ? 1 : 0 );
00042     p3 = ( a3.length2() ? 1 : 0 );
00043     if ( ! p1 ) a1 = Vector(1.0,0.0,0.0);
00044     if ( ! p2 ) {
00045       Vector u1 = a1 / a1.length();
00046       Vector e_z(0.0,0.0,1.0);
00047       if ( fabs(e_z * u1) < 0.9 ) { a2 = cross(e_z,a1); }
00048       else { a2 = cross(Vector(1.0,0.0,0.0),a1); }
00049       a2 /= a2.length();
00050     }
00051     if ( ! p3 ) {
00052       a3 = cross(a1,a2);
00053       a3 /= a3.length();
00054     }
00055     if ( volume() < 0.0 ) a3 *= -1.0;
00056     recalculate();
00057   }
```

 void Lattice::set ( Vector A, Vector B, Vector C ) ` [inline]`

Definition at line 31 of file Lattice.h.

References A, and B.

Referenced by get_lattice_from_ts().

```00032   {
00033     set(A,B,C,o);
00034   }
```

 Position Lattice::unscale ( ScaledPosition s ) const` [inline]`

Definition at line 77 of file Lattice.h.

References Vector::x, Vector::y, and Vector::z.

```00078   {
00079     return (o + a1*s.x + a2*s.y + a3*s.z);
00080   }
```

 BigReal Lattice::volume ( void ) const` [inline]`

Definition at line 277 of file Lattice.h.

References cross().

```00278   {
00279     return ( p1 && p2 && p3 ? cross(a1,a2) * a3 : 0.0 );
00280   }
```

 Vector Lattice::wrap_delta ( const Position & pos1 ) const` [inline]`

Definition at line 206 of file Lattice.h.

References namdnearbyint.

```00207   {
00208     Vector diff = pos1 - o;
00209     Vector result(0.,0.,0.);
00210     if ( p1 ) result -= a1*namdnearbyint(b1*diff);
00211     if ( p2 ) result -= a2*namdnearbyint(b2*diff);
00212     if ( p3 ) result -= a3*namdnearbyint(b3*diff);
00213     return result;
00214   }
```

 Vector Lattice::wrap_nearest_delta ( Position pos1 ) const` [inline]`

Definition at line 217 of file Lattice.h.

References namdnearbyint.

Referenced by ParallelIOMgr::recvFinalClusterCoor(), and wrap_coor_int().

```00218   {
00219     Vector diff = pos1 - o;
00220     Vector result0(0.,0.,0.);
00221     if ( p1 ) result0 -= a1*namdnearbyint(b1*diff);
00222     if ( p2 ) result0 -= a2*namdnearbyint(b2*diff);
00223     if ( p3 ) result0 -= a3*namdnearbyint(b3*diff);
00224     diff += result0;
00225     BigReal dist = diff.length2();
00226     Vector result(0.,0.,0.);
00227     for ( int i1=-p1; i1<=p1; ++i1 ) {
00228       for ( int i2 =-p2; i2<=p2; ++i2 ) {
00229         for ( int i3 =-p3; i3<=p3; ++i3 ) {
00230           Vector newresult = i1*a1+i2*a2+i3*a3;
00231           BigReal newdist = (diff+newresult).length2();
00232           if ( newdist < dist ) {
00233             dist = newdist;
00234             result = newresult;
00235           }
00236         }
00237       }
00238     }
00239     return result0 + result;
00240   }
```

The documentation for this class was generated from the following file:
Generated on Thu Jul 19 01:17:20 2018 for NAMD by  1.4.7