ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/types/AtomType.cpp
(Generate patch)

Comparing trunk/OOPSE-4/src/types/AtomType.cpp (file contents):
Revision 1930 by gezelter, Wed Jan 12 22:41:40 2005 UTC vs.
Revision 3172 by gezelter, Fri Jul 13 17:37:25 2007 UTC

# Line 1 | Line 1
1 < /*
1 > /*
2   * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3   *
4   * The University of Notre Dame grants you ("Licensee") a
# Line 50 | Line 50
50   #include "UseTheForce/DarkSide/atype_interface.h"
51   #include "UseTheForce/DarkSide/lj_interface.h"
52   #include "UseTheForce/DarkSide/eam_interface.h"
53 < #include "UseTheForce/DarkSide/charge_interface.h"
53 > #include "UseTheForce/DarkSide/electrostatic_interface.h"
54 > #include "UseTheForce/DarkSide/suttonchen_interface.h"
55   namespace oopse {
56    AtomType::AtomType(){
57      
58      // initialize to an error:
59      atp.ident = -1;
60 <
60 >    
61      // and mass_less:
62      mass_ = 0.0;
63      
# Line 65 | Line 66 | namespace oopse {
66      atp.is_LennardJones = 0;
67      atp.is_Charge = 0;
68      atp.is_Dipole = 0;
69 +    atp.is_SplitDipole = 0;
70      atp.is_Quadrupole = 0;
71      atp.is_Sticky = 0;
72 +    atp.is_StickyPower = 0;
73      atp.is_GayBerne = 0;
74      atp.is_EAM = 0;
75      atp.is_Shape = 0;
76      atp.is_FLARB = 0;  
77 +    atp.is_SC = 0;
78    }
79 <    
79 >  
80    void AtomType::makeFortranAtomType() {
81      
82      int status;
83 <
83 >    
84      if (name_.empty()) {
85        sprintf( painCave.errMsg,
86                 "Attempting to complete an AtomType without giving "
# Line 94 | Line 98 | namespace oopse {
98        painCave.isFatal = 1;
99        simError();          
100      }
101 <
101 >    
102      status = 0;
103 <
103 >    
104      makeAtype(&atp, &status);  
105      
106      if (status != 0) {
# Line 107 | Line 111 | namespace oopse {
111        simError();          
112      }
113    }
114 <
115 <
116 < void AtomType::complete() {
114 >  
115 >  
116 >  void AtomType::complete() {
117      int isError;
118      GenericData* data;
119      
120      //notify a new LJtype atom type is created
121      if (isLennardJones()) {
122 <        data = getPropertyByName("LennardJones");
123 <        if (data != NULL) {
124 <            LJParamGenericData* ljData = dynamic_cast<LJParamGenericData*>(data);
125 <
126 <            if (ljData != NULL) {
127 <                LJParam ljParam = ljData->getData();
128 <                
129 <                newLJtype(&atp.ident, &ljParam.sigma, &ljParam.epsilon, &isError);
130 <
131 <                if (isError != 0) {
132 <                    sprintf( painCave.errMsg,
133 <                           "Fortran rejected newLJtype\n");
134 <                    painCave.severity = OOPSE_ERROR;
135 <                    painCave.isFatal = 1;
136 <                    simError();          
137 <                }
138 <                
139 <            } else {
140 <                    sprintf( painCave.errMsg,
141 <                           "Can not cast GenericData to LJParam\n");
142 <                    painCave.severity = OOPSE_ERROR;
143 <                    painCave.isFatal = 1;
144 <                    simError();          
145 <            }            
146 <        } else {
147 <            sprintf( painCave.errMsg, "Can not find Parameters for LennardJones\n");
148 <            painCave.severity = OOPSE_ERROR;
149 <            painCave.isFatal = 1;
150 <            simError();          
151 <        }
122 >      data = getPropertyByName("LennardJones");
123 >      if (data != NULL) {
124 >        LJParamGenericData* ljData = dynamic_cast<LJParamGenericData*>(data);
125 >        
126 >        if (ljData != NULL) {
127 >          LJParam ljParam = ljData->getData();
128 >          
129 >          newLJtype(&atp.ident, &ljParam.sigma, &ljParam.epsilon,
130 >                    &ljParam.soft_pot, &isError);
131 >          
132 >          if (isError != 0) {
133 >            sprintf( painCave.errMsg,
134 >                     "Fortran rejected newLJtype\n");
135 >            painCave.severity = OOPSE_ERROR;
136 >            painCave.isFatal = 1;
137 >            simError();          
138 >          }
139 >          
140 >        } else {
141 >          sprintf( painCave.errMsg,
142 >                   "Can not cast GenericData to LJParam\n");
143 >          painCave.severity = OOPSE_ERROR;
144 >          painCave.isFatal = 1;
145 >          simError();          
146 >        }            
147 >      } else {
148 >        sprintf( painCave.errMsg, "Can not find Parameters for LennardJones\n");
149 >        painCave.severity = OOPSE_ERROR;
150 >        painCave.isFatal = 1;
151 >        simError();          
152 >      }
153      }
154 <
155 <    if (isCharge()) {
156 <        data = getPropertyByName("Charge");
157 <        if (data != NULL) {
158 <            DoubleGenericData* doubleData= dynamic_cast<DoubleGenericData*>(data);
159 <
160 <            if (doubleData != NULL) {
161 <                double charge = doubleData->getData();
162 <                newChargeType(&atp.ident, &charge, &isError);
163 <
159 <                if (isError != 0) {
160 <                    sprintf( painCave.errMsg,
161 <                           "Fortran rejected newChargeType\n");
162 <                    painCave.severity = OOPSE_ERROR;
163 <                    painCave.isFatal = 1;
164 <                    simError();          
165 <                }
166 <            } else {
167 <                    sprintf( painCave.errMsg,
168 <                           "Can not cast GenericData to DoubleGenericData\n");
169 <                    painCave.severity = OOPSE_ERROR;
170 <                    painCave.isFatal = 1;
171 <                    simError();          
172 <            }
173 <        } else {
174 <            sprintf( painCave.errMsg, "Can not find Charge Parameters\n");
175 <            painCave.severity = OOPSE_ERROR;
176 <            painCave.isFatal = 1;
177 <            simError();          
178 <        }
154 >    
155 >    if (isElectrostatic()) {
156 >      newElectrostaticType(&atp, &isError);
157 >      if (isError != 0) {
158 >        sprintf( painCave.errMsg,
159 >                 "Fortran rejected newElectrostaticType\n");
160 >        painCave.severity = OOPSE_ERROR;
161 >        painCave.isFatal = 1;
162 >        simError();          
163 >      }
164      }
165 <
165 >    
166 >    if (isCharge()) {
167 >      data = getPropertyByName("Charge");
168 >      if (data != NULL) {
169 >        DoubleGenericData* doubleData= dynamic_cast<DoubleGenericData*>(data);
170 >        
171 >        if (doubleData != NULL) {
172 >          RealType charge = doubleData->getData();
173 >          setCharge(&atp.ident, &charge, &isError);
174 >          
175 >          if (isError != 0) {
176 >            sprintf( painCave.errMsg,
177 >                     "Fortran rejected setCharge\n");
178 >            painCave.severity = OOPSE_ERROR;
179 >            painCave.isFatal = 1;
180 >            simError();          
181 >          }
182 >        } else {
183 >          sprintf( painCave.errMsg,
184 >                   "Can not cast GenericData to DoubleGenericData\n");
185 >          painCave.severity = OOPSE_ERROR;
186 >          painCave.isFatal = 1;
187 >          simError();          
188 >        }
189 >      } else {
190 >        sprintf( painCave.errMsg, "Can not find Charge Parameters\n");
191 >        painCave.severity = OOPSE_ERROR;
192 >        painCave.isFatal = 1;
193 >        simError();          
194 >      }
195 >    }
196 >    
197      if (isEAM()) {
198 <        data = getPropertyByName("EAM");
199 <        if (data != NULL) {
200 <            EAMParamGenericData* eamData = dynamic_cast<EAMParamGenericData*>(data);
201 <
202 <            if (eamData != NULL) {
203 <
204 <                EAMParam eamParam = eamData->getData();
205 <                
206 <
207 <                newEAMtype(&eamParam.latticeConstant, &eamParam.nrho, &eamParam.drho,  &eamParam.nr, &eamParam.dr, &eamParam.rcut,
208 <                                &eamParam.rvals[0], &eamParam.rhovals[0], &eamParam.Frhovals[0], &atp.ident, &isError );
209 <
210 <                if (isError != 0) {
211 <                    sprintf( painCave.errMsg,
212 <                           "Fortran rejected newEAMtype\n");
213 <                    painCave.severity = OOPSE_ERROR;
214 <                    painCave.isFatal = 1;
215 <                    simError();          
216 <                }
217 <            } else {
218 <                    sprintf( painCave.errMsg,
219 <                           "Can not cast GenericData to EAMParam\n");
220 <                    painCave.severity = OOPSE_ERROR;
221 <                    painCave.isFatal = 1;
222 <                    simError();          
223 <            }
224 <        } else {
225 <            sprintf( painCave.errMsg, "Can not find EAM Parameters\n");
198 >      data = getPropertyByName("EAM");
199 >      if (data != NULL) {
200 >        EAMParamGenericData* eamData = dynamic_cast<EAMParamGenericData*>(data);
201 >        
202 >        if (eamData != NULL) {
203 >          
204 >          EAMParam eamParam = eamData->getData();
205 >          
206 >          
207 >          newEAMtype(&eamParam.latticeConstant, &eamParam.nrho,
208 >                     &eamParam.drho,  &eamParam.nr, &eamParam.dr,
209 >                     &eamParam.rcut, &eamParam.rvals[0], &eamParam.rhovals[0],
210 >                     &eamParam.Frhovals[0], &atp.ident, &isError );
211 >          
212 >          if (isError != 0) {
213 >            sprintf( painCave.errMsg,
214 >                     "Fortran rejected newEAMtype\n");
215 >            painCave.severity = OOPSE_ERROR;
216 >            painCave.isFatal = 1;
217 >            simError();          
218 >          }
219 >        } else {
220 >          sprintf( painCave.errMsg,
221 >                   "Can not cast GenericData to EAMParam\n");
222 >          painCave.severity = OOPSE_ERROR;
223 >          painCave.isFatal = 1;
224 >          simError();          
225 >        }
226 >      } else {
227 >        sprintf( painCave.errMsg, "Can not find EAM Parameters\n");
228 >        painCave.severity = OOPSE_ERROR;
229 >        painCave.isFatal = 1;
230 >        simError();          
231 >      }
232 >    }
233 >    
234 >    
235 >    if (isSC()) {
236 >      data = getPropertyByName("SC");
237 >      if (data != NULL) {
238 >        SCParamGenericData* SCData = dynamic_cast<SCParamGenericData*>(data);
239 >        
240 >        if (SCData != NULL) {
241 >          
242 >          SCParam scParam = SCData->getData();
243 >                    
244 >          newSCtype(&atp.ident, &scParam.c, &scParam.m,  
245 >                    &scParam.n, &scParam.alpha, &scParam.epsilon,
246 >                    &isError );
247 >          
248 >          if (isError != 0) {
249 >            sprintf( painCave.errMsg,
250 >                     "Fortran rejected newSCtype\n");
251              painCave.severity = OOPSE_ERROR;
252              painCave.isFatal = 1;
253              simError();          
254 +          }
255 +        } else {
256 +          sprintf( painCave.errMsg,
257 +                   "Can not cast GenericData to SCParam\n");
258 +          painCave.severity = OOPSE_ERROR;
259 +          painCave.isFatal = 1;
260 +          simError();          
261          }
262 +      } else {
263 +        sprintf( painCave.errMsg, "Can not find SC Parameters\n");
264 +        painCave.severity = OOPSE_ERROR;
265 +        painCave.isFatal = 1;
266 +        simError();          
267 +      }
268      }
269 +  }
270  
271 <    
217 < }
218 <
219 < void AtomType::addProperty(GenericData* genData) {
271 >  void AtomType::addProperty(GenericData* genData) {
272      properties_.addProperty(genData);  
273 < }
274 <
275 < void AtomType::removeProperty(const std::string& propName) {
273 >  }
274 >  
275 >  void AtomType::removeProperty(const std::string& propName) {
276      properties_.removeProperty(propName);  
277 < }
278 <
279 < void AtomType::clearProperties() {
277 >  }
278 >  
279 >  void AtomType::clearProperties() {
280      properties_.clearProperties();
281 < }
282 <
283 < std::vector<std::string> AtomType::getPropertyNames() {
281 >  }
282 >  
283 >  std::vector<std::string> AtomType::getPropertyNames() {
284      return properties_.getPropertyNames();  
285 < }
286 <      
287 < std::vector<GenericData*> AtomType::getProperties() {
285 >  }
286 >  
287 >  std::vector<GenericData*> AtomType::getProperties() {
288      return properties_.getProperties();
289 < }
290 <
291 < GenericData* AtomType::getPropertyByName(const std::string& propName) {
289 >  }
290 >  
291 >  GenericData* AtomType::getPropertyByName(const std::string& propName) {
292      return properties_.getPropertyByName(propName);
293 < }  
293 >  }  
294   }

Diff Legend

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