Simulation.h

Go to the documentation of this file.

/* 
   Packing of hard spheres via molecular dynamics
   Developed by Monica Skoge, 2006, Princeton University
   Contact: Aleksandar Donev (adonev@math.princeton.edu) with questions
   This code may be used, modified and distributed freely.
   Please cite:

   "Packing Hyperspheres in High-Dimensional Euclidean Spaces"
        M. Skoge, A. Donev, F. H. Stillinger and S. Torquato, 2006

   if you use these codes.      
 */



#ifndef  _Simulation_H_
#define  _Simulation_H_

#include <math.h>
#include <vector>
#include <algorithm>
#include <functional>
#include <fstream>
#include <iostream>
#include "tarch/la/Vector.h"
#include "GlobalValue.h"
#include "Cells.h"
#include "Event.h"
#include "Sphere.h"
#include "Heap.h"
#include "Collisions.h"
#include "algorithms/geometries/SphereGeometry.h"

namespace algorithms{
namespace ls2{
class Simulation;
//#define PI     3.141592653589793238462643
#define VOLUMESPHERE_ls2 pow(tarch::la::PI,((double)(DIM))/2.)/exp(lgamma(1+((double)(DIM))/2.)) // volume prefactor for sphere
#define DBL_EPSILON_ls2  2.2204460492503131e-016 // smallest # such that 1.0+DBL_EPSILON!=1.0
#define Mass_ls2 1.0



class Simulation {

public:
        void growSphere();
        void findAllNeighbour(int i);
        void findNearestNeighbor(int i,double *criteria);
        double oneDimensionDistance(double r1,double r2);
        void getSpheres(std::vector<algorithms::geometries::SphereGeometry>& spheres) const;
Simulation(
    double Size_i,
    int N_i,
    double r_i,
    double growthrate_i,
    double maxpf_i,
    double various_i,
    std::vector<double>& array
);

        ~Simulation();


        //initial process
        int Optimalngrids();
        int Optimalngrids2(double maxr);
        void CreateSpheres(double temp);
        void CreateSphere(int Ncurrent);
        double Velocity(double temp);
        void VelocityGiver(double temp);
        void SetInitialEvents();
        void RecreateSpheres(const char* filename, double temp);
        void ReadPositions(const char* filename);
        void AssignCells();

        // Predicting next Event
        Event FindNextEvent(int i);
        void CollisionChecker(Event c);
        Event FindNextTransfer(int i);
        Event FindNextCollision(int i);
        void ForAllNeighbors(int, tarch::la::Vector<DIM, int>, tarch::la::Vector<DIM,int>, Collisions&);
        void PredictCollision(int i, int j, tarch::la::Vector<DIM, int> pboffset,
                        double& ctime, int& cpartner, 
                        tarch::la::Vector<DIM, int>& cpartnerpboffset);
        double CalculateCollision(int i, int j, tarch::la::Vector<DIM,double>  pboffset);
        double QuadraticFormula(double a, double b, double c);

        // Processing an Event
        void Process(int n);
        void ProcessEvent();
        void Collision(Event e);
        void Transfer(Event e);
        void UpdateCell(int i, tarch::la::Vector<DIM,int>& celli);
        void Synchronize(bool rescale);
        void ChangeNgrids(int newngrids);

        // Debugging
        void TrackPositions();
        void OutputEvents();
        void OutputCells();
        void GetInfo();
        int CheckSphereDiameters();

        // Statistics
        double Energy();
        double PackingFraction();
        void PrintStatistics();
        void RunTime();
        void WriteConfiguration(const char* wconfigfile);

        double getRadius() const;
        int getNumberGrids() const;
        double getPressure() const;
        double getFraction() const;
        double getEnergyChance() const;
        double getTotalEvents() const;
        double getCollisionrate() const;


private:

        double _SIZE;
        double r;
        const int N;
        double growthrate;
        int ngrids;
        double gtime;
        double rtime;
        double collisionrate;

        // statistics
        double pressure;
        double xmomentum;
        double pf;
        double energy;
        double energychange;
        int ncollisions;
        int ntransfers;
        int nchecks;
        int nEventstot;
        int ncycles;
        time_t start, error, end;

        // arrays
        Sphere *s;
        Cells<DIM, int> cells;
        int *binlist;
        Heap h;
        tarch::la::Vector<DIM,double> *x;
        double maxpf;
        double various_radius;
        std::vector<Sphere> neighbor;
        std::vector<double>& _array;
};
}/* close namespace ls2 */
}/* close namespace algorithms */
#endif