container.h

Go to the documentation of this file.

 
#ifndef CONTAINER_H 
#define CONTAINER_H
 
#include "common.h"
 
// ========================================================================  
// Container Class
// ========================================================================  
class Container {
    public:
        Container();
        virtual ~Container();
 
        TinyVector <unsigned int, NDIM> periodic;   
 
        dVec side;                          
        dVec sideInv;                       
        dVec sideInv2;                      
 
        double volume;                      
        double rcut2;                       
        double maxSep;                      
 
        string name;                        
 
        int numGrid;                        
        bool fullyPeriodic;                 
 
        dVec gridSize;                      
 
        void putInBC(dVec & r) const {
            r -= pSide*blitz::floor(r*sideInv + 0.5);
            /* int k; */
            /* for (int i = 0; i < NDIM; ++i) { */
            /*     k = int(r[i]*sideInv[i] + ((r[i]>=0.0)?0.5:-0.5)); */
            /*     r[i] -= k*pSide[i]; */
            /* } */
        }
 
        /* An old version */
        /* void putInBC1(dVec & r) const { */
        /*     for (int i = 0; i < NDIM; ++i) { */
        /*         r[i] -= (r[i] >= 0.5*side[i])*pSide[i]; */
        /*         r[i] += (r[i] < -0.5*side[i])*pSide[i]; */
        /*     } */
        /* } */
 
        /* Place a vector in boundary conditions. */
        void putInBC1(dVec & r) const {
            for (int i = 0; i < NDIM; ++i) {
                while (r[i] >= 0.5*side[i] && periodic[i])
                    r[i] -= pSide[i];
                while (r[i] < -0.5*side[i] && periodic[i])
                    r[i] += pSide[i];
            }
        }
 
        virtual void putInside(dVec &) const = 0;   
        
        virtual dVec randPosition(MTRand &) const = 0;                  
 
        virtual dVec randUpdate(MTRand &, const dVec &) const = 0;
 
        virtual int gridIndex(const dVec &) const = 0;
 
        virtual double gridBoxVolume(const int) const = 0;
 
        double gridRadius2(const int) const;
 
 
    protected:
        dVec pSide;         
};
 
// ========================================================================  
// Prism Class
// ========================================================================  
class Prism: public Container {
    public:
        Prism(const double, const int);
        Prism(const dVec &, const iVec &_periodic=1);
        ~Prism();
 
        void putInside(dVec &r) const {
            putInBC(r);
 
            /* This is slow!  Try function pointers? Or create a separate hard
             * top box? */
            if (!fullyPeriodic) {
                for (int i = 0; i < NDIM; i++) {
                    if (!periodic[i]) {
                        if (r[i] >= 0.5*side[i])
                            r[i] = 0.5*side[i] - 2*EPS;
                        if (r[i] < -0.5*side[i]) 
                            r[i] = -0.5*side[i] + 2*EPS;
                    }
                }
            }
        }
 
        dVec randPosition(MTRand &) const;                  
        dVec randUpdate(MTRand &, const dVec &) const;
        int gridIndex(const dVec &) const;
        double gridBoxVolume(const int) const;
};
 
// ========================================================================  
// Cylinder Class
// ========================================================================  
class Cylinder: public Container {
    public:
        Cylinder(const double, const double, const int);
        Cylinder(const double, const double);
        ~Cylinder();
 
        /* Place a vector inside the cylinder */
        void putInside(dVec &r) const;
 
        /* The various types of random positions inside the cylinder */
        dVec randPosition(MTRand &) const;                  
        dVec randUpdate(MTRand &, const dVec &) const;
 
        dVec randUpdateJumpShell(MTRand &, const dVec &) const;
        dVec randUpdateSmall(MTRand &, const dVec &) const;
 
        int gridIndex(const dVec &) const;
        double gridBoxVolume(const int) const;
};
#endif