LBflow > Reference

Home
Research
Publications
LBflow
LB theory
Downloads
Examples
Reference
LBview
Collaborators Contact
Links
Site last updated 21st June 2007

lattice.h

Go to the documentation of this file.
00001 /***************************************************************************
00002  *                                                                         *
00003  *   LBflow - an extensible lattice Boltzmann simulation framework         *
00004  *                                                                         *
00005  *   Copyright (C) 2007 by Ed Llewellin                                    *
00006  *                                                                         *
00007  *   This file may not be copied or shared without permission              *
00008  *   Contact ed@lbflow.co.uk or visit www.lbflow.co.uk                     *
00009  *                                                                         *
00010  ***************************************************************************/
00011 
00012 #ifndef LATTICE_H
00013 #define LATTICE_H
00014 
00015 #include <vector>
00016 #include <set>
00017 #include <map>
00018 #include <iostream>
00019 
00020 #ifdef HAVE_CONFIG_H
00021 #include <config.h>
00022 #endif 
00023 
00024 #include "simulation.h"
00025 
00026 //forward declarations
00027 class Parser;
00028 class TripleInt;
00029 class TripleDouble;
00030 class Node;
00031 
00032 using namespace std;
00033 
00034 //TODO: lattice should deal with all spatial information. Should have a where() function which returns a vector of indices 
00035 //      of node positions that conform to some positional descriptor. This would work with, e.g. "where(location)" in .sim files
00036 //      (parsed by nodegroup), and any other place where position info is required, such as in outputs.
00037 
00038 class Lattice {
00039 
00040   protected:
00041     //data members
00042     Simulation *sim;
00043     map<int, Node*> m; //NOTE: starts from 0
00044     //constructor
00045     Lattice(Simulation*);
00046 
00047   public:
00048     //destructor
00049     virtual ~Lattice(){};
00050     virtual void read(Parser*)=0;
00051     virtual void writeToSim(ostream&)=0;
00052     //transform between coordinate and indexing space
00053       //for discrete space
00054     virtual TripleInt       indexToLattCoords(int)=0;
00055     virtual TripleDouble    indexToPhysCoords(int)=0;
00056     virtual TripleDouble    lattCoordsToPhysCoords(TripleInt)=0;
00057     virtual TripleInt       physCoordsToLattCoords(TripleDouble)=0;
00058     virtual int             lattCoordsToIndex(TripleInt, bool)=0;
00059     virtual int             physCoordsToIndex(TripleDouble, bool)=0;
00060       //for continuous space
00061     virtual TripleDouble    physCoordsToLattCoordsCont(TripleDouble, bool)=0;
00062     virtual TripleDouble    lattCoordsToPhysCoordsCont(TripleDouble)=0;
00063     //get bookkeeping information about lattice
00064     virtual int             getDimensionality()=0;
00065     virtual string          getLatticeType()=0;
00066     virtual TripleInt       getLattDim()=0;
00067     virtual TripleDouble    getPhysDim()=0;
00068     virtual TripleDouble    getOrigin()=0;
00069     virtual TripleDouble    getCentre()=0;
00070     virtual int             getSize()=0;
00071     virtual string          getDescription()=0;
00072     virtual string          getDescriptorForDomainOutput()=0;
00073     //set nodes
00074     virtual void            put(int, Node*)=0;
00075     //get nodes
00076     virtual Node*           get(int)=0;
00077     virtual Node*           get(int, TripleInt)=0;
00078     virtual vector<Node*>*  getAdjacentNodes(int, vector<Node*>*)=0;
00079     virtual vector<Node*>*  getAdjacentNodes(int, vector<Node*>*, bool)=0;
00080 
00081 #ifdef ENABLE_MPI
00082   protected:
00083     //data members
00084     map<int, int>* mpi_procmap;
00085     set<int>* mpi_mynodes;
00086     map<int, map<int, int> >* mpi_boundaryneighbours;
00087   public:
00088     void mpiPartitionDomain(int, Simulation::PartitionType, map<int, int>*);
00089     void mpiSetProcMap(map<int, int>*, int);
00090     map<int, int>* mpiGetProcMap();
00091     set<int>* mpiGetMyNodes();
00092     void mpiCreateShuttles();
00093     map<int, map<int, int> >* mpiGetBoundaryNeighbours() {return mpi_boundaryneighbours;};
00094 
00095     bool mpiHasIndex(int i) {return m.find(i) != m.end();};
00096     virtual vector<int>*    mpiGetBoundaryNeighbours(int, vector<int>*)=0;
00097     virtual void mpiInitBoundaryMap()=0;
00098     
00099   protected:
00100     virtual void mpiPartitionTrivial(int, map<int, int>*)=0;
00101     virtual void mpiCreateMetisAdjacencyStructure(vector<int>*, vector<int>*)=0;
00102     virtual vector<int>* mpiGetAdjacentIndices(int, vector<int>*)=0;
00103     
00104   private:
00105     void mpiPartitionMetis(int, map<int, int>*);
00106     
00107 #endif /*ENABLE_MPI*/
00108 
00109 };
00110 
00111 #endif
>