ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/branches/new_design/OOPSE-3.0/src/brains/SimInfo.hpp
(Generate patch)

Comparing:
trunk/OOPSE-3.0/src/brains/SimInfo.hpp (file contents), Revision 1636 by chrisfen, Fri Oct 22 22:54:01 2004 UTC vs.
branches/new_design/OOPSE-3.0/src/brains/SimInfo.hpp (file contents), Revision 1726 by tim, Wed Nov 10 22:50:03 2004 UTC

# Line 1 | Line 1
1 < #ifndef __SIMINFO_H__
2 < #define __SIMINFO_H__
1 > /*
2 > * Copyright (C) 2000-2004  Object Oriented Parallel Simulation Engine (OOPSE) project
3 > *
4 > * Contact: oopse@oopse.org
5 > *
6 > * This program is free software; you can redistribute it and/or
7 > * modify it under the terms of the GNU Lesser General Public License
8 > * as published by the Free Software Foundation; either version 2.1
9 > * of the License, or (at your option) any later version.
10 > * All we ask is that proper credit is given for our work, which includes
11 > * - but is not limited to - adding the above copyright notice to the beginning
12 > * of your source code files, and to any copyright notice that you may distribute
13 > * with programs based on this work.
14 > *
15 > * This program is distributed in the hope that it will be useful,
16 > * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 > * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 > * GNU Lesser General Public License for more details.
19 > *
20 > * You should have received a copy of the GNU Lesser General Public License
21 > * along with this program; if not, write to the Free Software
22 > * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23 > *
24 > */
25  
26 < #include <map>
27 < #include <string>
26 > /**
27 > * @file SimInfo.hpp
28 > * @author    tlin
29 > * @date  11/02/2004
30 > * @version 1.0
31 > */
32 >
33 > #ifndef BRAINS_SIMMODEL_HPP
34 > #define BRAINS_SIMMODEL_HPP
35 >
36 > #include <iostream>
37   #include <vector>
38 + #include <utility>
39  
40 < #include "primitives/Atom.hpp"
9 < #include "primitives/RigidBody.hpp"
40 > #include "brains/fSimulation.h"
41   #include "primitives/Molecule.hpp"
42 < #include "brains/Exclude.hpp"
43 < #include "brains/SkipList.hpp"
44 < #include "primitives/AbstractClasses.hpp"
14 < #include "types/MakeStamps.hpp"
15 < #include "brains/SimState.hpp"
16 < #include "restraints/Restraints.hpp"
42 > #include "types/MoleculeStamp.hpp"
43 > #include "utils/PropertyMap.hpp"
44 > #include "io/Globals.hpp"
45  
46 < #define __C
19 < #include "brains/fSimulation.h"
20 < #include "utils/GenericData.hpp"
46 > namespace oopse{
47  
48 + /**
49 + * @class SimInfo SimInfo.hpp "brains/SimInfo.hpp"
50 + * @brief
51 + */
52 + class SimInfo {
53 +    public:
54 +        typedef MoleculeIterator MoleculeIterator;
55 +        SimInfo();
56 +        virtual ~SimInfo();
57  
58 < //#include "Minimizer.hpp"
59 < //#include "minimizers/OOPSEMinimizer.hpp"
58 >        /**
59 >         * Adds a molecule
60 >         * @return return true if adding successfully, return false if the molecule is already in SimInfo
61 >         * @param mol molecule to be added
62 >         */
63 >        bool addMolecule(Molecule* mol);
64  
65 +        /**
66 +         * Removes a molecule from SimInfo
67 +         * @return true if removing successfully, return false if molecule is not in this SimInfo
68 +         */
69 +        bool removeMolecule(Molecule* mol);
70  
71 < double roundMe( double x );
72 < class OOPSEMinimizer;
29 < class SimInfo{
71 >        /** Returns the total number of molecules in the system. */
72 >        int getNGlobalMolecules() {
73  
74 < public:
74 > #ifdef IS_MPI
75 >        int nmols;
76 >        int totNMols;
77  
78 <  SimInfo();
79 <  ~SimInfo();
78 >        nmols = getNMolecules();
79 >        MPI_Allreduce(&nmols, &totNMols, 1, MPI_INT,MPI_SUM, MPI_COMM_WORLD);
80  
81 <  int n_atoms; // the number of atoms
82 <  Atom **atoms; // the array of atom objects
81 >        return totNMols;
82 > #else
83 >            return getNMolecules();
84 > #endif
85 >        }
86  
87 <  vector<RigidBody*> rigidBodies;  // A vector of rigid bodies
88 <  vector<StuntDouble*> integrableObjects;
41 <  
42 <  double tau[9]; // the stress tensor
87 >        /** Returns the total number of atoms in the system. */
88 >        int getNGlobalAtoms() {
89  
90 <  int n_bonds;    // number of bends
91 <  int n_bends;    // number of bends
92 <  int n_torsions; // number of torsions
93 <  int n_oriented; // number of of atoms with orientation
94 <  int ndf;        // number of actual degrees of freedom
95 <  int ndfRaw;     // number of settable degrees of freedom
96 <  int ndfTrans;   // number of translational degrees of freedom
97 <  int nZconstraints; // the number of zConstraints
90 > #ifdef IS_MPI
91 >        int totNAtoms;
92 >        MPI_Allreduce(&nAtoms_, &totNAtoms, 1, MPI_INT,MPI_SUM, MPI_COMM_WORLD);
93 >        return totNAtoms;
94 > #else
95 >            return nAtoms_;
96 > #endif
97 >        }
98  
99 <  int setTemp;   // boolean to set the temperature at each sampleTime
100 <  int resetIntegrator; // boolean to reset the integrator
99 >        /** Returns the total number of cutoff groups in the system. */
100 >        int getNGlobalCutoffGroups() {
101 > #ifdef IS_MPI
102 >        int totNGroups;
103 >        MPI_Allreduce(&nCutoffGroups_, &totNGroups, 1, MPI_INT,MPI_SUM, MPI_COMM_WORLD);
104 >        return totNGroups;
105 > #else
106 >            return nCutoffGroups_;
107 > #endif
108 >        }
109 >        
110 >        /**
111 >         * Returns the number of local molecules.
112 >         * @return the number of local molecules
113 >         */
114 >        int getNMolecules() {
115 >            return molecules_.size();
116 >        }
117  
118 <  int n_dipoles; // number of dipoles
118 >        /** Returns the number of local atoms */
119 >        unsigned int getNAtoms() {
120 >            return nAtoms_;
121 >        }
122  
123 <  int n_exclude;
124 <  Exclude* excludes;  // the exclude list for ignoring pairs in fortran
125 <  int nGlobalExcludes;
126 <  int* globalExcludes; // same as above, but these guys participate in
62 <                       // no long range forces.
123 >        /** Returns the number of local bonds */        
124 >        unsigned int getNBonds(){
125 >            return nBonds_;
126 >        }
127  
128 <  int* identArray;     // array of unique identifiers for the atoms
129 <  int* molMembershipArray;  // map of atom numbers onto molecule numbers
128 >        /** Returns the number of local bends */        
129 >        unsigned int getNBends() {
130 >            return nBends_;
131 >        }
132  
133 <  int n_constraints; // the number of constraints on the system
133 >        /** Returns the number of local torsions */        
134 >        unsigned int getNTorsions() {
135 >            return nTorsions_;
136 >        }
137  
138 <  int n_SRI;   // the number of short range interactions
138 >        /** Returns the number of local rigid bodies */        
139 >        unsigned int getNRigidBodies() {
140 >            return nRigidBodies_;
141 >        }
142  
143 <  double lrPot; // the potential energy from the long range calculations.
143 >        /** Returns the number of local integrable objects */
144 >        unsigned int getNIntegrableObjects() {
145 >            return nIntegrableObjects_;
146 >        }
147  
148 <  double Hmat[3][3];  // the periodic boundry conditions. The Hmat is the
149 <                      // column vectors of the x, y, and z box vectors.
150 <                      //   h1  h2  h3
151 <                      // [ Xx  Yx  Zx ]
77 <                      // [ Xy  Yy  Zy ]
78 <                      // [ Xz  Yz  Zz ]
79 <                      //  
80 <  double HmatInv[3][3];
148 >        /** Returns the number of local cutoff groups */
149 >        unsigned int getNCutoffGroups() {
150 >            return nCutoffGroups_;
151 >        }
152  
153 <  double boxL[3]; // The Lengths of the 3 column vectors of Hmat
154 <  double boxVol;
155 <  int orthoRhombic;
156 <  
153 >        /** Returns the total number of constraints in this SimInfo */
154 >        unsigned int getNConstraints() {
155 >            return nConstraints_;
156 >        }
157 >        
158 >        /**
159 >         * Returns the first molecule in this SimInfo and intialize the iterator.
160 >         * @return the first molecule, return NULL if there is not molecule in this SimInfo
161 >         * @param i the iterator of molecule array (user shouldn't change it)
162 >         */
163 >        Molecule* beginMolecule(MoleculeIterator& i);
164  
165 <  double dielectric;      // the dielectric of the medium for reaction field
165 >        /**
166 >          * Returns the next avaliable Molecule based on the iterator.
167 >          * @return the next avaliable molecule, return NULL if reaching the end of the array
168 >          * @param i the iterator of molecule array
169 >          */
170 >        Molecule* nextMolecule(MoleculeIterator& i);
171  
172 <  
173 <  int usePBC; // whether we use periodic boundry conditions.
174 <  int useDirectionalAtoms;
175 <  int useLennardJones;
93 <  int useElectrostatics;
94 <  int useCharges;
95 <  int useDipoles;
96 <  int useSticky;
97 <  int useGayBerne;
98 <  int useEAM;
99 <  int useShapes;
100 <  int useFLARB;
101 <  int useReactionField;
102 <  bool haveCutoffGroups;
103 <  bool useInitXSstate;
104 <  double orthoTolerance;
172 >        /** Returns the number of degrees of freedom */
173 >        int getNdf() {
174 >            return ndf_;
175 >        }
176  
177 <  double dt, run_time;           // the time step and total time
178 <  double sampleTime, statusTime; // the position and energy dump frequencies
179 <  double target_temp;            // the target temperature of the system
180 <  double thermalTime;            // the temp kick interval
110 <  double currentTime;            // Used primarily for correlation Functions
111 <  double resetTime;              // Use to reset the integrator periodically
112 <  short int have_target_temp;
177 >        /** Returns the number of raw degrees of freedom */
178 >        int getNdfRaw() {
179 >            return ndfRaw_;
180 >        }
181  
182 <  int n_mol;           // n_molecules;
183 <  Molecule* molecules; // the array of molecules
184 <  
185 <  int nComponents;           // the number of components in the system
118 <  int* componentsNmol;       // the number of molecules of each component
119 <  MoleculeStamp** compStamps;// the stamps matching the components
120 <  LinkedMolStamp* headStamp; // list of stamps used in the simulation
121 <  
122 <  
123 <  char ensemble[100]; // the enesemble of the simulation (NVT, NVE, etc. )
124 <  char mixingRule[100]; // the mixing rules for Lennard jones/van der walls
125 <  BaseIntegrator *the_integrator; // the integrator of the simulation
182 >        /** Returns the number of translational degrees of freedom */
183 >        int getNdfTrans() {
184 >            return ndfTrans_;
185 >        }
186  
187 <  OOPSEMinimizer* the_minimizer; // the energy minimizer
188 <  Restraints* restraint;
189 <  bool has_minimizer;
187 >        /** Returns the snapshot manager. */
188 >        SnapshotManager* getSnapshotManager() {
189 >            return sman_;
190 >        }
191  
192 <  string finalName;  // the name of the eor file to be written
193 <  string sampleName; // the name of the dump file to be written
194 <  string statusName; // the name of the stat file to be written
192 >        /** Sets the snapshot manager. */
193 >        void setSnapshotManager(SnapshotManager* sman) {
194 >            sman_ = sman;
195 >        }
196  
197 <  int seed;                    //seed for random number generator
197 >        /** Returns the force field */
198 >        ForceField* getForceField() {
199 >            return forceField_;
200 >        }
201  
202 <  int useSolidThermInt;  // is solid-state thermodynamic integration being used
203 <  int useLiquidThermInt; // is liquid thermodynamic integration being used
204 <  double thermIntLambda; // lambda for TI
205 <  double thermIntK;      // power of lambda for TI
141 <  double vRaw;           // unperturbed potential for TI
142 <  double vHarm;          // harmonic potential for TI
143 <  int i;                 // just an int
202 >        /** Sets the force field */
203 >        void setForceField(ForceField* ff) {
204 >            forceField_ = ff;
205 >        }
206  
207 <  vector<double> mfact;
208 <  vector<int> FglobalGroupMembership;
209 <  int ngroup;
210 <  int* globalGroupMembership;
207 >        Globals* getGlobals() {
208 >            return globals_;
209 >        }
210 >        
211 >        void setGlobals(Globals* globals) {
212 >            globals_ = globals;
213 >        }
214  
215 <  // refreshes the sim if things get changed (load balanceing, volume
216 <  // adjustment, etc.)
215 >        /** Returns the velocity of center of mass of the whole system.*/
216 >        Vector3d getComVel();
217  
218 <  void refreshSim( void );
219 <  
218 >        /** Returns the center of the mass of the whole system.*/
219 >        Vector3d getCom();
220  
221 <  // sets the internal function pointer to fortran.
221 >        /** Returns the seed (used for random number generator) */
222 >        int getSeed() {
223 >            return seed_;
224 >        }
225  
226 +        /** Sets the seed*/
227 +        void setSeed(int seed) {
228 +            seed_ = seed;
229 +        }
230  
231 <  int getNDF();
232 <  int getNDFraw();
161 <  int getNDFtranslational();
162 <  int getTotIntegrableObjects();
163 <  void setBox( double newBox[3] );
164 <  void setBoxM( double newBox[3][3] );
165 <  void getBoxM( double theBox[3][3] );
166 <  void scaleBox( double scale );
167 <  
168 <  void setDefaultRcut( double theRcut );
169 <  void setDefaultRcut( double theRcut, double theRsw );
170 <  void checkCutOffs( void );
231 >        
232 >        void update();
233  
172 –  double getRcut( void )  { return rCut; }
173 –  double getRlist( void ) { return rList; }
174 –  double getRsw( void )   { return rSw; }
175 –  double getMaxCutoff( void ) { return maxCutoff; }
176 –  
177 –  void setTime( double theTime ) { currentTime = theTime; }
178 –  void incrTime( double the_dt ) { currentTime += the_dt; }
179 –  void decrTime( double the_dt ) { currentTime -= the_dt; }
180 –  double getTime( void ) { return currentTime; }
234  
235 <  void wrapVector( double thePos[3] );
235 >        /** Returns the local index manager */
236 >        LocalIndexManager* getLocalIndexManager() {
237 >            return localIndexMan_;
238 >        }
239  
184 –  SimState* getConfiguration( void ) { return myConfiguration; }
185 –  
186 –  void addProperty(GenericData* prop);
187 –  GenericData* getProperty(const string& propName);
188 –  //vector<GenericData*>& getProperties()  {return properties;}    
240  
241 <  int getSeed(void) {  return seed; }
242 <  void setSeed(int theSeed) {  seed = theSeed;}
241 >        /**
242 >         *
243 >         */
244 >        void addMoleculeStamp(MoleculeStamp* molStamp, int nmol);
245  
246 < private:
246 >        int getMoleculeStampId(int globalIndex) {
247 >            //assert(globalIndex < molStampIds_.size())
248 >            return molStampIds_[globalIndex];
249 >        }
250  
251 <  SimState* myConfiguration;
251 >        /** Returns the molecule stamp */
252 >        MoleculeStamp* getMoleculeStamp(int id) {
253 >            return moleculeStamps_[id];
254 >        }
255 >        
256 >        /**
257 >         * Finds the processor where a molecule resides
258 >         * @return the id of the processor which contains the molecule
259 >         * @param globalIndex global Index of the molecule
260 >         */
261 >        int getMolToProc(int globalIndex) {
262 >            //assert(globalIndex < molToProcMap_.size());
263 >            return molToProcMap_[globalIndex];
264 >        }
265  
266 <  int boxIsInit, haveRcut, haveRsw;
266 >        /**
267 >         * Finds a molecule with a specified global index
268 >         * @return a pointer point to found molecule
269 >         * @param index
270 >         */
271 >        Molecule* getMoleculeByGlobalIndex(int index) {
272 >            std::map<int, Molecule*> i;
273 >            i = molecules_.find(index);
274  
275 <  double rList, rCut; // variables for the neighborlist
276 <  double rSw;         // the switching radius
275 >            return i != molecules_.end() ? i->second : NULL;
276 >        }
277  
278 <  double maxCutoff;
278 >        friend std::ostream& operator <<(ostream& o, SimInfo& info);
279 >        
280 >    private:
281  
282 <  double distXY;
283 <  double distYZ;
284 <  double distZX;
207 <  
208 <  void calcHmatInv( void );
209 <  void calcBoxL();
210 <  double calcMaxCutOff();
282 >        void calcNdf();
283 >        void calcNdfRaw();
284 >        void calcNdfTrans();
285  
286 <  
287 <  //Addtional Properties of SimInfo
288 <  map<string, GenericData*> properties;
215 <  void getFortranGroupArrays(SimInfo* info,
216 <                             vector<int>& FglobalGroupMembership,
217 <                             vector<double>& mfact);
286 >        int* getExcludeList() {
287 >            return exclude_.getExcludeList();
288 >        }
289  
290 +        void addExcludePairs(Molecule* mol);
291 +        void removeExcludePairs(Molecule* mol);
292  
293 < };
293 >        //degress of freedom
294 >        int ndf_;           /** number of degress of freedom */
295 >        int ndfRaw_;
296 >        int ndfTrans_; /**< number of translation degress of freedom */
297  
298 +        //number of local objects
299 +        int nAtoms_;
300 +        int nBonds_;
301 +        int nBends_;
302 +        int nTorsions_;
303 +        int nRigidBodies_;
304 +        int nIntegrableObjects_;
305 +        int nCutoffGroups_;
306 +        int nConstraints_;
307  
308 < #endif
308 >        simtype fInfo_;
309 >        Exclude exclude_;
310 >        ForceField* forceField_;
311 >        
312 >       std::map<int, Molecule*>  molecules_; /**< Molecule array */
313 >        PropertyMap properties_;                  /**< Generic Property */
314 >        SnapshotManager* sman_;               /**< SnapshotManager */
315 >
316 >        Globals* globals_;
317 >
318 >        int seed_; /**< seed for random number generator */
319 >
320 >        LocalIndexManager localIndexMan_;
321 >
322 >        //
323 >        std::vector<int> molToProcMap_;
324 >        std::vector<int> molStampIds_;                                /**< stamp id array of all molecules in the system */
325 >        std::vector<MoleculeStamp*> moleculeStamps_; /**< molecule stamps array */      
326 >
327 > };
328 >
329 > } //namespace oopse
330 > #endif //BRAINS_SIMMODEL_HPP

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines