src/mdParser/MDTreeParser.g

header
{
#include <stack>
#include "io/Globals.hpp"
#include "utils/StringUtils.hpp"
using namespace std;
using namespace OpenMD;
}
options
{
    language = "Cpp";
}   

class MDTreeParser extends TreeParser;

options
{
    k = 1;
    importVocab = MD;
}
{
    public:
    Globals* walkTree(ANTLR_USE_NAMESPACE(antlr)RefAST tree)
    {
        currConf = new Globals;
        blockStack.push(currConf);
        mdfile(tree);
        return currConf;
    }
    private:
    Globals* currConf;
    stack<DataHolder*> blockStack;    
}
mdfile  : (statement)* {blockStack.top()->validate(); blockStack.pop();}
    ;

statement : assignment
    | componentblock
    | moleculeblock
    | zconstraintblock
    | restraintblock
    | flucqblock
    | rnemdblock
    | minimizerblock
    ;

assignment  : #(ASSIGNEQUAL id:ID constant[#id]) //{blockStack.top()->assign(#ID->getText(),);}
    ;

constant [ANTLR_USE_NAMESPACE(antlr)RefAST id]
{
    int ival;
    RealType dval, x, y, z;
    std::vector<RealType> dvec;
}    
    : ival=intConst {blockStack.top()->assign(id->getText(), ival);}
    | dval=floatConst {blockStack.top()->assign(id->getText(), dval);}
    | str1:ID {blockStack.top()->assign(id->getText(), str1->getText());}
    | str2:StringLiteral {std::string s =  str2->getText();
            s = s.substr(1, s.length()-2);
            blockStack.top()->assign(id->getText(),s);
        }
    | #(LPAREN dvec=doubleNumberTuple RPAREN) 
        { 
            blockStack.top()->assign(id->getText(), dvec);
        }
    ;


componentblock  : #(COMPONENT  {Component* currComponet = new Component(); blockStack.push(currComponet);}
            (assignment)* 
            ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);}
    ;

zconstraintblock  : #(ZCONSTRAINT {ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);}
            (assignment)* 
            ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);}
    ;

restraintblock  : #(RESTRAINT {RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);}
            (assignment)* 
            ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);}
    ;

flucqblock  : #(FLUCQ  {FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);}
            (assignment)* 
            ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);}
    ;

rnemdblock  : #(RNEMD  {RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);}
            (assignment)* 
            ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);}
    ;

minimizerblock  : #(MINIMIZER  {MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);}
            (assignment)* 
            ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);}
    ;


moleculeblock : #(MOLECULE {MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);}
            (moleculestatement)* 
            ENDBLOCK ) {blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);}
    ;

moleculestatement : assignment
    | atomblock
    | bondblock
    | bendblock
    | torsionblock
    | inversionblock
    | rigidbodyblock
    | cutoffgroupblock
    | fragmentblock
    | constraintblock
    ;

atomblock 
{
    int index;
}
    : #(ATOM index=intConst {AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);} 
            (atomstatement)* 
            ENDBLOCK ) {
            blockStack.top()->validate();
            blockStack.pop(); 
            MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
            currMoleculeStamp->addAtomStamp(currAtomStamp); 
        }
    ;

atomstatement 
{
    vector<RealType> dvec;
    RealType rval;
    AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
    
}
    : assignment
    | #(POSITION dvec=doubleNumberTuple) {currAtomStamp->setPosition(dvec);}
    | #(ORIENTATION dvec=doubleNumberTuple) {currAtomStamp->setOrientation(dvec);}
    | #(CHARGE rval=doubleNumber) {currAtomStamp->overrideCharge(rval);}        
    ;


bondblock 
    : #(BOND {BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);}
            (bondstatement)* 
            ENDBLOCK )  {
            blockStack.top()->validate();
            blockStack.pop(); 
            MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
            currMoleculeStamp->addBondStamp(currBondStamp); 
        }   
    ;

bondstatement 
{
    vector<int> ivec;
    RealType rval;
    vector<RealType> dvec;
    BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
}
    : assignment
    | #(MEMBERS ivec=inttuple) {currBondStamp->setMembers(ivec);}
    | #(FIXED rval=doubleNumber) {currBondStamp->overrideType("Fixed", rval);}
    | #(HARMONIC dvec=doubleNumberTuple) {currBondStamp->overrideType("Harmonic", dvec);}
    | #(CUBIC dvec=doubleNumberTuple) {currBondStamp->overrideType("Cubic", dvec);}
    | #(QUARTIC dvec=doubleNumberTuple) {currBondStamp->overrideType("Quartic", dvec);}
    | #(POLYNOMIAL dvec=doubleNumberTuple) {currBondStamp->overrideType("Polynomial", dvec);}
    | #(MORSE dvec=doubleNumberTuple) {currBondStamp->overrideType("Morse", dvec);}
    ;

