ViewVC Help

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

root/OpenMD/trunk/src/UseTheForce/DUFF.cpp

Comparing trunk/src/UseTheForce/DUFF.cpp (file contents):
Revision 492 by chuckv, Wed Apr 13 20:36:45 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
43		#include "UseTheForce/DUFF.hpp"
44		#include "UseTheForce/DarkSide/lj_interface.h"
45		#include "UseTheForce/DarkSide/sticky_interface.h"
46	+	#include "UseTheForce/DarkSide/gb_interface.h"
47		#include "UseTheForce/ForceFieldFactory.hpp"
48	+	#include "io/BaseAtomTypesSectionParser.hpp"
49		#include "io/DirectionalAtomTypesSectionParser.hpp"
50		#include "io/AtomTypesSectionParser.hpp"
51	+	#include "io/BaseAtomTypesSectionParser.hpp"
52		#include "io/LennardJonesAtomTypesSectionParser.hpp"
53		#include "io/ChargeAtomTypesSectionParser.hpp"
54		#include "io/MultipoleAtomTypesSectionParser.hpp"
55		#include "io/StickyAtomTypesSectionParser.hpp"
56	+	#include "io/StickyPowerAtomTypesSectionParser.hpp"
57	+	#include "io/GayBerneAtomTypesSectionParser.hpp"
58		#include "io/BondTypesSectionParser.hpp"
59		#include "io/BendTypesSectionParser.hpp"
60		#include "io/TorsionTypesSectionParser.hpp"
61	+	#include "io/OptionSectionParser.hpp"
62		#include "UseTheForce/ForceFieldCreator.hpp"
63
64	<	namespace oopse {
64	>	namespace OpenMD {
65
66	<	DUFF::DUFF(){
66	>	DUFF::DUFF(){
67
68		//set default force field filename
69		setForceFieldFileName("DUFF2.frc");
70
71	<	//the order of adding section parsers are important
72	<	//DirectionalAtomTypesSectionParser should be added before AtomTypesSectionParser Since
67	<	//These two section parsers will actually create "real" AtomTypes (AtomTypesSectionParser will create
68	<	//AtomType and DirectionalAtomTypesSectionParser will creat DirectionalAtomType which is a subclass
69	<	//of AtomType, therefore it should come first). Other AtomTypes Section Parser will not create the
70	<	//"real" AtomType, they only add and set some attribute of the AtomType. Thus their order are not
71	<	//important. AtomTypesSectionParser should be added before other atom type section parsers.
72	<	//Make sure they are added after DirectionalAtomTypesSectionParser and AtomTypesSectionParser.
73	<	//The order of BondTypesSectionParser, BendTypesSectionParser and TorsionTypesSectionParser are
74	<	//not important.
75	<	spMan_.push_back(new DirectionalAtomTypesSectionParser());
71	>	spMan_.push_back(new OptionSectionParser(forceFieldOptions_));
72	>	spMan_.push_back(new BaseAtomTypesSectionParser());
73		spMan_.push_back(new AtomTypesSectionParser());
74	<	spMan_.push_back(new LennardJonesAtomTypesSectionParser());
75	<	spMan_.push_back(new ChargeAtomTypesSectionParser());
76	<	spMan_.push_back(new MultipoleAtomTypesSectionParser());
77	<	spMan_.push_back(new StickyAtomTypesSectionParser());
78	<	spMan_.push_back(new BondTypesSectionParser());
79	<	spMan_.push_back(new BendTypesSectionParser());
80	<	spMan_.push_back(new TorsionTypesSectionParser());
74	>	spMan_.push_back(new DirectionalAtomTypesSectionParser(forceFieldOptions_));
75	>	spMan_.push_back(new LennardJonesAtomTypesSectionParser(forceFieldOptions_));
76	>	spMan_.push_back(new ChargeAtomTypesSectionParser(forceFieldOptions_));
77	>	spMan_.push_back(new MultipoleAtomTypesSectionParser(forceFieldOptions_));
78	>	spMan_.push_back(new StickyAtomTypesSectionParser(forceFieldOptions_));
79	>	spMan_.push_back(new StickyPowerAtomTypesSectionParser(forceFieldOptions_));
80	>	spMan_.push_back(new GayBerneAtomTypesSectionParser(forceFieldOptions_));
81	>	spMan_.push_back(new BondTypesSectionParser(forceFieldOptions_));
82	>	spMan_.push_back(new BendTypesSectionParser(forceFieldOptions_));
83	>	spMan_.push_back(new TorsionTypesSectionParser(forceFieldOptions_));
84
85	<	}
85	>	}
86
87	<	void DUFF::parse(const std::string& filename) {
87	>	void DUFF::parse(const std::string& filename) {
88		ifstrstream* ffStream;
89	+	bool hasGBtypes;
90	+
91		ffStream = openForceFieldFile(filename);
92
93		spMan_.parse(*ffStream, *this);
#	Line 93 | Line 95 | void DUFF::parse(const std::string& filename) {
95		ForceField::AtomTypeContainer::MapTypeIterator i;
96		AtomType* at;
97
98	<	for (at = atomTypeCont_.beginType(i); at != NULL; at = atomTypeCont_.nextType(i)) {
99	<	at->makeFortranAtomType();
98	>	for (at = atomTypeCont_.beginType(i); at != NULL;
99	>	at = atomTypeCont_.nextType(i)) {
100	>	// useBase sets the responsibilities, and these have to be done
101	>	// after the atomTypes and Base types have all been scanned:
102	>
103	>	std::vector<AtomType*> ayb = at->allYourBase();
104	>	if (ayb.size() > 1) {
105	>	for (int j = ayb.size()-1; j > 0; j--) {
106	>
107	>	ayb[j-1]->useBase(ayb[j]);
108	>
109	>	}
110	>	}
111	>	at->makeFortranAtomType();
112		}
113
114	<	for (at = atomTypeCont_.beginType(i); at != NULL; at = atomTypeCont_.nextType(i)) {
115	<	at->complete();
114	>	for (at = atomTypeCont_.beginType(i); at != NULL;
115	>	at = atomTypeCont_.nextType(i)) {
116	>	at->complete();
117		}
118
119	+	hasGBtypes = false;
120	+	for (at = atomTypeCont_.beginType(i); at != NULL;
121	+	at = atomTypeCont_.nextType(i)) {
122	+	if (at->isGayBerne())
123	+	hasGBtypes = true;
124	+	}
125	+
126	+	int isError = 0;
127	+
128	+	if (hasGBtypes) {
129	+	completeGBFF(&isError);
130	+	}
131	+
132		delete ffStream;
133
134	<	}
134	>	}
135
136	<	DUFF::~DUFF(){
137	<	destroyLJTypes();
138	<	destroyStickyTypes();
139	<	}
140	<	} //end namespace oopse
136	>	DUFF::~DUFF(){
137	>	destroyLJTypes();
138	>	destroyStickyTypes();
139	>	destroyGayBerneTypes();
140	>	}
141	>	} //end namespace OpenMD

Comparing trunk/src/UseTheForce/DUFF.cpp (property svn:keywords):
Revision 492 by chuckv, Wed Apr 13 20:36:45 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