ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/trunk/src/brains/SimInfo.hpp

Comparing trunk/src/brains/SimInfo.hpp (file contents):
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
Revision 1929 by gezelter, Mon Aug 19 13:12:00 2013 UTC

#	Line 35 | Line 35
35		*
36		* [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
37		* [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
38	<	* [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).
39	<	* [4]  Vardeman & Gezelter, in progress (2009).
38	>	* [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).
39	>	* [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40	>	* [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41		*/
42
43		/**
#	Line 59 | Line 60
60		#include "math/Vector3.hpp"
61		#include "math/SquareMatrix3.hpp"
62		#include "types/MoleculeStamp.hpp"
63	<	#include "UseTheForce/ForceField.hpp"
63	>	#include "brains/ForceField.hpp"
64		#include "utils/PropertyMap.hpp"
65		#include "utils/LocalIndexManager.hpp"
66	+	#include "nonbonded/SwitchingFunction.hpp"
67
68	<	//another nonsense macro declaration
67	<	#define __OPENMD_C
68	<	#include "brains/fSimulation.h"
69	<
68	>	using namespace std;
69		namespace OpenMD{
70	<
72	<	//forward decalration
70	>	//forward declaration
71		class SnapshotManager;
72		class Molecule;
73		class SelectionManager;
74		class StuntDouble;
75	+
76		/**
77	<	* @class SimInfo SimInfo.hpp "brains/SimInfo.hpp"
78	<	* @brief One of the heavy weight classes of OpenMD, SimInfo maintains a list of molecules.
79	<	* The Molecule class maintains all of the concrete objects
80	<	* (atoms, bond, bend, torsions, inversions, rigid bodies, cutoff groups,
81	<	* constraints). In both the single and parallel versions, atoms and
82	<	* rigid bodies have both global and local indices.  The local index is
83	<	* not relevant to molecules or cutoff groups.
84	<	*/
77	>	* @class SimInfo SimInfo.hpp "brains/SimInfo.hpp"
78	>	*
79	>	* @brief One of the heavy-weight classes of OpenMD, SimInfo
80	>	* maintains objects and variables relating to the current
81	>	* simulation.  This includes the master list of Molecules.  The
82	>	* Molecule class maintains all of the concrete objects (Atoms,
83	>	* Bond, Bend, Torsions, Inversions, RigidBodies, CutoffGroups,
84	>	* Constraints). In both the single and parallel versions, Atoms and
85	>	* RigidBodies have both global and local indices.
86	>	*/
87		class SimInfo {
88		public:
89	<	typedef std::map<int, Molecule*>::iterator  MoleculeIterator;
90	<
89	>	typedef map<int, Molecule*>::iterator  MoleculeIterator;
90	>
91		/**
92		* Constructor of SimInfo
93	<	* @param molStampPairs MoleculeStamp Array. The first element of the pair is molecule stamp, the
94	<	* second element is the total number of molecules with the same molecule stamp in the system
95	<	* @param ff pointer of a concrete ForceField instance
96	<	* @param simParams
96	<	* @note
93	>	*
94	>	* @param ff pointer to a concrete ForceField instance
95	>	*
96	>	* @param simParams pointer to the simulation parameters in a Globals object
97		*/
98		SimInfo(ForceField* ff, Globals* simParams);
99		virtual ~SimInfo();
100
101		/**
102		* Adds a molecule
103	<	* @return return true if adding successfully, return false if the molecule is already in SimInfo
104	<	* @param mol molecule to be added
103	>	*
104	>	* @return return true if adding successfully, return false if the
105	>	* molecule is already in SimInfo
106	>	*
107	>	* @param mol Molecule to be added
108		*/
109		bool addMolecule(Molecule* mol);
110
111		/**
112		* Removes a molecule from SimInfo
113	<	* @return true if removing successfully, return false if molecule is not in this SimInfo
113	>	*
114	>	* @return true if removing successfully, return false if molecule
115	>	* is not in this SimInfo
116		*/
117		bool removeMolecule(Molecule* mol);
118
#	Line 127 | Line 132 | namespace OpenMD{
132		}
133
134		/**
135	<	* Returns the total number of integrable objects (total number of rigid bodies plus the total number
136	<	* of atoms which do not belong to the rigid bodies) in the system
135	>	* Returns the total number of integrable objects (total number of
136	>	* rigid bodies plus the total number of atoms which do not belong
137	>	* to the rigid bodies) in the system
138		*/
139		int getNGlobalIntegrableObjects() {
140		return nGlobalIntegrableObjects_;
141		}
142
143		/**
144	<	* Returns the total number of integrable objects (total number of rigid bodies plus the total number
145	<	* of atoms which do not belong to the rigid bodies) in the system
144	>	* Returns the total number of integrable objects (total number of
145	>	* rigid bodies plus the total number of atoms which do not belong
146	>	* to the rigid bodies) in the system
147		*/
148		int getNGlobalRigidBodies() {
149		return nGlobalRigidBodies_;
#	Line 156 | Line 163 | namespace OpenMD{
163		return nAtoms_;
164		}
165
166	+	/** Returns the number of effective cutoff groups on local processor */
167	+	unsigned int getNLocalCutoffGroups();
168	+
169		/** Returns the number of local bonds */
170		unsigned int getNBonds(){
171		return nBonds_;
#	Line 209 | Line 219 | namespace OpenMD{
219		*/
220		Molecule* nextMolecule(MoleculeIterator& i);
221
222	+	/** Returns the total number of fluctuating charges that are present */
223	+	int getNFluctuatingCharges() {
224	+	return nGlobalFluctuatingCharges_;
225	+	}
226	+
227		/** Returns the number of degrees of freedom */
228		int getNdf() {
229		return ndf_ - getFdf();
230		}
231
232	+	/** Returns the number of degrees of freedom (LOCAL) */
233	+	int getNdfLocal() {
234	+	return ndfLocal_;
235	+	}
236	+
237		/** Returns the number of raw degrees of freedom */
238		int getNdfRaw() {
239		return ndfRaw_;
#	Line 231 | Line 251 | namespace OpenMD{
251
252		int getFdf();
253
254	<	//getNZconstraint and setNZconstraint ruin the coherent of SimInfo class, need refactorying
254	>	//getNZconstraint and setNZconstraint ruin the coherence of
255	>	//SimInfo class, need refactoring
256
257		/** Returns the total number of z-constraint molecules in the system */
258		int getNZconstraint() {
#	Line 249 | Line 270 | namespace OpenMD{
270		SnapshotManager* getSnapshotManager() {
271		return sman_;
272		}
273	<
273	>	/** Returns the storage layout (computed by SimCreator) */
274	>	int getStorageLayout() {
275	>	return storageLayout_;
276	>	}
277	>	/** Sets the storage layout (computed by SimCreator) */
278	>	void setStorageLayout(int sl) {
279	>	storageLayout_ = sl;
280	>	}
281	>
282		/** Sets the snapshot manager. */
283		void setSnapshotManager(SnapshotManager* sman);
284
#	Line 262 | Line 291 | namespace OpenMD{
291		return simParams_;
292		}
293
265	–	/** Returns the velocity of center of mass of the whole system.*/
266	–	Vector3d getComVel();
267	–
268	–	/** Returns the center of the mass of the whole system.*/
269	–	Vector3d getCom();
270	–	/** Returns the center of the mass and Center of Mass velocity of the whole system.*/
271	–	void getComAll(Vector3d& com,Vector3d& comVel);
272	–
273	–	/** Returns intertia tensor for the entire system and system Angular Momentum.*/
274	–	void getInertiaTensor(Mat3x3d &intertiaTensor,Vector3d &angularMomentum);
275	–
276	–	/** Returns system angular momentum */
277	–	Vector3d getAngularMomentum();
278	–
279	–	/** Returns volume of system as estimated by an ellipsoid defined by the radii of gyration*/
280	–	void getGyrationalVolume(RealType &vol);
281	–	/** Overloaded version of gyrational volume that also returns det(I) so dV/dr can be calculated*/
282	–	void getGyrationalVolume(RealType &vol, RealType &detI);
283	–	/** main driver function to interact with fortran during the initialization and molecule migration */
294		void update();
295	+	/**
296	+	* Do final bookkeeping before Force managers need their data.
297	+	*/
298	+	void prepareTopology();
299
300	+
301		/** Returns the local index manager */
302		LocalIndexManager* getLocalIndexManager() {
303		return &localIndexMan_;
#	Line 318 | Line 333 | namespace OpenMD{
333		return globalMolMembership_[id];
334		}
335
336	<	RealType getRcut() {
337	<	return rcut_;
338	<	}
336	>	/**
337	>	* returns a vector which maps the local atom index on this
338	>	* processor to the global atom index.  With only one processor,
339	>	* these should be identical.
340	>	*/
341	>	vector<int> getGlobalAtomIndices();
342
343	<	RealType getRsw() {
344	<	return rsw_;
345	<	}
343	>	/**
344	>	* returns a vector which maps the local cutoff group index on
345	>	* this processor to the global cutoff group index.  With only one
346	>	* processor, these should be identical.
347	>	*/
348	>	vector<int> getGlobalGroupIndices();
349
329	–	RealType getList() {
330	–	return rlist_;
331	–	}
350
351	<	std::string getFinalConfigFileName() {
351	>	string getFinalConfigFileName() {
352		return finalConfigFileName_;
353		}
354
355	<	void setFinalConfigFileName(const std::string& fileName) {
355	>	void setFinalConfigFileName(const string& fileName) {
356		finalConfigFileName_ = fileName;
357		}
358
359	<	std::string getRawMetaData() {
359	>	string getRawMetaData() {
360		return rawMetaData_;
361		}
362	<	void setRawMetaData(const std::string& rawMetaData) {
362	>	void setRawMetaData(const string& rawMetaData) {
363		rawMetaData_ = rawMetaData;
364		}
365
366	<	std::string getDumpFileName() {
366	>	string getDumpFileName() {
367		return dumpFileName_;
368		}
369
370	<	void setDumpFileName(const std::string& fileName) {
370	>	void setDumpFileName(const string& fileName) {
371		dumpFileName_ = fileName;
372		}
373
374	<	std::string getStatFileName() {
374	>	string getStatFileName() {
375		return statFileName_;
376		}
377
378	<	void setStatFileName(const std::string& fileName) {
378	>	void setStatFileName(const string& fileName) {
379		statFileName_ = fileName;
380		}
381
382	<	std::string getRestFileName() {
382	>	string getRestFileName() {
383		return restFileName_;
384		}
385
386	<	void setRestFileName(const std::string& fileName) {
386	>	void setRestFileName(const string& fileName) {
387		restFileName_ = fileName;
388		}
389
390		/**
391		* Sets GlobalGroupMembership
374	–	* @see #SimCreator::setGlobalIndex
392		*/
393	<	void setGlobalGroupMembership(const std::vector<int>& globalGroupMembership) {
394	<	assert(globalGroupMembership.size() == static_cast<size_t>(nGlobalAtoms_));
395	<	globalGroupMembership_ = globalGroupMembership;
393	>	void setGlobalGroupMembership(const vector<int>& ggm) {
394	>	assert(ggm.size() == static_cast<size_t>(nGlobalAtoms_));
395	>	globalGroupMembership_ = ggm;
396		}
397
398		/**
399		* Sets GlobalMolMembership
383	–	* @see #SimCreator::setGlobalIndex
400		*/
401	<	void setGlobalMolMembership(const std::vector<int>& globalMolMembership) {
402	<	assert(globalMolMembership.size() == static_cast<size_t>(nGlobalAtoms_));
403	<	globalMolMembership_ = globalMolMembership;
401	>	void setGlobalMolMembership(const vector<int>& gmm) {
402	>	assert(gmm.size() == (static_cast<size_t>(nGlobalAtoms_ +
403	>	nGlobalRigidBodies_)));
404	>	globalMolMembership_ = gmm;
405		}
406
407
408	<	bool isFortranInitialized() {
409	<	return fortranInitialized_;
408	>	bool isTopologyDone() {
409	>	return topologyDone_;
410		}
411
412		bool getCalcBoxDipole() {
#	Line 400 | Line 417 | namespace OpenMD{
417		return useAtomicVirial_;
418		}
419
403	–	//below functions are just forward functions
404	–	//To compose or to inherit is always a hot debate. In general, is-a relation need subclassing, in the
405	–	//the other hand, has-a relation need composing.
420		/**
421		* Adds property into property map
422		* @param genData GenericData to be added into PropertyMap
#	Line 413 | Line 427 | namespace OpenMD{
427		* Removes property from PropertyMap by name
428		* @param propName the name of property to be removed
429		*/
430	<	void removeProperty(const std::string& propName);
430	>	void removeProperty(const string& propName);
431
432		/**
433		* clear all of the properties
#	Line 424 | Line 438 | namespace OpenMD{
438		* Returns all names of properties
439		* @return all names of properties
440		*/
441	<	std::vector<std::string> getPropertyNames();
441	>	vector<string> getPropertyNames();
442
443		/**
444		* Returns all of the properties in PropertyMap
445		* @return all of the properties in PropertyMap
446		*/
447	<	std::vector<GenericData*> getProperties();
447	>	vector<GenericData*> getProperties();
448
449		/**
450		* Returns property
#	Line 438 | Line 452 | namespace OpenMD{
452		* @return a pointer point to property with propName. If no property named propName
453		* exists, return NULL
454		*/
455	<	GenericData* getPropertyByName(const std::string& propName);
455	>	GenericData* getPropertyByName(const string& propName);
456
457		/**
458		* add all special interaction pairs (including excluded
#	Line 452 | Line 466 | namespace OpenMD{
466		*/
467		void removeInteractionPairs(Molecule* mol);
468
469	+	/** Returns the set of atom types present in this simulation */
470	+	set<AtomType*> getSimulatedAtomTypes();
471
472	<	/** Returns the unique atom types of local processor in an array */
473	<	std::set<AtomType*> getUniqueAtomTypes();
472	>	/** Returns the global count of atoms of a particular type */
473	>	int getGlobalCountOfType(AtomType* atype);
474
475	<	friend std::ostream& operator <<(std::ostream& o, SimInfo& info);
475	>	friend ostream& operator <<(ostream& o, SimInfo& info);
476
477		void getCutoff(RealType& rcut, RealType& rsw);
478
479		private:
480
481	<	/** fill up the simtype struct*/
482	<	void setupSimType();
481	>	/** fill up the simtype struct and other simulation-related variables */
482	>	void setupSimVariables();
483
468	–	/**
469	–	* Setup Fortran Simulation
470	–	* @see #setupFortranParallel
471	–	*/
472	–	void setupFortranSim();
484
474	–	/** Figure out the radius of cutoff, radius of switching function and pass them to fortran */
475	–	void setupCutoff();
476	–
477	–	/** Figure out which coulombic correction method to use and pass to fortran */
478	–	void setupElectrostaticSummationMethod( int isError );
479	–
480	–	/** Figure out which polynomial type to use for the switching function */
481	–	void setupSwitchingFunction();
482	–
485		/** Determine if we need to accumulate the simulation box dipole */
486		void setupAccumulateBoxDipole();
487
#	Line 488 | Line 490 | namespace OpenMD{
490		void calcNdfRaw();
491		void calcNdfTrans();
492
491	–	ForceField* forceField_;
492	–	Globals* simParams_;
493	–
494	–	std::map<int, Molecule*>  molecules_; /**< Molecule array */
495	–
493		/**
494	<	* Adds molecule stamp and the total number of the molecule with same molecule stamp in the whole
495	<	* system.
494	>	* Adds molecule stamp and the total number of the molecule with
495	>	* same molecule stamp in the whole system.
496		*/
497		void addMoleculeStamp(MoleculeStamp* molStamp, int nmol);
498	<
499	<	//degress of freedom
500	<	int ndf_;           /**< number of degress of freedom (excludes constraints),  ndf_ is local */
501	<	int fdf_local;       /**< number of frozen degrees of freedom */
505	<	int fdf_;            /**< number of frozen degrees of freedom */
506	<	int ndfRaw_;    /**< number of degress of freedom (includes constraints),  ndfRaw_ is local */
507	<	int ndfTrans_; /**< number of translation degress of freedom, ndfTrans_ is local */
508	<	int nZconstraint_; /** number of  z-constraint molecules, nZconstraint_ is global */
509	<
510	<	//number of global objects
511	<	int nGlobalMols_;       /**< number of molecules in the system */
512	<	int nGlobalAtoms_;   /**< number of atoms in the system */
513	<	int nGlobalCutoffGroups_; /**< number of cutoff groups in this system */
514	<	int nGlobalIntegrableObjects_; /**< number of integrable objects in this system */
515	<	int nGlobalRigidBodies_; /**< number of rigid bodies in this system */
516	<	/**
517	<	* the size of globalGroupMembership_  is nGlobalAtoms. Its index is  global index of an atom, and the
518	<	* corresponding content is the global index of cutoff group this atom belong to.
519	<	* It is filled by SimCreator once and only once, since it never changed during the simulation.
520	<	*/
521	<	std::vector<int> globalGroupMembership_;
498	>
499	>	// Other classes holdingn important information
500	>	ForceField* forceField_; /**< provides access to defined atom types, bond types, etc. */
501	>	Globals* simParams_;     /**< provides access to simulation parameters set by user */
502
503	<	/**
524	<	* the size of globalMolMembership_  is nGlobalAtoms. Its index is  global index of an atom, and the
525	<	* corresponding content is the global index of molecule this atom belong to.
526	<	* It is filled by SimCreator once and only once, since it is never changed during the simulation.
527	<	*/
528	<	std::vector<int> globalMolMembership_;
529	<
530	<
531	<	std::vector<int> molStampIds_;                                /**< stamp id array of all molecules in the system */
532	<	std::vector<MoleculeStamp*> moleculeStamps_;      /**< molecule stamps array */
533	<
534	<	//number of local objects
503	>	///  Counts of local objects
504		int nAtoms_;              /**< number of atoms in local processor */
505		int nBonds_;              /**< number of bonds in local processor */
506		int nBends_;              /**< number of bends in local processor */
#	Line 541 | Line 510 | namespace OpenMD{
510		int nIntegrableObjects_;  /**< number of integrable objects in local processor */
511		int nCutoffGroups_;       /**< number of cutoff groups in local processor */
512		int nConstraints_;        /**< number of constraints in local processors */
513	+	int nFluctuatingCharges_; /**< number of fluctuating charges in local processor */
514	+
515	+	/// Counts of global objects
516	+	int nGlobalMols_;              /**< number of molecules in the system (GLOBAL) */
517	+	int nGlobalAtoms_;             /**< number of atoms in the system (GLOBAL) */
518	+	int nGlobalCutoffGroups_;      /**< number of cutoff groups in this system (GLOBAL) */
519	+	int nGlobalIntegrableObjects_; /**< number of integrable objects in this system */
520	+	int nGlobalRigidBodies_;       /**< number of rigid bodies in this system (GLOBAL) */
521	+	int nGlobalFluctuatingCharges_;/**< number of fluctuating charges in this system (GLOBAL) */
522	+
523	+
524	+	/// Degress of freedom
525	+	int ndf_;          /**< number of degress of freedom (excludes constraints) (LOCAL) */
526	+	int ndfLocal_;     /**< number of degrees of freedom (LOCAL, excludes constraints) */
527	+	int fdf_local;     /**< number of frozen degrees of freedom (LOCAL) */
528	+	int fdf_;          /**< number of frozen degrees of freedom (GLOBAL) */
529	+	int ndfRaw_;       /**< number of degress of freedom (includes constraints),  (LOCAL) */
530	+	int ndfTrans_;     /**< number of translation degress of freedom, (LOCAL) */
531	+	int nZconstraint_; /**< number of  z-constraint molecules (GLOBAL) */
532
533	<	simtype fInfo_; /**< A dual struct shared by c++/fortran which indicates the atom types in simulation*/
534	<	PairList excludedInteractions_;
535	<	PairList oneTwoInteractions_;
536	<	PairList oneThreeInteractions_;
537	<	PairList oneFourInteractions_;
538	<	PropertyMap properties_;                  /**< Generic Property */
539	<	SnapshotManager* sman_;               /**< SnapshotManager */
533	>	/// logicals
534	>	bool usesPeriodicBoundaries_; /**< use periodic boundary conditions? */
535	>	bool usesDirectionalAtoms_;   /**< are there atoms with position AND orientation? */
536	>	bool usesMetallicAtoms_;      /**< are there transition metal atoms? */
537	>	bool usesElectrostaticAtoms_; /**< are there electrostatic atoms? */
538	>	bool usesFluctuatingCharges_; /**< are there fluctuating charges? */
539	>	bool usesAtomicVirial_;       /**< are we computing atomic virials? */
540	>	bool requiresPrepair_;        /**< does this simulation require a pre-pair loop? */
541	>	bool requiresSkipCorrection_; /**< does this simulation require a skip-correction? */
542	>	bool requiresSelfCorrection_; /**< does this simulation require a self-correction? */
543
544	+	public:
545	+	bool usesElectrostaticAtoms() { return usesElectrostaticAtoms_; }
546	+	bool usesDirectionalAtoms() { return usesDirectionalAtoms_; }
547	+	bool usesFluctuatingCharges() { return usesFluctuatingCharges_; }
548	+	bool usesAtomicVirial() { return usesAtomicVirial_; }
549	+	bool requiresPrepair() { return requiresPrepair_; }
550	+	bool requiresSkipCorrection() { return requiresSkipCorrection_;}
551	+	bool requiresSelfCorrection() { return requiresSelfCorrection_;}
552	+
553	+	private:
554	+	/// Data structures holding primary simulation objects
555	+	map<int, Molecule*>  molecules_;  /**< map holding pointers to LOCAL molecules */
556	+
557	+	/// Stamps are templates for objects that are then used to create
558	+	/// groups of objects.  For example, a molecule stamp contains
559	+	/// information on how to build that molecule (i.e. the topology,
560	+	/// the atoms, the bonds, etc.)  Once the system is built, the
561	+	/// stamps are no longer useful.
562	+	vector<int> molStampIds_;                /**< stamp id for molecules in the system */
563	+	vector<MoleculeStamp*> moleculeStamps_;  /**< molecule stamps array */
564	+
565	+	/**
566	+	* A vector that maps between the global index of an atom, and the
567	+	* global index of cutoff group the atom belong to.  It is filled
568	+	* by SimCreator once and only once, since it never changed during
569	+	* the simulation.  It should be nGlobalAtoms_ in size.
570	+	*/
571	+	vector<int> globalGroupMembership_;
572	+	public:
573	+	vector<int> getGlobalGroupMembership() { return globalGroupMembership_; }
574	+	private:
575	+
576	+	/**
577	+	* A vector that maps between the global index of an atom and the
578	+	* global index of the molecule the atom belongs to.  It is filled
579	+	* by SimCreator once and only once, since it is never changed
580	+	* during the simulation. It shoudl be nGlobalAtoms_ in size.
581	+	*/
582	+	vector<int> globalMolMembership_;
583	+
584		/**
585	<	* The reason to have a local index manager is that when molecule is migrating to other processors,
586	<	* the atoms and the rigid-bodies will release their local indices to LocalIndexManager. Combining the
587	<	* information of molecule migrating to current processor, Migrator class can query  the LocalIndexManager
588	<	* to make a efficient data moving plan.
585	>	* A vector that maps between the local index of an atom and the
586	>	* index of the AtomType.
587	>	*/
588	>	vector<int> identArray_;
589	>	public:
590	>	vector<int> getIdentArray() { return identArray_; }
591	>
592	>	/**
593	>	* A vector that contains information about the local region of an
594	>	* atom (used for fluctuating charges, etc.)
595	>	*/
596	>	private:
597	>	vector<int> regions_;
598	>	public:
599	>	vector<int> getRegions() { return regions_; }
600	>	private:
601	>	/**
602	>	* A vector which contains the fractional contribution of an
603	>	* atom's mass to the total mass of the cutoffGroup that atom
604	>	* belongs to.  In the case of single atom cutoff groups, the mass
605	>	* factor for that atom is 1.  For massless atoms, the factor is
606	>	* also 1.
607	>	*/
608	>	vector<RealType> massFactors_;
609	>	public:
610	>	vector<RealType> getMassFactors() { return massFactors_; }
611	>
612	>	PairList* getExcludedInteractions() { return &excludedInteractions_; }
613	>	PairList* getOneTwoInteractions() { return &oneTwoInteractions_; }
614	>	PairList* getOneThreeInteractions() { return &oneThreeInteractions_; }
615	>	PairList* getOneFourInteractions() { return &oneFourInteractions_; }
616	>
617	>	private:
618	>
619	>	/// lists to handle atoms needing special treatment in the non-bonded interactions
620	>	PairList excludedInteractions_;  /**< atoms excluded from interacting with each other */
621	>	PairList oneTwoInteractions_;    /**< atoms that are directly Bonded */
622	>	PairList oneThreeInteractions_;  /**< atoms sharing a Bend */
623	>	PairList oneFourInteractions_;   /**< atoms sharing a Torsion */
624	>
625	>	PropertyMap properties_;       /**< Generic Properties can be added */
626	>	SnapshotManager* sman_;        /**< SnapshotManager (handles particle positions, etc.) */
627	>	int storageLayout_;            /**< Bits to tell how much data to store on each object */
628	>
629	>	/**
630	>	* The reason to have a local index manager is that when molecule
631	>	* is migrating to other processors, the atoms and the
632	>	* rigid-bodies will release their local indices to
633	>	* LocalIndexManager. Combining the information of molecule
634	>	* migrating to current processor, Migrator class can query the
635	>	* LocalIndexManager to make a efficient data moving plan.
636		*/
637		LocalIndexManager localIndexMan_;
638
639		// unparsed MetaData block for storing in Dump and EOR files:
640	<	std::string rawMetaData_;
640	>	string rawMetaData_;
641
642	<	//file names
643	<	std::string finalConfigFileName_;
644	<	std::string dumpFileName_;
645	<	std::string statFileName_;
646	<	std::string restFileName_;
569	<
570	<	RealType rcut_;       /**< cutoff radius*/
571	<	RealType rsw_;        /**< radius of switching function*/
572	<	RealType rlist_;      /**< neighbor list radius */
642	>	// file names
643	>	string finalConfigFileName_;
644	>	string dumpFileName_;
645	>	string statFileName_;
646	>	string restFileName_;
647
648	<	int ljsp_; /**< use shifted potential for LJ*/
649	<	int ljsf_; /**< use shifted force for LJ*/
650	<
577	<	bool fortranInitialized_; /**< flag indicate whether fortran side
578	<	is initialized */
648	>	bool topologyDone_;  /** flag to indicate whether the topology has
649	>	been scanned and all the relevant
650	>	bookkeeping has been done*/
651
652		bool calcBoxDipole_; /**< flag to indicate whether or not we calculate
653		the simulation box dipole moment */
654
655		bool useAtomicVirial_; /**< flag to indicate whether or not we use
656		Atomic Virials to calculate the pressure */
657	<
658	<	public:
587	<	/**
588	<	* return an integral objects by its global index. In MPI version, if the StuntDouble with specified
589	<	* global index does not belong to local processor, a NULL will be return.
590	<	*/
591	<	StuntDouble* getIOIndexToIntegrableObject(int index);
592	<	void setIOIndexToIntegrableObject(const std::vector<StuntDouble*>& v);
593	<	private:
594	<	std::vector<StuntDouble*> IOIndexToIntegrableObject;
595	<	//public:
596	<	//void setStuntDoubleFromGlobalIndex(std::vector<StuntDouble*> v);
657	>
658	>	public:
659		/**
660	<	* return a StuntDouble by its global index. In MPI version, if the StuntDouble with specified
661	<	* global index does not belong to local processor, a NULL will be return.
662	<	*/
663	<	//StuntDouble* getStuntDoubleFromGlobalIndex(int index);
664	<	//private:
665	<	//std::vector<StuntDouble*> sdByGlobalIndex_;
660	>	* return an integral objects by its global index. In MPI
661	>	* version, if the StuntDouble with specified global index does
662	>	* not belong to local processor, a NULL will be return.
663	>	*/
664	>	StuntDouble* getIOIndexToIntegrableObject(int index);
665	>	void setIOIndexToIntegrableObject(const vector<StuntDouble*>& v);
666
667	<	//in Parallel version, we need MolToProc
667	>	private:
668	>	vector<StuntDouble*> IOIndexToIntegrableObject;
669	>
670		public:
671
672		/**
#	Line 614 | Line 678 | namespace OpenMD{
678		//assert(globalIndex < molToProcMap_.size());
679		return molToProcMap_[globalIndex];
680		}
681	<
681	>
682		/**
683		* Set MolToProcMap array
620	–	* @see #SimCreator::divideMolecules
684		*/
685	<	void setMolToProcMap(const std::vector<int>& molToProcMap) {
685	>	void setMolToProcMap(const vector<int>& molToProcMap) {
686		molToProcMap_ = molToProcMap;
687		}
688
689		private:
627	–
628	–	void setupFortranParallel();
690
691		/**
692		* The size of molToProcMap_ is equal to total number of molecules
693		* in the system.  It maps a molecule to the processor on which it
694		* resides. it is filled by SimCreator once and only once.
695		*/
696	<	std::vector<int> molToProcMap_;
696	>	vector<int> molToProcMap_;
697
637	–
698		};
699
700		} //namespace OpenMD

Comparing trunk/src/brains/SimInfo.hpp (property svn:keywords):
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
Revision 1929 by gezelter, Mon Aug 19 13:12:00 2013 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

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