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 598 by chrisfen, Thu Sep 15 00:14:35 2005 UTC vs.
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

#	Line 6 | Line 6
6		* redistribute this software in source and binary code form, provided
7		* that the following conditions are met:
8		*
9	<	* 1. Acknowledgement of the program authors must be made in any
10	<	*    publication of scientific results based in part on use of the
11	<	*    program.  An acceptable form of acknowledgement is citation of
12	<	*    the article in which the program was described (Matthew
13	<	*    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14	<	*    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15	<	*    Parallel Simulation Engine for Molecular Dynamics,"
16	<	*    J. Comput. Chem. 26, pp. 252-271 (2005))
17	<	*
18	<	* 2. Redistributions of source code must retain the above copyright
9	>	* 1. Redistributions of source code must retain the above copyright
10		*    notice, this list of conditions and the following disclaimer.
11		*
12	<	* 3. Redistributions in binary form must reproduce the above copyright
12	>	* 2. Redistributions in binary form must reproduce the above copyright
13		*    notice, this list of conditions and the following disclaimer in the
14		*    documentation and/or other materials provided with the
15		*    distribution.
#	Line 37 | Line 28
28		* arising out of the use of or inability to use software, even if the
29		* University of Notre Dame has been advised of the possibility of
30		* such damages.
31	+	*
32	+	* SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33	+	* research, please cite the appropriate papers when you publish your
34	+	* work.  Good starting points are:
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).
40		*/
41
42		/**
#	Line 54 | Line 54
54		#include <utility>
55		#include <vector>
56
57	<	#include "brains/Exclude.hpp"
57	>	#include "brains/PairList.hpp"
58		#include "io/Globals.hpp"
59		#include "math/Vector3.hpp"
60		#include "math/SquareMatrix3.hpp"
#	Line 64 | Line 64
64		#include "utils/LocalIndexManager.hpp"
65
66		//another nonsense macro declaration
67	<	#define __C
67	>	#define __OPENMD_C
68		#include "brains/fSimulation.h"
69
70	<	namespace oopse{
70	>	namespace OpenMD{
71
72		//forward decalration
73		class SnapshotManager;
74		class Molecule;
75		class SelectionManager;
76	+	class StuntDouble;
77		/**
78		* @class SimInfo SimInfo.hpp "brains/SimInfo.hpp"
79	<	* @brief As one of the heavy weight class of OOPSE, SimInfo
80	<	* One of the major changes in SimInfo class is the data struct. It only maintains a list of molecules.
81	<	* And the Molecule class will maintain all of the concrete objects (atoms, bond, bend, torsions, rigid bodies,
82	<	* cutoff groups, constrains).
83	<	* Another major change is the index. No matter single version or parallel version,  atoms and
84	<	* rigid bodies have both global index and local index. Local index is not important to molecule as well as
85	<	* cutoff group.
85	<	*/
79	>	* @brief One of the heavy weight classes of OpenMD, SimInfo maintains a list of molecules.
80	>	* The Molecule class maintains all of the concrete objects
81	>	* (atoms, bond, bend, torsions, inversions, rigid bodies, cutoff groups,
82	>	* constraints). In both the single and parallel versions, atoms and
83	>	* rigid bodies have both global and local indices.  The local index is
84	>	* not relevant to molecules or cutoff groups.
85	>	*/
86		class SimInfo {
87		public:
88		typedef std::map<int, Molecule*>::iterator  MoleculeIterator;
#	Line 95 | Line 95 | namespace oopse{
95		* @param simParams
96		* @note
97		*/
98	<	SimInfo(MakeStamps* stamps, std::vector<std::pair<MoleculeStamp*, int> >& molStampPairs, ForceField* ff, Globals* simParams);
98	>	SimInfo(ForceField* ff, Globals* simParams);
99		virtual ~SimInfo();
100
101		/**
#	Line 171 | Line 171 | namespace oopse{
171		return nTorsions_;
172		}
173
174	+	/** Returns the number of local torsions */
175	+	unsigned int getNInversions() {
176	+	return nInversions_;
177	+	}
178		/** Returns the number of local rigid bodies */
179		unsigned int getNRigidBodies() {
180		return nRigidBodies_;
#	Line 207 | Line 211 | namespace oopse{
211
212		/** Returns the number of degrees of freedom */
213		int getNdf() {
214	<	return ndf_;
214	>	return ndf_ - getFdf();
215		}
216
217		/** Returns the number of raw degrees of freedom */
#	Line 218 | Line 222 | namespace oopse{
222		/** Returns the number of translational degrees of freedom */
223		int getNdfTrans() {
224		return ndfTrans_;
225	+	}
226	+
227	+	/** sets the current number of frozen degrees of freedom */
228	+	void setFdf(int fdf) {
229	+	fdf_local = fdf;
230		}
231
232	+	int getFdf();
233	+
234		//getNZconstraint and setNZconstraint ruin the coherent of SimInfo class, need refactorying
235
236		/** Returns the total number of z-constraint molecules in the system */
#	Line 265 | Line 276 | namespace oopse{
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 */
284		void update();
285
#	Line 299 | Line 314 | namespace oopse{
314		return i != molecules_.end() ? i->second : NULL;
315		}
316
317	<	/** Calculate the maximum cutoff radius based on the atom types */
318	<	double calcMaxCutoffRadius();
317	>	int getGlobalMolMembership(int id){
318	>	return globalMolMembership_[id];
319	>	}
320
321	<	double getRcut() {
321	>	RealType getRcut() {
322		return rcut_;
323		}
324
325	<	double getRsw() {
325	>	RealType getRsw() {
326		return rsw_;
327		}
328	+
329	+	RealType getList() {
330	+	return rlist_;
331	+	}
332
333		std::string getFinalConfigFileName() {
334		return finalConfigFileName_;
335		}
336	<
336	>
337		void setFinalConfigFileName(const std::string& fileName) {
338		finalConfigFileName_ = fileName;
339		}
340
341	+	std::string getRawMetaData() {
342	+	return rawMetaData_;
343	+	}
344	+	void setRawMetaData(const std::string& rawMetaData) {
345	+	rawMetaData_ = rawMetaData;
346	+	}
347	+
348		std::string getDumpFileName() {
349		return dumpFileName_;
350		}
#	Line 347 | Line 374 | namespace oopse{
374		* @see #SimCreator::setGlobalIndex
375		*/
376		void setGlobalGroupMembership(const std::vector<int>& globalGroupMembership) {
377	<	assert(globalGroupMembership.size() == nGlobalAtoms_);
377	>	assert(globalGroupMembership.size() == static_cast<size_t>(nGlobalAtoms_));
378		globalGroupMembership_ = globalGroupMembership;
379		}
380
#	Line 356 | Line 383 | namespace oopse{
383		* @see #SimCreator::setGlobalIndex
384		*/
385		void setGlobalMolMembership(const std::vector<int>& globalMolMembership) {
386	<	assert(globalMolMembership.size() == nGlobalAtoms_);
386	>	assert(globalMolMembership.size() == static_cast<size_t>(nGlobalAtoms_));
387		globalMolMembership_ = globalMolMembership;
388		}
389
#	Line 365 | Line 392 | namespace oopse{
392		return fortranInitialized_;
393		}
394
395	+	bool getCalcBoxDipole() {
396	+	return calcBoxDipole_;
397	+	}
398	+
399	+	bool getUseAtomicVirial() {
400	+	return useAtomicVirial_;
401	+	}
402	+
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.
#	Line 406 | Line 441 | namespace oopse{
441		GenericData* getPropertyByName(const std::string& propName);
442
443		/**
444	<	* add all exclude pairs of a molecule into exclude list.
444	>	* add all special interaction pairs (including excluded
445	>	* interactions) in a molecule into the appropriate lists.
446		*/
447	<	void addExcludePairs(Molecule* mol);
447	>	void addInteractionPairs(Molecule* mol);
448
449		/**
450	<	* remove all exclude pairs which belong to a molecule from exclude list
450	>	* remove all special interaction pairs which belong to a molecule
451	>	* from the appropriate lists.
452		*/
453	+	void removeInteractionPairs(Molecule* mol);
454
417	–	void removeExcludePairs(Molecule* mol);
455
419	–
456		/** Returns the unique atom types of local processor in an array */
457		std::set<AtomType*> getUniqueAtomTypes();
458
459		friend std::ostream& operator <<(std::ostream& o, SimInfo& info);
460
461	<	void getCutoff(double& rcut, double& rsw);
461	>	void getCutoff(RealType& rcut, RealType& rsw);
462
463		private:
464
#	Line 439 | Line 475 | namespace oopse{
475		void setupCutoff();
476
477		/** Figure out which coulombic correction method to use and pass to fortran */
478	<	void setupCoulombicCorrection( int isError );
478	>	void setupElectrostaticSummationMethod( int isError );
479
480	+	/** Figure out which polynomial type to use for the switching function */
481	+	void setupSwitchingFunction();
482	+
483	+	/** Determine if we need to accumulate the simulation box dipole */
484	+	void setupAccumulateBoxDipole();
485	+
486		/** Calculates the number of degress of freedom in the whole system */
487		void calcNdf();
488		void calcNdfRaw();
489		void calcNdfTrans();
490
491	+	ForceField* forceField_;
492	+	Globals* simParams_;
493	+
494	+	std::map<int, Molecule*>  molecules_; /**< Molecule array */
495	+
496		/**
497		* Adds molecule stamp and the total number of the molecule with same molecule stamp in the whole
498		* system.
499		*/
500		void addMoleculeStamp(MoleculeStamp* molStamp, int nmol);
454	–
455	–	MakeStamps* stamps_;
456	–	ForceField* forceField_;
457	–	Globals* simParams_;
458	–
459	–	std::map<int, Molecule*>  molecules_; /**< Molecule array */
501
502		//degress of freedom
503		int ndf_;           /**< number of degress of freedom (excludes constraints),  ndf_ is local */
504	+	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 */
#	Line 478 | Line 521 | namespace oopse{
521		std::vector<int> globalGroupMembership_;
522
523		/**
524	<	* the size of globalGroupMembership_  is nGlobalAtoms. Its index is  global index of an atom, and the
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		*/
#	Line 489 | Line 532 | namespace oopse{
532		std::vector<MoleculeStamp*> moleculeStamps_;      /**< molecule stamps array */
533
534		//number of local objects
535	<	int nAtoms_;                        /**< number of atoms in local processor */
536	<	int nBonds_;                        /**< number of bonds in local processor */
537	<	int nBends_;                        /**< number of bends in local processor */
538	<	int nTorsions_;                    /**< number of torsions in local processor */
539	<	int nRigidBodies_;              /**< number of rigid bodies in local processor */
540	<	int nIntegrableObjects_;    /**< number of integrable objects in local processor */
541	<	int nCutoffGroups_;             /**< number of cutoff groups in local processor */
542	<	int nConstraints_;              /**< number of constraints in local processors */
535	>	int nAtoms_;              /**< number of atoms in local processor */
536	>	int nBonds_;              /**< number of bonds in local processor */
537	>	int nBends_;              /**< number of bends in local processor */
538	>	int nTorsions_;           /**< number of torsions in local processor */
539	>	int nInversions_;         /**< number of inversions in local processor */
540	>	int nRigidBodies_;        /**< number of rigid bodies in local processor */
541	>	int nIntegrableObjects_;  /**< number of integrable objects in local processor */
542	>	int nCutoffGroups_;       /**< number of cutoff groups in local processor */
543	>	int nConstraints_;        /**< number of constraints in local processors */
544
545		simtype fInfo_; /**< A dual struct shared by c++/fortran which indicates the atom types in simulation*/
546	<	Exclude exclude_;
546	>	PairList excludedInteractions_;
547	>	PairList oneTwoInteractions_;
548	>	PairList oneThreeInteractions_;
549	>	PairList oneFourInteractions_;
550		PropertyMap properties_;                  /**< Generic Property */
551		SnapshotManager* sman_;               /**< SnapshotManager */
552
#	Line 511 | Line 558 | namespace oopse{
558		*/
559		LocalIndexManager localIndexMan_;
560
561	+	// unparsed MetaData block for storing in Dump and EOR files:
562	+	std::string rawMetaData_;
563	+
564		//file names
565		std::string finalConfigFileName_;
566		std::string dumpFileName_;
567		std::string statFileName_;
568		std::string restFileName_;
569
570	<	double rcut_;       /**< cutoff radius*/
571	<	double rsw_;        /**< radius of switching function*/
570	>	RealType rcut_;       /**< cutoff radius*/
571	>	RealType rsw_;        /**< radius of switching function*/
572	>	RealType rlist_;      /**< neighbor list radius */
573
574	<	bool fortranInitialized_; /**< flag indicate whether fortran side is initialized */
574	>	int ljsp_; /**< use shifted potential for LJ*/
575	>	int ljsf_; /**< use shifted force for LJ*/
576
577	<	#ifdef IS_MPI
577	>	bool fortranInitialized_; /**< flag indicate whether fortran side
578	>	is initialized */
579	>
580	>	bool calcBoxDipole_; /**< flag to indicate whether or not we calculate
581	>	the simulation box dipole moment */
582	>
583	>	bool useAtomicVirial_; /**< flag to indicate whether or not we use
584	>	Atomic Virials to calculate the pressure */
585	>
586	>	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);
597	>	/**
598	>	* return a StuntDouble by its global index. In MPI version, if the StuntDouble with specified
599	>	* global index does not belong to local processor, a NULL will be return.
600	>	*/
601	>	//StuntDouble* getStuntDoubleFromGlobalIndex(int index);
602	>	//private:
603	>	//std::vector<StuntDouble*> sdByGlobalIndex_;
604	>
605		//in Parallel version, we need MolToProc
606		public:
607
#	Line 549 | Line 628 | namespace oopse{
628		void setupFortranParallel();
629
630		/**
631	<	* The size of molToProcMap_ is equal to total number of molecules in the system.
632	<	*  It maps a molecule to the processor on which it resides. it is filled by SimCreator once and only
633	<	* once.
631	>	* The size of molToProcMap_ is equal to total number of molecules
632	>	* in the system.  It maps a molecule to the processor on which it
633	>	* resides. it is filled by SimCreator once and only once.
634		*/
635		std::vector<int> molToProcMap_;
636
558	–	#endif
637
638		};
639
640	<	} //namespace oopse
640	>	} //namespace OpenMD
641		#endif //BRAINS_SIMMODEL_HPP
642

Comparing trunk/src/brains/SimInfo.hpp (property svn:keywords):
Revision 598 by chrisfen, Thu Sep 15 00:14:35 2005 UTC vs.
Revision 1442 by gezelter, Mon May 10 17:28:26 2010 UTC

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

Diff Legend

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