bendblock : #(BEND {BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);}
                  (bendstatement)* 
                   ENDBLOCK)  {
            blockStack.top()->validate();
            blockStack.pop(); 
            MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
            currMoleculeStamp->addBendStamp(currBendStamp); 
        }
        ;
    
bendstatement 
{
    vector<int> ivec;
    vector<RealType> dvec;
    BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
}
    : assignment
    | #(MEMBERS ivec=inttuple) {currBendStamp->setMembers(ivec);}
    | #(HARMONIC dvec=doubleNumberTuple) {currBendStamp->overrideType("Harmonic", dvec);}
    | #(GHOSTBEND dvec=doubleNumberTuple) {currBendStamp->overrideType("GhostBend", dvec);}
    | #(UREYBRADLEY dvec=doubleNumberTuple) {currBendStamp->overrideType("UreyBradley", dvec);}
    | #(CUBIC dvec=doubleNumberTuple) {currBendStamp->overrideType("Cubic", dvec);}
    | #(QUARTIC dvec=doubleNumberTuple) {currBendStamp->overrideType("Quartic", dvec);}
    | #(POLYNOMIAL dvec=doubleNumberTuple) {currBendStamp->overrideType("Polynomial", dvec);}
    | #(COSINE dvec=doubleNumberTuple) {currBendStamp->overrideType("Cosine", dvec);}
              ;

torsionblock  : #(TORSION {TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);}
                   (torsionstatement)*
                    ENDBLOCK )  {
                                  blockStack.top()->validate();
                                  blockStack.pop(); 
                                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                  currMoleculeStamp->addTorsionStamp(currTorsionStamp); 
                                }
          ;

torsionstatement
{
  vector<int> ivec;
  vector<RealType> dvec;
  TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
}  
              : assignment
    | #(MEMBERS ivec=inttuple) {currTorsionStamp->setMembers(ivec);}
    | #(GHOSTTORSION dvec=doubleNumberTuple) {currTorsionStamp->overrideType("GhostTorsion", dvec);}
    | #(CUBIC dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Cubic", dvec);}
    | #(QUARTIC dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Quartic", dvec);}
    | #(POLYNOMIAL dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Polynomial", dvec);}
    | #(CHARMM dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Charmm", dvec);}
    | #(OPLS dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Opls", dvec);}
    | #(TRAPPE dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Trappe", dvec);}
    | #(HARMONIC dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Harmonic", dvec);}

              ;

inversionblock  : #(INVERSION {InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);}
                   (inversionstatement)*
                    ENDBLOCK )  {
                                  blockStack.top()->validate();
                                  blockStack.pop(); 
                                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                  currMoleculeStamp->addInversionStamp(currInversionStamp); 
                                }
          ;

inversionstatement
{
  int icent;
  vector<int> ivec;
  vector<RealType> dvec;
  InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
}
 : assignment
    | #(CENTER icent=intConst) {currInversionStamp->setCenter(icent);}
    | #(SATELLITES ivec=inttuple) {currInversionStamp->setSatellites(ivec);}
    | #(AMBERIMPROPER dvec=doubleNumberTuple) {currInversionStamp->overrideType("AmberImproper", dvec);}
    | #(IMPROPERCOSINE dvec=doubleNumberTuple) {currInversionStamp->overrideType("ImproperCosine", dvec);}
    | #(HARMONIC dvec=doubleNumberTuple) {currInversionStamp->overrideType("Harmonic", dvec);}
    | #(CENTRALATOMHEIGHT dvec=doubleNumberTuple) {currInversionStamp->overrideType("CentralAtomHeight", dvec);}
    | #(DREIDING dvec=doubleNumberTuple) {currInversionStamp->overrideType("Dreiding", dvec);}

              ;

rigidbodyblock
{
int index;
}
              : #(RIGIDBODY index=intConst {RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);}
                        (rigidbodystatement)* 
                        ENDBLOCK )  {
                                      blockStack.top()->validate();
                                      blockStack.pop(); 
                                      MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                      currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp); 
                                    }
                ;

rigidbodystatement  
{
  vector<int> ivec;
  RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
}
              : assignment
              | #(MEMBERS ivec=inttuple) {currRigidBodyStamp->setMembers(ivec);}
              ;

cutoffgroupblock  : #(CUTOFFGROUP  {CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);}
                          (cutoffgroupstatement)* 
                           ENDBLOCK ) {
                                        blockStack.top()->validate();
                                        blockStack.pop(); 
                                        MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                        currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp); 
                                      }
                  ;

cutoffgroupstatement
{
  vector<int> ivec;
  CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
}  
              : assignment
              | #(MEMBERS ivec=inttuple) {currCutoffGroupStamp->setMembers(ivec);}             
              ;

fragmentblock {int ival;}
               : #(FRAGMENT ival=intConst {FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);}
                      (fragmentstatement)* 
                      ENDBLOCK) {
                                  blockStack.top()->validate();
                                  blockStack.pop(); 
                                  MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                  currMoleculeStamp->addFragmentStamp(currFragmentStamp); 
                                }
              ;

fragmentstatement : assignment
    ;

constraintblock : #(CONSTRAINT {ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);}
                (constraintstatement)* 
                 ENDBLOCK )  {
                                blockStack.pop(); 
                                MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
                                currMoleculeStamp->addConstraintStamp(currConstraintStamp); 
                             }
          ;

constraintstatement 
{
  vector<int> ivec;
  ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
}
              : assignment
              | #(MEMBERS ivec=inttuple) {currConstraintStamp->setMembers(ivec);}
              ;

              
doubleNumberTuple returns [vector<RealType> dvec]
{
    RealType dval;
}   
    : (dval=doubleNumber {dvec.push_back(dval);})+  
    ;


inttuple returns [vector<int> ivec]
{
    int ival;
}
    : (ival=intConst {ivec.push_back(ival);})+ 
    ;

protected
intConst returns [int ival]
    : i1:NUM_INT {ival = lexi_cast<int>(i1->getText());} 
    | i2:NUM_LONG {ival = lexi_cast<int>(i2->getText());}
    ;

protected
doubleNumber returns [RealType dval]
    : ic:intConst {dval = lexi_cast<RealType>(ic->getText());}
    | fc:floatConst {dval = lexi_cast<RealType>(fc->getText());}         
    ;
              
protected
floatConst returns [RealType dval]
    : d1:NUM_FLOAT {dval = lexi_cast<RealType>(d1->getText());}  
    | d2:NUM_DOUBLE {dval = lexi_cast<RealType>(d2->getText());} 
    ;
  
Revision:	2046
Committed:	Tue Dec 2 22:11:04 2014 UTC (10 years, 5 months ago) by gezelter
File size:	14405 byte(s)
Log Message:	Fixed some broken comments for use with Doxygen. Made changes to allow topology-based force-field overrides in include files. Fixed a calculation of box quadrupole moments for molecules with point dipoles.
#	Content
1	header
2	{
3	#include <stack>
4	#include "io/Globals.hpp"
5	#include "utils/StringUtils.hpp"
6	using namespace std;
7	using namespace OpenMD;
8	}
9	options
10	{
11	language = "Cpp";
12	}
13
14	class MDTreeParser extends TreeParser;
15
16	options
17	{
18	k = 1;
19	importVocab = MD;
20	}
21	{
22	public:
23	Globals* walkTree(ANTLR_USE_NAMESPACE(antlr)RefAST tree)
24	{
25	currConf = new Globals;
26	blockStack.push(currConf);
27	mdfile(tree);
28	return currConf;
29	}
30	private:
31	Globals* currConf;
32	stack<DataHolder*> blockStack;
33	}
34	mdfile : (statement)* {blockStack.top()->validate(); blockStack.pop();}
35	;
36
37	statement : assignment
38	\| componentblock
39	\| moleculeblock
40	\| zconstraintblock
41	\| restraintblock
42	\| flucqblock
43	\| rnemdblock
44	\| minimizerblock
45	;
46
47	assignment : #(ASSIGNEQUAL id:ID constant[#id]) //{blockStack.top()->assign(#ID->getText(),);}
48	;
49
50	constant [ANTLR_USE_NAMESPACE(antlr)RefAST id]
51	{
52	int ival;
53	RealType dval, x, y, z;
54	std::vector<RealType> dvec;
55	}
56	: ival=intConst {blockStack.top()->assign(id->getText(), ival);}
57	\| dval=floatConst {blockStack.top()->assign(id->getText(), dval);}
58	\| str1:ID {blockStack.top()->assign(id->getText(), str1->getText());}
59	\| str2:StringLiteral {std::string s = str2->getText();
60	s = s.substr(1, s.length()-2);
61	blockStack.top()->assign(id->getText(),s);
62	}
63	\| #(LPAREN dvec=doubleNumberTuple RPAREN)
64	{
65	blockStack.top()->assign(id->getText(), dvec);
66	}
67	;
68
69
70	componentblock : #(COMPONENT {Component* currComponet = new Component(); blockStack.push(currComponet);}
71	(assignment)*
72	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addComponent(currComponet);}
73	;
74
75	zconstraintblock : #(ZCONSTRAINT {ZConsStamp* currZConsStamp = new ZConsStamp(); blockStack.push(currZConsStamp);}
76	(assignment)*
77	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addZConsStamp(currZConsStamp);}
78	;
79
80	restraintblock : #(RESTRAINT {RestraintStamp* currRestraintStamp = new RestraintStamp(); blockStack.push(currRestraintStamp);}
81	(assignment)*
82	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRestraintStamp(currRestraintStamp);}
83	;
84
85	flucqblock : #(FLUCQ {FluctuatingChargeParameters* flucQpars = new FluctuatingChargeParameters(); blockStack.push(flucQpars);}
86	(assignment)*
87	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addFluctuatingChargeParameters(flucQpars);}
88	;
89
90	rnemdblock : #(RNEMD {RNEMDParameters* rnemdPars = new RNEMDParameters(); blockStack.push(rnemdPars);}
91	(assignment)*
92	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addRNEMDParameters(rnemdPars);}
93	;
94
95	minimizerblock : #(MINIMIZER {MinimizerParameters* minimizerPars = new MinimizerParameters(); blockStack.push(minimizerPars);}
96	(assignment)*
97	ENDBLOCK ) {blockStack.top()->validate();blockStack.pop(); currConf->addMinimizerParameters(minimizerPars);}
98	;
99
100
101	moleculeblock : #(MOLECULE {MoleculeStamp* currMoleculeStamp = new MoleculeStamp(); blockStack.push(currMoleculeStamp);}
102	(moleculestatement)*
103	ENDBLOCK ) {blockStack.top()->validate(); blockStack.pop(); currConf->addMoleculeStamp(currMoleculeStamp);}
104	;
105
106	moleculestatement : assignment
107	\| atomblock
108	\| bondblock
109	\| bendblock
110	\| torsionblock
111	\| inversionblock
112	\| rigidbodyblock
113	\| cutoffgroupblock
114	\| fragmentblock
115	\| constraintblock
116	;
117
118	atomblock
119	{
120	int index;
121	}
122	: #(ATOM index=intConst {AtomStamp* currAtomStamp = new AtomStamp(index); blockStack.push(currAtomStamp);}
123	(atomstatement)*
124	ENDBLOCK ) {
125	blockStack.top()->validate();
126	blockStack.pop();
127	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
128	currMoleculeStamp->addAtomStamp(currAtomStamp);
129	}
130	;
131
132	atomstatement
133	{
134	vector<RealType> dvec;
135	RealType rval;
136	AtomStamp* currAtomStamp = static_cast<AtomStamp*>(blockStack.top());
137
138	}
139	: assignment
140	\| #(POSITION dvec=doubleNumberTuple) {currAtomStamp->setPosition(dvec);}
141	\| #(ORIENTATION dvec=doubleNumberTuple) {currAtomStamp->setOrientation(dvec);}
142	\| #(CHARGE rval=doubleNumber) {currAtomStamp->overrideCharge(rval);}
143	;
144
145
146	bondblock
147	: #(BOND {BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);}
148	(bondstatement)*
149	ENDBLOCK ) {
150	blockStack.top()->validate();
151	blockStack.pop();
152	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
153	currMoleculeStamp->addBondStamp(currBondStamp);
154	}
155	;
156
157	bondstatement
158	{
159	vector<int> ivec;
160	RealType rval;
161	vector<RealType> dvec;
162	BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
163	}
164	: assignment
165	\| #(MEMBERS ivec=inttuple) {currBondStamp->setMembers(ivec);}
166	\| #(FIXED rval=doubleNumber) {currBondStamp->overrideType("Fixed", rval);}
167	\| #(HARMONIC dvec=doubleNumberTuple) {currBondStamp->overrideType("Harmonic", dvec);}
168	\| #(CUBIC dvec=doubleNumberTuple) {currBondStamp->overrideType("Cubic", dvec);}
169	\| #(QUARTIC dvec=doubleNumberTuple) {currBondStamp->overrideType("Quartic", dvec);}
170	\| #(POLYNOMIAL dvec=doubleNumberTuple) {currBondStamp->overrideType("Polynomial", dvec);}
171	\| #(MORSE dvec=doubleNumberTuple) {currBondStamp->overrideType("Morse", dvec);}
172	;
173
174	bendblock : #(BEND {BendStamp* currBendStamp = new BendStamp(); blockStack.push(currBendStamp);}
175	(bendstatement)*
176	ENDBLOCK) {
177	blockStack.top()->validate();
178	blockStack.pop();
179	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
180	currMoleculeStamp->addBendStamp(currBendStamp);
181	}
182	;
183
184	bendstatement
185	{
186	vector<int> ivec;
187	vector<RealType> dvec;
188	BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
189	}
190	: assignment
191	\| #(MEMBERS ivec=inttuple) {currBendStamp->setMembers(ivec);}
192	\| #(HARMONIC dvec=doubleNumberTuple) {currBendStamp->overrideType("Harmonic", dvec);}
193	\| #(GHOSTBEND dvec=doubleNumberTuple) {currBendStamp->overrideType("GhostBend", dvec);}
194	\| #(UREYBRADLEY dvec=doubleNumberTuple) {currBendStamp->overrideType("UreyBradley", dvec);}
195	\| #(CUBIC dvec=doubleNumberTuple) {currBendStamp->overrideType("Cubic", dvec);}
196	\| #(QUARTIC dvec=doubleNumberTuple) {currBendStamp->overrideType("Quartic", dvec);}
197	\| #(POLYNOMIAL dvec=doubleNumberTuple) {currBendStamp->overrideType("Polynomial", dvec);}
198	\| #(COSINE dvec=doubleNumberTuple) {currBendStamp->overrideType("Cosine", dvec);}
199	;
200
201	torsionblock : #(TORSION {TorsionStamp* currTorsionStamp = new TorsionStamp(); blockStack.push(currTorsionStamp);}
202	(torsionstatement)*
203	ENDBLOCK ) {
204	blockStack.top()->validate();
205	blockStack.pop();
206	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
207	currMoleculeStamp->addTorsionStamp(currTorsionStamp);
208	}
209	;
210
211	torsionstatement
212	{
213	vector<int> ivec;
214	vector<RealType> dvec;
215	TorsionStamp* currTorsionStamp = static_cast<TorsionStamp*>(blockStack.top());
216	}
217	: assignment
218	\| #(MEMBERS ivec=inttuple) {currTorsionStamp->setMembers(ivec);}
219	\| #(GHOSTTORSION dvec=doubleNumberTuple) {currTorsionStamp->overrideType("GhostTorsion", dvec);}
220	\| #(CUBIC dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Cubic", dvec);}
221	\| #(QUARTIC dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Quartic", dvec);}
222	\| #(POLYNOMIAL dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Polynomial", dvec);}
223	\| #(CHARMM dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Charmm", dvec);}
224	\| #(OPLS dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Opls", dvec);}
225	\| #(TRAPPE dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Trappe", dvec);}
226	\| #(HARMONIC dvec=doubleNumberTuple) {currTorsionStamp->overrideType("Harmonic", dvec);}
227
228	;
229
230	inversionblock : #(INVERSION {InversionStamp* currInversionStamp = new InversionStamp(); blockStack.push(currInversionStamp);}
231	(inversionstatement)*
232	ENDBLOCK ) {
233	blockStack.top()->validate();
234	blockStack.pop();
235	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
236	currMoleculeStamp->addInversionStamp(currInversionStamp);
237	}
238	;
239
240	inversionstatement
241	{
242	int icent;
243	vector<int> ivec;
244	vector<RealType> dvec;
245	InversionStamp* currInversionStamp = static_cast<InversionStamp*>(blockStack.top());
246	}
247	: assignment
248	\| #(CENTER icent=intConst) {currInversionStamp->setCenter(icent);}
249	\| #(SATELLITES ivec=inttuple) {currInversionStamp->setSatellites(ivec);}
250	\| #(AMBERIMPROPER dvec=doubleNumberTuple) {currInversionStamp->overrideType("AmberImproper", dvec);}
251	\| #(IMPROPERCOSINE dvec=doubleNumberTuple) {currInversionStamp->overrideType("ImproperCosine", dvec);}
252	\| #(HARMONIC dvec=doubleNumberTuple) {currInversionStamp->overrideType("Harmonic", dvec);}
253	\| #(CENTRALATOMHEIGHT dvec=doubleNumberTuple) {currInversionStamp->overrideType("CentralAtomHeight", dvec);}
254	\| #(DREIDING dvec=doubleNumberTuple) {currInversionStamp->overrideType("Dreiding", dvec);}
255
256	;
257
258	rigidbodyblock
259	{
260	int index;
261	}
262	: #(RIGIDBODY index=intConst {RigidBodyStamp* currRigidBodyStamp = new RigidBodyStamp(index); blockStack.push(currRigidBodyStamp);}
263	(rigidbodystatement)*
264	ENDBLOCK ) {
265	blockStack.top()->validate();
266	blockStack.pop();
267	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
268	currMoleculeStamp->addRigidBodyStamp(currRigidBodyStamp);
269	}
270	;
271
272	rigidbodystatement
273	{
274	vector<int> ivec;
275	RigidBodyStamp* currRigidBodyStamp = static_cast<RigidBodyStamp*>(blockStack.top());
276	}
277	: assignment
278	\| #(MEMBERS ivec=inttuple) {currRigidBodyStamp->setMembers(ivec);}
279	;
280
281	cutoffgroupblock : #(CUTOFFGROUP {CutoffGroupStamp* currCutoffGroupStamp = new CutoffGroupStamp(); blockStack.push(currCutoffGroupStamp);}
282	(cutoffgroupstatement)*
283	ENDBLOCK ) {
284	blockStack.top()->validate();
285	blockStack.pop();
286	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
287	currMoleculeStamp->addCutoffGroupStamp(currCutoffGroupStamp);
288	}
289	;
290
291	cutoffgroupstatement
292	{
293	vector<int> ivec;
294	CutoffGroupStamp* currCutoffGroupStamp = static_cast<CutoffGroupStamp*>(blockStack.top());
295	}
296	: assignment
297	\| #(MEMBERS ivec=inttuple) {currCutoffGroupStamp->setMembers(ivec);}
298	;
299
300	fragmentblock {int ival;}
301	: #(FRAGMENT ival=intConst {FragmentStamp* currFragmentStamp = new FragmentStamp(ival); blockStack.push(currFragmentStamp);}
302	(fragmentstatement)*
303	ENDBLOCK) {
304	blockStack.top()->validate();
305	blockStack.pop();
306	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
307	currMoleculeStamp->addFragmentStamp(currFragmentStamp);
308	}
309	;
310
311	fragmentstatement : assignment
312	;
313
314	constraintblock : #(CONSTRAINT {ConstraintStamp* currConstraintStamp = new ConstraintStamp(); blockStack.push(currConstraintStamp);}
315	(constraintstatement)*
316	ENDBLOCK ) {
317	blockStack.pop();
318	MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
319	currMoleculeStamp->addConstraintStamp(currConstraintStamp);
320	}
321	;
322
323	constraintstatement
324	{
325	vector<int> ivec;
326	ConstraintStamp* currConstraintStamp = static_cast<ConstraintStamp*>(blockStack.top());
327	}
328	: assignment
329	\| #(MEMBERS ivec=inttuple) {currConstraintStamp->setMembers(ivec);}
330	;
331
332
333	doubleNumberTuple returns [vector<RealType> dvec]
334	{
335	RealType dval;
336	}
337	: (dval=doubleNumber {dvec.push_back(dval);})+
338	;
339
340
341	inttuple returns [vector<int> ivec]
342	{
343	int ival;
344	}
345	: (ival=intConst {ivec.push_back(ival);})+
346	;
347
348	protected
349	intConst returns [int ival]
350	: i1:NUM_INT {ival = lexi_cast<int>(i1->getText());}
351	\| i2:NUM_LONG {ival = lexi_cast<int>(i2->getText());}
352	;
353
354	protected
355	doubleNumber returns [RealType dval]
356	: ic:intConst {dval = lexi_cast<RealType>(ic->getText());}
357	\| fc:floatConst {dval = lexi_cast<RealType>(fc->getText());}
358	;
359
360	protected
361	floatConst returns [RealType dval]
362	: d1:NUM_FLOAT {dval = lexi_cast<RealType>(d1->getText());}
363	\| d2:NUM_DOUBLE {dval = lexi_cast<RealType>(d2->getText());}
364	;
365