# | Line 45 | Line 45 | |
---|---|---|
45 | #include <string> | |
46 | ||
47 | #include "io/Globals.hpp" | |
48 | + | #include "io/ParamConstraint.hpp" |
49 | + | #include "utils/MemoryUtils.hpp" |
50 | #include "utils/simError.h" | |
49 | – | #ifdef IS_MPI |
50 | – | #include "io/mpiBASS.h" |
51 | – | #endif // is_mpi |
51 | ||
52 | < | |
53 | < | #define DefineParameter(NAME,KEYWORD) \ |
55 | < | NAME.setKeyword(KEYWORD); \ |
56 | < | parameters_.insert(std::make_pair(std::string(KEYWORD), &NAME)); |
57 | < | |
58 | < | #define DefineOptionalParameter(NAME,KEYWORD) \ |
59 | < | NAME.setKeyword(KEYWORD); NAME.setOptional(true); \ |
60 | < | parameters_.insert(std::make_pair(std::string(KEYWORD), &NAME)); |
61 | < | |
62 | < | #define DefineOptionalParameterWithDefaultValue(NAME,KEYWORD, DEFAULTVALUE) \ |
63 | < | NAME.setKeyword(KEYWORD); NAME.setOptional(true); NAME.setDefaultValue(DEFAULTVALUE); \ |
64 | < | parameters_.insert(std::make_pair(std::string(KEYWORD), &NAME)); |
65 | < | |
66 | < | Globals::Globals(){ |
67 | < | |
52 | > | namespace oopse { |
53 | > | Globals::Globals() { |
54 | DefineParameter(ForceField, "forceField") | |
69 | – | DefineParameter(NComponents, "nComponents") |
55 | ||
56 | DefineOptionalParameter(TargetTemp, "targetTemp"); | |
57 | DefineOptionalParameter(Ensemble, "ensemble"); | |
58 | DefineOptionalParameter(Dt, "dt"); | |
59 | DefineOptionalParameter(RunTime, "runTime"); | |
75 | – | DefineOptionalParameter(InitialConfig, "initialConfig"); |
60 | DefineOptionalParameter(FinalConfig, "finalConfig"); | |
77 | – | DefineOptionalParameter(NMol, "nMol"); |
78 | – | DefineOptionalParameter(Density, "density"); |
79 | – | DefineOptionalParameter(Box, "box"); |
80 | – | DefineOptionalParameter(BoxX, "boxX"); |
81 | – | DefineOptionalParameter(BoxY, "boxY"); |
82 | – | DefineOptionalParameter(BoxZ, "boxZ"); |
61 | DefineOptionalParameter(SampleTime, "sampleTime"); | |
62 | DefineOptionalParameter(ResetTime, "resetTime"); | |
63 | DefineOptionalParameter(StatusTime, "statusTime"); | |
64 | DefineOptionalParameter(CutoffRadius, "cutoffRadius"); | |
65 | DefineOptionalParameter(SwitchingRadius, "switchingRadius"); | |
88 | – | DefineOptionalParameter(Dielectric, "dielectric"); |
66 | DefineOptionalParameter(TempSet, "tempSet"); | |
67 | DefineOptionalParameter(ThermalTime, "thermalTime"); | |
68 | < | DefineOptionalParameter(TargetPressure, "targetPressure"); |
68 | > | DefineOptionalParameter(TargetPressure, "targetPressure"); |
69 | DefineOptionalParameter(TauThermostat, "tauThermostat"); | |
70 | DefineOptionalParameter(TauBarostat, "tauBarostat"); | |
71 | DefineOptionalParameter(ZconsTime, "zconsTime"); | |
95 | – | DefineOptionalParameter(NZconstraints, "nZconstraints"); |
72 | DefineOptionalParameter(ZconsTol, "zconsTol"); | |
73 | DefineOptionalParameter(ZconsForcePolicy, "zconsForcePolicy"); | |
74 | DefineOptionalParameter(Seed, "seed"); | |
# | Line 111 | Line 87 | Globals::Globals(){ | |
87 | DefineOptionalParameter(ThermodynamicIntegrationK, "thermodynamicIntegrationK"); | |
88 | DefineOptionalParameter(ForceFieldVariant, "forceFieldVariant"); | |
89 | DefineOptionalParameter(ForceFieldFileName, "forceFieldFileName"); | |
90 | + | DefineOptionalParameter(DampingAlpha, "dampingAlpha"); |
91 | DefineOptionalParameter(ThermIntDistSpringConst, "thermIntDistSpringConst"); | |
92 | DefineOptionalParameter(ThermIntThetaSpringConst, "thermIntThetaSpringConst"); | |
93 | DefineOptionalParameter(ThermIntOmegaSpringConst, "thermIntOmegaSpringConst"); | |
94 | DefineOptionalParameter(SurfaceTension, "surfaceTension"); | |
95 | DefineOptionalParameter(PrintPressureTensor, "printPressureTensor"); | |
96 | < | DefineOptionalParameter(ElectrostaticSummationMethod, "electrostaticSummationMethod"); |
96 | > | DefineOptionalParameter(TaggedAtomPair, "taggedAtomPair"); |
97 | > | DefineOptionalParameter(PrintTaggedPairDistance, "printTaggedPairDistance"); |
98 | DefineOptionalParameter(CutoffPolicy, "cutoffPolicy"); | |
99 | < | DefineOptionalParameter(StatFileFormat, "statFileFormat"); |
99 | > | DefineOptionalParameter(SwitchingFunctionType, "switchingFunctionType"); |
100 | > | DefineOptionalParameter(HydroPropFile, "HydroPropFile"); |
101 | > | DefineOptionalParameter(Viscosity, "viscosity"); |
102 | > | DefineOptionalParameter(BeadSize, "beadSize"); |
103 | > | DefineOptionalParameter(FrozenBufferRadius, "frozenBufferRadius"); |
104 | > | DefineOptionalParameter(LangevinBufferRadius, "langevinBufferRadius"); |
105 | > | DefineOptionalParameter(NeighborListNeighbors,"NeighborListNeighbors"); |
106 | > | DefineOptionalParameter(UseMultipleTemperatureMethod, "useMultipleTemperatureMethod"); |
107 | > | DefineOptionalParameter(MTM_Ce, "MTM_Ce"); |
108 | > | DefineOptionalParameter(MTM_G, "MTM_G"); |
109 | > | DefineOptionalParameter(MTM_Io, "MTM_Io"); |
110 | > | DefineOptionalParameter(MTM_Sigma, "MTM_Sigma"); |
111 | > | DefineOptionalParameter(MTM_R, "MTM_R"); |
112 | ||
113 | < | DefineOptionalParameterWithDefaultValue(MixingRule, "mixingRule", "standard"); |
113 | > | |
114 | > | |
115 | DefineOptionalParameterWithDefaultValue(UsePeriodicBoundaryConditions, "usePeriodicBoundaryConditions", true); | |
116 | + | DefineOptionalParameterWithDefaultValue(UseAtomicVirial, "useAtomicVirial", true); |
117 | DefineOptionalParameterWithDefaultValue(UseInitalTime, "useInitialTime", false); | |
118 | DefineOptionalParameterWithDefaultValue(UseIntialExtendedSystemState, "useInitialExtendedSystemState", false); | |
119 | DefineOptionalParameterWithDefaultValue(OrthoBoxTolerance, "orthoBoxTolerance", 1E-6); | |
120 | DefineOptionalParameterWithDefaultValue(UseSolidThermInt, "useSolidThermInt", false); | |
121 | DefineOptionalParameterWithDefaultValue(UseLiquidThermInt, "useLiquidThermInt", false); | |
122 | < | DefineOptionalParameterWithDefaultValue(DampingAlpha, "dampingAlpha", 1.5); |
122 | > | DefineOptionalParameterWithDefaultValue(ThermIntDistSpringConst, "thermIntDistSpringConst", 6.0); |
123 | > | DefineOptionalParameterWithDefaultValue(ThermIntThetaSpringConst, "thermIntThetaSpringConst", 7.5); |
124 | > | DefineOptionalParameterWithDefaultValue(ThermIntOmegaSpringConst, "thermIntOmegaSpringConst", 13.5); |
125 | > | DefineOptionalParameterWithDefaultValue(ElectrostaticSummationMethod, "electrostaticSummationMethod", "SHIFTED_FORCE"); |
126 | > | DefineOptionalParameterWithDefaultValue(ElectrostaticScreeningMethod, "electrostaticScreeningMethod", "DAMPED"); |
127 | > | DefineOptionalParameterWithDefaultValue(Dielectric, "dielectric", 78.5); |
128 | DefineOptionalParameterWithDefaultValue(CompressDumpFile, "compressDumpFile", 0); | |
129 | + | DefineOptionalParameterWithDefaultValue(OutputForceVector, "outputForceVector", 0); |
130 | DefineOptionalParameterWithDefaultValue(SkinThickness, "skinThickness", 1.0); | |
131 | < | |
132 | < | } |
131 | > | DefineOptionalParameterWithDefaultValue(StatFileFormat, "statFileFormat", "TIME|TOTAL_ENERGY|POTENTIAL_ENERGY|KINETIC_ENERGY|TEMPERATURE|PRESSURE|VOLUME|CONSERVED_QUANTITY"); |
132 | > | DefineOptionalParameterWithDefaultValue(UseSphericalBoundaryConditions, "useSphericalBoundaryConditions", false); |
133 | > | DefineOptionalParameterWithDefaultValue(AccumulateBoxDipole, "accumulateBoxDipole", false); |
134 | ||
135 | < | int Globals::globalAssign( event* the_event ){ |
135 | > | DefineOptionalParameterWithDefaultValue(UseRNEMD, "useRNEMD", false); |
136 | > | DefineOptionalParameterWithDefaultValue(RNEMD_swapTime, "RNEMD_swapTime", 100.0); |
137 | > | DefineOptionalParameterWithDefaultValue(RNEMD_nBins, "RNEMD_nBins", 15); |
138 | > | DefineOptionalParameterWithDefaultValue(RNEMD_swapType, "RNEMD_swapType", "Kinetic"); |
139 | > | DefineOptionalParameterWithDefaultValue(RNEMD_objectSelection, "RNEMD_objectSelection", "select all"); |
140 | ||
138 | – | int key; |
139 | – | int token; |
140 | – | interface_assign_type the_type = the_event->evt.asmt.asmt_type; |
141 | – | char* lhs = the_event->evt.asmt.lhs; |
142 | – | std::string keyword(lhs); |
141 | ||
142 | < | bool result; |
143 | < | |
144 | < | |
147 | < | ParamMap::iterator i =parameters_.find(keyword); |
148 | < | if (i != parameters_.end()) { |
149 | < | if( the_type == STRING ){ |
150 | < | result = i->second->setData(std::string(the_event->evt.asmt.rhs.sval)); |
151 | < | if (!result ) { |
152 | < | sprintf(the_event->err_msg, "Error in parsing meta-data file!\n\t%s must be a string.\n", keyword.c_str() ); |
153 | < | } |
154 | < | } else if( the_type == DOUBLE ){ |
155 | < | result = i->second->setData(the_event->evt.asmt.rhs.dval); |
156 | < | if (!result ) |
157 | < | sprintf(the_event->err_msg, "Error in parsing meta-data file!\n\t%s must be a double.\n", keyword.c_str() ); |
158 | < | } |
159 | < | else if (the_type == INT ){ |
160 | < | result = i->second->setData(the_event->evt.asmt.rhs.ival); |
161 | < | if (!result ) |
162 | < | sprintf(the_event->err_msg, "Error in parsing meta-data file!\n\t%s must be an int.\n", keyword.c_str() ); |
163 | < | |
164 | < | } else { |
142 | > | deprecatedKeywords_.insert("nComponents"); |
143 | > | deprecatedKeywords_.insert("nZconstraints"); |
144 | > | deprecatedKeywords_.insert("initialConfig"); |
145 | ||
166 | – | } |
167 | – | } |
168 | – | |
169 | – | if (keyword == "nComponents" && getNComponents() > 0) { |
170 | – | components = new Component*[getNComponents()]; |
171 | – | }else if (keyword == "nZconstraints" && getNZconstraints() > 0) { |
172 | – | zConstraints = new ZconStamp*[getNZconstraints()]; |
173 | – | } |
174 | – | |
175 | – | return result; |
146 | } | |
147 | ||
148 | < | int Globals::newComponent( event* the_event ){ |
149 | < | |
150 | < | current_component = new Component; |
181 | < | int index = the_event->evt.blk_index; |
182 | < | char err[200]; |
183 | < | |
184 | < | if( haveNComponents() && index < getNComponents() ) |
185 | < | components[index] = current_component; |
186 | < | else{ |
187 | < | if( haveNComponents() ){ |
188 | < | sprintf( err, "meta-data parsing error: %d out of nComponents range", |
189 | < | index ); |
190 | < | the_event->err_msg = strdup( err ); |
191 | < | return 0; |
192 | < | } |
193 | < | else{ |
194 | < | the_event->err_msg = strdup("meta-data parsing error: nComponents not given before" |
195 | < | " first component declaration." ); |
196 | < | return 0; |
197 | < | } |
198 | < | } |
199 | < | |
200 | < | return 1; |
201 | < | } |
202 | < | |
203 | < | |
204 | < | |
205 | < | int Globals::componentAssign( event* the_event ){ |
206 | < | |
207 | < | switch( the_event->evt.asmt.asmt_type ){ |
208 | < | |
209 | < | case STRING: |
210 | < | return current_component->assignString( the_event->evt.asmt.lhs, |
211 | < | the_event->evt.asmt.rhs.sval, |
212 | < | &(the_event->err_msg)); |
213 | < | break; |
214 | < | |
215 | < | case DOUBLE: |
216 | < | return current_component->assignDouble( the_event->evt.asmt.lhs, |
217 | < | the_event->evt.asmt.rhs.dval, |
218 | < | &(the_event->err_msg)); |
219 | < | break; |
220 | < | |
221 | < | case INT: |
222 | < | return current_component->assignInt( the_event->evt.asmt.lhs, |
223 | < | the_event->evt.asmt.rhs.ival, |
224 | < | &(the_event->err_msg)); |
225 | < | break; |
226 | < | |
227 | < | default: |
228 | < | the_event->err_msg = strdup( "Globals error. Invalid component" |
229 | < | " assignment type" ); |
230 | < | return 0; |
231 | < | break; |
232 | < | } |
233 | < | return 0; |
234 | < | } |
235 | < | |
236 | < | int Globals::componentEnd( event* the_event ){ |
237 | < | |
238 | < | the_event->err_msg = current_component->checkMe(); |
239 | < | if( the_event->err_msg != NULL ) return 0; |
240 | < | |
241 | < | return 1; |
148 | > | Globals::~Globals() { |
149 | > | MemoryUtils::deletePointers(components_); |
150 | > | MemoryUtils::deletePointers(zconstraints_); |
151 | } | |
152 | ||
153 | < | int Globals::newZconstraint( event* the_event ){ |
154 | < | |
153 | > | void Globals::validate() { |
154 | > | DataHolder::validate(); |
155 | ||
156 | < | int index = the_event->evt.blk_index; |
157 | < | char err[200]; |
158 | < | current_zConstraint = new ZconStamp( index ); |
159 | < | |
160 | < | if( haveNZconstraints() && index < getNZconstraints() ) |
161 | < | zConstraints[index] = current_zConstraint; |
162 | < | else{ |
163 | < | if( haveNZconstraints() ){ |
164 | < | sprintf( err, "meta-data parsing error: %d out of nZconstraints range", |
165 | < | index ); |
166 | < | the_event->err_msg = strdup( err ); |
167 | < | return 0; |
168 | < | } |
169 | < | else{ |
170 | < | the_event->err_msg = strdup("meta-data parsing error: nZconstraints" |
171 | < | " not given before" |
172 | < | " first zConstraint declaration." ); |
173 | < | return 0; |
174 | < | } |
175 | < | } |
156 | > | CheckParameter(ForceField, isNotEmpty()); |
157 | > | CheckParameter(TargetTemp, isPositive()); |
158 | > | CheckParameter(Ensemble, isEqualIgnoreCase("NVE") || isEqualIgnoreCase("NVT") || isEqualIgnoreCase("NPTi") || isEqualIgnoreCase("NPTf") || isEqualIgnoreCase("NPTxyz") || isEqualIgnoreCase("NPAT") || isEqualIgnoreCase("LANGEVINDYNAMICS") || isEqualIgnoreCase("LD") || isEqualIgnoreCase("NPRT") || isEqualIgnoreCase("NPGT") || isEqualIgnoreCase("NGammaT") || isEqualIgnoreCase("NGT") || isEqualIgnoreCase("SMIPD")); |
159 | > | CheckParameter(Dt, isPositive()); |
160 | > | CheckParameter(RunTime, isPositive()); |
161 | > | CheckParameter(FinalConfig, isNotEmpty()); |
162 | > | CheckParameter(SampleTime, isNonNegative()); |
163 | > | CheckParameter(ResetTime, isNonNegative()); |
164 | > | CheckParameter(StatusTime, isNonNegative()); |
165 | > | CheckParameter(CutoffRadius, isPositive()); |
166 | > | CheckParameter(SwitchingRadius, isNonNegative()); |
167 | > | CheckParameter(Dielectric, isPositive()); |
168 | > | CheckParameter(ThermalTime, isNonNegative()); |
169 | > | CheckParameter(TauThermostat, isPositive()); |
170 | > | CheckParameter(TauBarostat, isPositive()); |
171 | > | CheckParameter(ZconsTime, isPositive()); |
172 | > | CheckParameter(ZconsTol, isPositive()); |
173 | > | CheckParameter(Seed, isPositive()); |
174 | > | CheckParameter(Minimizer, isEqualIgnoreCase("SD") || isEqualIgnoreCase("CG")); |
175 | > | CheckParameter(MinimizerMaxIter, isPositive()); |
176 | > | CheckParameter(MinimizerWriteFrq, isPositive()); |
177 | > | CheckParameter(MinimizerStepSize, isPositive()); |
178 | > | CheckParameter(MinimizerFTol, isPositive()); |
179 | > | CheckParameter(MinimizerGTol, isPositive()); |
180 | > | CheckParameter(MinimizerLSTol, isPositive()); |
181 | > | CheckParameter(MinimizerLSMaxIter, isPositive()); |
182 | > | CheckParameter(ZconsGap, isPositive()); |
183 | > | CheckParameter(ZconsFixtime, isPositive()); |
184 | > | CheckParameter(ThermodynamicIntegrationLambda, isNonNegative()); |
185 | > | CheckParameter(ThermodynamicIntegrationK, isPositive()); |
186 | > | CheckParameter(ForceFieldVariant, isNotEmpty()); |
187 | > | CheckParameter(ForceFieldFileName, isNotEmpty()); |
188 | > | CheckParameter(ThermIntDistSpringConst, isPositive()); |
189 | > | CheckParameter(ThermIntThetaSpringConst, isPositive()); |
190 | > | CheckParameter(ThermIntOmegaSpringConst, isPositive()); |
191 | > | CheckParameter(ElectrostaticSummationMethod, isEqualIgnoreCase("NONE") || isEqualIgnoreCase("SHIFTED_POTENTIAL") || isEqualIgnoreCase("SHIFTED_FORCE") || isEqualIgnoreCase("REACTION_FIELD")); |
192 | > | CheckParameter(ElectrostaticScreeningMethod, isEqualIgnoreCase("UNDAMPED") || isEqualIgnoreCase("DAMPED")); |
193 | > | CheckParameter(CutoffPolicy, isEqualIgnoreCase("MIX") || isEqualIgnoreCase("MAX") || isEqualIgnoreCase("TRADITIONAL")); |
194 | > | CheckParameter(SwitchingFunctionType, isEqualIgnoreCase("CUBIC") || isEqualIgnoreCase("FIFTH_ORDER_POLYNOMIAL")); |
195 | > | //CheckParameter(StatFileFormat,); |
196 | > | CheckParameter(OrthoBoxTolerance, isPositive()); |
197 | > | CheckParameter(ThermIntDistSpringConst, isPositive()); |
198 | > | CheckParameter(ThermIntThetaSpringConst, isPositive()); |
199 | > | CheckParameter(ThermIntOmegaSpringConst, isPositive()); |
200 | > | CheckParameter(DampingAlpha,isNonNegative()); |
201 | > | CheckParameter(SkinThickness, isPositive()); |
202 | > | CheckParameter(Viscosity, isNonNegative()); |
203 | > | CheckParameter(BeadSize, isPositive()); |
204 | > | CheckParameter(FrozenBufferRadius, isPositive()); |
205 | > | CheckParameter(LangevinBufferRadius, isPositive()); |
206 | > | CheckParameter(NeighborListNeighbors, isPositive()); |
207 | > | CheckParameter(RNEMD_swapTime, isPositive()); |
208 | > | CheckParameter(RNEMD_nBins, isPositive()); |
209 | > | CheckParameter(RNEMD_swapType, isEqualIgnoreCase("Kinetic") || isEqualIgnoreCase("Px") || isEqualIgnoreCase("Py") || isEqualIgnoreCase("Pz")); |
210 | ||
211 | < | return 1; |
211 | > | for(std::vector<Component*>::iterator i = components_.begin(); i != components_.end(); ++i) { |
212 | > | if (!(*i)->findMoleculeStamp(moleculeStamps_)) { |
213 | > | std::ostringstream oss; |
214 | > | oss << "Globals Error: can not find molecule stamp for component " << (*i)->getType() << std::endl; |
215 | > | throw OOPSEException(oss.str()); |
216 | > | } |
217 | > | } |
218 | } | |
270 | – | |
271 | – | |
272 | – | |
273 | – | int Globals::zConstraintAssign( event* the_event ){ |
274 | – | |
275 | – | switch( the_event->evt.asmt.asmt_type ){ |
219 | ||
220 | < | case STRING: |
221 | < | return current_zConstraint->assignString( the_event->evt.asmt.lhs, |
222 | < | the_event->evt.asmt.rhs.sval, |
280 | < | &(the_event->err_msg)); |
281 | < | break; |
282 | < | |
283 | < | case DOUBLE: |
284 | < | return current_zConstraint->assignDouble( the_event->evt.asmt.lhs, |
285 | < | the_event->evt.asmt.rhs.dval, |
286 | < | &(the_event->err_msg)); |
287 | < | break; |
288 | < | |
289 | < | case INT: |
290 | < | return current_zConstraint->assignInt( the_event->evt.asmt.lhs, |
291 | < | the_event->evt.asmt.rhs.ival, |
292 | < | &(the_event->err_msg)); |
293 | < | break; |
294 | < | |
295 | < | default: |
296 | < | the_event->err_msg = strdup( "Globals error. Invalid zConstraint" |
297 | < | " assignment type" ); |
298 | < | return 0; |
299 | < | break; |
300 | < | } |
301 | < | return 0; |
220 | > | bool Globals::addComponent(Component* comp) { |
221 | > | components_.push_back(comp); |
222 | > | return true; |
223 | } | |
224 | ||
225 | < | int Globals::zConstraintEnd( event* the_event ){ |
226 | < | |
227 | < | the_event->err_msg = current_zConstraint->checkMe(); |
307 | < | if( the_event->err_msg != NULL ) return 0; |
308 | < | |
309 | < | return 1; |
225 | > | bool Globals::addZConsStamp(ZConsStamp* zcons) { |
226 | > | zconstraints_.push_back(zcons); |
227 | > | return true; |
228 | } | |
229 | ||
230 | < | char* Globals::checkMe( void ){ |
231 | < | |
232 | < | |
233 | < | std::string err("The following required keywords are missing:\n"); |
234 | < | short int have_err = 0; |
235 | < | |
236 | < | ParamMap::iterator i; |
237 | < | for (i = parameters_.begin(); i != parameters_.end(); ++i) { |
238 | < | if (!i->second->isOptional() && i->second->empty()) { |
239 | < | err += i->second->getKeyword() + "\n"; |
230 | > | bool Globals::addMoleculeStamp(MoleculeStamp* molStamp) { |
231 | > | std::string molStampName = molStamp->getName(); |
232 | > | std::map<std::string, MoleculeStamp*>::iterator i; |
233 | > | bool ret = false; |
234 | > | i = moleculeStamps_.find(molStampName); |
235 | > | if (i == moleculeStamps_.end()) { |
236 | > | moleculeStamps_.insert(std::map<std::string, MoleculeStamp*>::value_type(molStampName, molStamp)); |
237 | > | ret = true; |
238 | > | } else { |
239 | > | std::ostringstream oss; |
240 | > | oss << "Globals Error: Molecule Stamp " << molStamp->getName() << "appears multiple times\n"; |
241 | > | throw OOPSEException(oss.str()); |
242 | } | |
243 | < | } |
324 | < | |
325 | < | //@todo memory leak |
326 | < | if( have_err ) |
327 | < | return strdup( err.c_str() ); |
328 | < | |
329 | < | return NULL; |
330 | < | |
331 | < | |
243 | > | return ret; |
244 | } | |
245 | + | |
246 | ||
334 | – | int Globals::globalEnd( event* the_event ){ |
335 | – | |
336 | – | the_event->err_msg = checkMe(); |
337 | – | if( the_event->err_msg != NULL ) return 0; |
338 | – | |
339 | – | return 1; |
247 | } |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |