ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/mdParser/MDTreeParser.g
(Generate patch)

Comparing trunk/src/mdParser/MDTreeParser.g (file contents):
Revision 1979 by gezelter, Sat Apr 5 20:56:01 2014 UTC vs.
Revision 2046 by gezelter, Tue Dec 2 22:11:04 2014 UTC

# Line 7 | Line 7 | options
7   using namespace OpenMD;
8   }
9   options
10 <  {
11 <  language = "Cpp";
12 <  }
13 <                    
10 > {
11 >    language = "Cpp";
12 > }  
13 >
14   class MDTreeParser extends TreeParser;
15  
16   options
17   {
18 <        k = 1;
19 <        importVocab = MD;
18 >    k = 1;
19 >    importVocab = MD;
20   }
21   {
22 <  public:
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;
25 >        currConf = new Globals;
26 >        blockStack.push(currConf);
27 >        mdfile(tree);
28 >        return currConf;
29      }
30 <  private:
30 >    private:
31      Globals* currConf;
32      stack<DataHolder*> blockStack;    
33   }
34   mdfile  : (statement)* {blockStack.top()->validate(); blockStack.pop();}
35 <        ;
35 >    ;
36  
37   statement : assignment
38      | componentblock
# Line 45 | Line 45 | assignment  : #(ASSIGNEQUAL id:ID constant[#id]) //{bl
45      ;
46  
47   assignment  : #(ASSIGNEQUAL id:ID constant[#id]) //{blockStack.top()->assign(#ID->getText(),);}
48 <            ;
49 <            
48 >    ;
49 >
50   constant [ANTLR_USE_NAMESPACE(antlr)RefAST id]
51   {
52      int ival;
53      RealType dval, x, y, z;
54 <    Vector3d dvec;
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 –    | #(LPAREN x=doubleNumber COMMA y=doubleNumber COMMA z=doubleNumber RPAREN)
59 –        {   dvec.x() = x;
60 –            dvec.y() = y;
61 –            dvec.z() = z;
62 –            blockStack.top()->assign(id->getText(), dvec);
63 –        }
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      ;
70 –            
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 <    
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 <                  ;
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 <  
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 <                ;
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 <                ;
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 <                ;
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 <              ;
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 <                  ;
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;
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 <          ;
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 < AtomStamp* currAtomStamp =  static_cast<AtomStamp*>(blockStack.top());
136 <
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 <              ;
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 : #(BOND {BondStamp* currBondStamp = new BondStamp(); blockStack.push(currBondStamp);}
147 –                (bondstatement)*
148 –                 ENDBLOCK )  {
149 –                                blockStack.pop();
150 –                                MoleculeStamp* currMoleculeStamp = static_cast<MoleculeStamp*>(blockStack.top());
151 –                                currMoleculeStamp->addBondStamp(currBondStamp);
152 –                             }
153 –          ;
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 <  BondStamp* currBondStamp = static_cast<BondStamp*>(blockStack.top());
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 <              ;
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 <
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 <  BendStamp* currBendStamp = static_cast<BendStamp*>(blockStack.top());
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);}
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);}
# Line 193 | Line 211 | torsionstatement
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);}
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);}
# Line 213 | Line 241 | 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);}
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

Diff Legend

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