source: src/Parser/TremoloParser.cpp@ 4fc0ea

Candidate_v1.6.1 ChemicalSpaceEvaluator TremoloParser_IncreasedPrecision
Last change on this file since 4fc0ea was fba720, checked in by Frederik Heber <frederik.heber@…>, 7 years ago

Increased output precision in tremolo's data files to 10 digits.

  • this allows to safely use tremolo as writer for system states without loosing too much accuracy, i.e. w.r.t total energy, unlike others such as PDB.
  • TESTS: Marked many test as XFAIL because of changed tremolo output precision.
  • Property mode set to 100644
File size: 39.8 KB
RevLine 
[bcf653]1/*
2 * Project: MoleCuilder
3 * Description: creates and alters molecular systems
[0aa122]4 * Copyright (C) 2010-2012 University of Bonn. All rights reserved.
[5aaa43]5 * Copyright (C) 2013 Frederik Heber. All rights reserved.
[94d5ac6]6 *
7 *
8 * This file is part of MoleCuilder.
9 *
10 * MoleCuilder is free software: you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation, either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * MoleCuilder is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with MoleCuilder. If not, see <http://www.gnu.org/licenses/>.
[bcf653]22 */
23
[6bc51d]24/*
25 * TremoloParser.cpp
26 *
27 * Created on: Mar 2, 2010
28 * Author: metzler
29 */
30
[bf3817]31// include config.h
32#ifdef HAVE_CONFIG_H
33#include <config.h>
34#endif
35
[9eb71b3]36//#include "CodePatterns/MemDebug.hpp"
[112b09]37
[ad011c]38#include "CodePatterns/Assert.hpp"
39#include "CodePatterns/Log.hpp"
[4d4d33]40#include "CodePatterns/toString.hpp"
[ad011c]41#include "CodePatterns/Verbose.hpp"
[42127c]42
[9131f3]43#include "TremoloParser.hpp"
[42127c]44
[6f0841]45#include "Atom/atom.hpp"
[129204]46#include "Bond/bond.hpp"
[ccb487]47#include "Box.hpp"
[42127c]48#include "Descriptors/AtomIdDescriptor.hpp"
[3bdb6d]49#include "Element/element.hpp"
50#include "Element/periodentafel.hpp"
[ed8a68]51#include "Parser/Exceptions.hpp"
52#include "Potentials/Particles/ParticleRegistry.hpp"
[ccb487]53#include "LinearAlgebra/RealSpaceMatrix.hpp"
[740f9f]54#include "Potentials/Particles/ParticleRegistry.hpp"
[42127c]55#include "molecule.hpp"
56#include "World.hpp"
57#include "WorldTime.hpp"
58
[9131f3]59
[9f8b01]60#include <algorithm>
[05e2ed]61#include <boost/bind.hpp>
[4795cd]62#include <boost/function.hpp>
[ca331c]63#include <boost/lambda/lambda.hpp>
[2034f3]64#include <boost/lexical_cast.hpp>
[72d108]65#include <boost/tokenizer.hpp>
[74a444]66#include <iostream>
67#include <iomanip>
[8bf9c6]68#include <map>
69#include <sstream>
[ca331c]70#include <string>
[8bf9c6]71#include <vector>
[9131f3]72
[5a667d]73#include <boost/assign/list_of.hpp> // for 'map_list_of()'
74#include <boost/assert.hpp>
75
[765f16]76// declare specialized static variables
77const std::string FormatParserTrait<tremolo>::name = "tremolo";
78const std::string FormatParserTrait<tremolo>::suffix = "data";
79const ParserTypes FormatParserTrait<tremolo>::type = tremolo;
80
[5a667d]81// static instances
82std::map<std::string, TremoloKey::atomDataKey> FormatParser<tremolo>::knownKeys =
83 boost::assign::map_list_of("x",TremoloKey::x)
84 ("u",TremoloKey::u)
85 ("F",TremoloKey::F)
86 ("stress",TremoloKey::stress)
87 ("Id",TremoloKey::Id)
88 ("neighbors",TremoloKey::neighbors)
89 ("imprData",TremoloKey::imprData)
90 ("GroupMeasureTypeNo",TremoloKey::GroupMeasureTypeNo)
91 ("type",TremoloKey::type)
92 ("extType",TremoloKey::extType)
93 ("name",TremoloKey::name)
94 ("resName",TremoloKey::resName)
95 ("chainID",TremoloKey::chainID)
96 ("resSeq",TremoloKey::resSeq)
97 ("occupancy",TremoloKey::occupancy)
98 ("tempFactor",TremoloKey::tempFactor)
99 ("segID",TremoloKey::segID)
100 ("Charge",TremoloKey::Charge)
101 ("charge",TremoloKey::charge)
102 ("GrpTypeNo",TremoloKey::GrpTypeNo)
103 ("torsion",TremoloKey::torsion)
104 (" ",TremoloKey::noKey); // with this we can detect invalid keys
105
[9131f3]106/**
107 * Constructor.
108 */
[765f16]109FormatParser< tremolo >::FormatParser() :
[05e2ed]110 FormatParser_common(NULL),
111 idglobalizer(boost::bind(&FormatParser< tremolo >::getGlobalId, this, _1)),
112 idlocalizer(boost::bind(&FormatParser< tremolo >::getLocalId, this, _1))
[765f16]113{
[4d4d33]114 // invert knownKeys for debug output
115 for (std::map<std::string, TremoloKey::atomDataKey>::iterator iter = knownKeys.begin(); iter != knownKeys.end(); ++iter)
116 knownKeyNames.insert( make_pair( iter->second, iter->first) );
117
118 additionalAtomData.clear();
[9131f3]119}
120
[5a667d]121
[9131f3]122/**
123 * Destructor.
124 */
[765f16]125FormatParser< tremolo >::~FormatParser()
126{
[23fd43]127 usedFields_save.clear();
[b8d4a3]128 additionalAtomData.clear();
129}
130
131/**
132 * Loads atoms from a tremolo-formatted file.
133 *
134 * \param tremolo file
135 */
[765f16]136void FormatParser< tremolo >::load(istream* file) {
[8bf9c6]137 std::string line;
138 std::string::size_type location;
[b8d4a3]139
[c0e28c]140 // reset the id maps
141 resetIdAssociations();
142
[dc1d9e]143 molecule *newmol = World::getInstance().createMolecule();
[bd2390]144 newmol->ActiveFlag = true;
[220d2c]145 usedFields_t usedFields_temp;
146 size_t timestep = 0;
147 atom *addedatom = NULL;
[33af20]148 std::list<atom *> addedatoms;
149 std::list<atom *>::iterator atomiter = addedatoms.begin();
[b8d4a3]150 while (file->good()) {
151 std::getline(*file, line, '\n');
[23fd43]152 // we only parse in the first ATOMDATA line
[220d2c]153 location = line.find("ATOMDATA", 0);
154 if (location != string::npos) {
155 parseAtomDataKeysLine(line, location + 8, usedFields_temp);
156 if (usedFields_load.empty()) {
157 // first ATOMDATA: use this line
158 usedFields_load.insert(usedFields_load.end(), usedFields_temp.begin(), usedFields_temp.end());
159 LOG(3, "DEBUG: Local usedFields is: " << usedFields_load);
160 } else {
161 // following ATOMDATA: check against present
162 LOG(3, "DEBUG: Parsed check usedFields is: " << usedFields_temp);
163 if (usedFields_load != usedFields_temp) {
164 ELOG(1, "File contains multiple time steps with differing ATOMDATA line, parsing only first time step.");
165 break;
166 } else {
167 // update time step
168 ++timestep;
169 atomiter = addedatoms.begin();
170 }
171 }
172 usedFields_temp.clear();
173 } else {
174 if (line.length() > 0 && line.at(0) != '#') {
175 if (timestep != 0) {
176 ASSERT( atomiter != addedatoms.end(),
177 "FormatParser< tremolo >::load() - timesteps contains more atoms than first one.");
178 addedatom = *atomiter++;
179 }
180 readAtomDataLine(line, newmol, timestep, addedatom);
181 if (timestep == 0)
182 addedatoms.push_back(addedatom);
[b8d4a3]183 }
184 }
185 }
[220d2c]186 ASSERT( addedatoms.size() == newmol->size(),
187 "FormatParser< tremolo >::load() - number of atoms in mol and addedatoms differ.");
[2e352f]188
[9f8b01]189 // refresh atom::nr and atom::name
190 std::vector<atomId_t> atoms(newmol->getAtomCount());
191 std::transform(newmol->begin(), newmol->end(), atoms.begin(),
192 boost::bind(&atom::getId, _1));
193 processNeighborInformation(atoms);
[05e2ed]194 adaptImprData(atoms);
195 adaptTorsion(atoms);
[23fd43]196
197 // append usedFields to global usedFields, is made unique on save, clear after use
198 usedFields_save.insert(usedFields_save.end(), usedFields_load.begin(), usedFields_load.end());
199 usedFields_load.clear();
[b8d4a3]200}
201
202/**
[73916f]203 * Saves the \a atoms into as a tremolo file.
[b8d4a3]204 *
205 * \param file where to save the state
[73916f]206 * \param atoms atoms to store
[b8d4a3]207 */
[fac58f]208void FormatParser< tremolo >::save(
209 std::ostream* file,
210 const std::vector<const atom *> &AtomList) {
[830b3e]211 LOG(2, "DEBUG: Saving changes to tremolo.");
[e97a44]212
[23fd43]213 // install default usedFields if empty so far
214 if (usedFields_save.empty()) {
215 // default behavior: use all possible keys on output
216 for (std::map<std::string, TremoloKey::atomDataKey>::iterator iter = knownKeys.begin();
217 iter != knownKeys.end(); ++iter)
218 if (iter->second != TremoloKey::noKey) // don't add noKey
219 usedFields_save.push_back(iter->first);
220 }
221 // make present usedFields_save unique
222 makeUsedFieldsUnique(usedFields_save);
[a86cda]223 LOG(1, "INFO: Global (with unique entries) usedFields_save is: " << usedFields_save);
[23fd43]224
225 // distribute ids continuously
226 distributeContinuousIds(AtomList);
227
[33af20]228 std::pair<size_t, size_t> minmax_trajectories =
229 getMinMaxTrajectories(AtomList);
230 LOG(2, "INFO: There are " << minmax_trajectories.second << " steps to save.");
[23fd43]231
[33af20]232 for (size_t step = 0; (step < minmax_trajectories.second) || (step == 0); ++step) {
233 // store atomdata
234 save_AtomDataLine(file);
[b8d4a3]235
[33af20]236 // store box only on first step
237 if (step == 0)
238 save_BoxLine(file);
239
240 // store particles
241 for (std::vector<const atom*>::const_iterator atomIt = AtomList.begin();
242 atomIt != AtomList.end(); ++atomIt)
243 saveLine(file, *atomIt, step);
244 }
[23fd43]245}
[acd638]246
[5b0581]247struct usedFieldsWeakComparator
248{
249 /** Special comparator regards "neighbors=4" and "neighbors=2" as equal
250 *
251 * \note This one is used for making usedFields unique, i.e. throwing out the "smaller"
252 * neighbors.
253 */
254 bool operator()(const std::string &a, const std::string &b) const
255 {
256 // only compare up to first equality sign
257 return (a.substr(0, a.find_first_of('=')) == b.substr(0, b.find_first_of('=')));
258 }
259};
260
261struct usedFieldsSpecialOrderer
262{
263 /** Special string comparator that regards "neighbors=4" < "neighbors=2" as true and
264 * the other way round as false.
265 *
266 * Here, we implement the operator "\a < \b" in a special way to allow the
267 * above.
268 *
269 * \note This one is used for sorting usedFields in preparation for making it unique.
270 */
271 bool operator()(const std::string &a, const std::string &b) const
272 {
273 // only compare up to first equality sign
274 size_t a_equality = a.find_first_of('=');
275 size_t b_equality = b.find_first_of('=');
276 // if key before equality is not equal, return whether it is smaller or not
277 if (a.substr(0, a_equality) != b.substr(0, b_equality)) {
278 return a.substr(0, a_equality) < b.substr(0, b_equality);
279 } else { // now we know that the key before equality is the same in either string
280 // if one of them has no equality, the one with equality must go before
281 if ((a_equality != std::string::npos) && (b_equality == std::string::npos))
282 return true;
283 if ((a_equality == std::string::npos) && (b_equality != std::string::npos))
284 return false;
285 // if both don't have equality (and the token before is equal), it is not "<" but "=="
286 if ((a_equality == std::string::npos) && (b_equality == std::string::npos))
287 return false;
288 // if now both have equality sign, the larger value after it, must come first
289 return a.substr(a_equality, std::string::npos) > b.substr(b_equality, std::string::npos);
290 }
291 }
292};
293
[23fd43]294/** Helper function to make \given fields unique while preserving the order of first appearance.
295 *
296 * As std::unique only removes element if equal to predecessor, a vector is only
297 * made unique if sorted beforehand. But sorting would destroy order of first
298 * appearance, hence we do the sorting on a temporary field and add the unique
299 * elements in the order as in \a fields.
300 *
301 * @param fields usedFields to make unique while preserving order of appearance
302 */
[27cfde]303void FormatParser< tremolo >::makeUsedFieldsUnique(usedFields_t &fields) const
[23fd43]304{
305 // std::unique only removes if predecessor is equal, not over whole range, hence do it manually
[27cfde]306 usedFields_t temp_fields(fields);
[5b0581]307 usedFieldsSpecialOrderer SpecialOrderer;
308 usedFieldsWeakComparator WeakComparator;
309 std::sort(temp_fields.begin(), temp_fields.end(), SpecialOrderer);
[23fd43]310 usedFields_t::iterator it =
[5b0581]311 std::unique(temp_fields.begin(), temp_fields.end(), WeakComparator);
[23fd43]312 temp_fields.erase(it, temp_fields.end());
[27cfde]313 usedFields_t usedfields(fields);
314 fields.clear();
315 fields.reserve(temp_fields.size());
[23fd43]316 // now go through each usedFields entry, check if in temp_fields and remove there on first occurence
317 for (usedFields_t::const_iterator iter = usedfields.begin();
318 iter != usedfields.end(); ++iter) {
319 usedFields_t::iterator uniqueiter =
320 std::find(temp_fields.begin(), temp_fields.end(), *iter);
321 if (uniqueiter != temp_fields.end()) {
[27cfde]322 fields.push_back(*iter);
[23fd43]323 // add only once to ATOMDATA
324 temp_fields.erase(uniqueiter);
325 }
326 }
327 ASSERT( temp_fields.empty(),
328 "FormatParser< tremolo >::save() - still unique entries left in temp_fields after unique?");
329}
330
331
332/** Resets and distributes the indices continuously.
333 *
334 * \param atoms atoms to store
335 */
[fac58f]336void FormatParser< tremolo >::distributeContinuousIds(
337 const std::vector<const atom *> &AtomList)
[23fd43]338{
[812155]339 resetIdAssociations();
340 atomId_t lastid = 0;
[fac58f]341 for (std::vector<const atom*>::const_iterator atomIt = AtomList.begin();
[23fd43]342 atomIt != AtomList.end(); ++atomIt)
[812155]343 associateLocaltoGlobalId(++lastid, (*atomIt)->getId());
[23fd43]344}
[812155]345
[23fd43]346/** Store Atomdata line to \a file.
347 *
348 * @param file output stream
349 */
350void FormatParser< tremolo >::save_AtomDataLine(std::ostream* file) const
351{
[b8d4a3]352 *file << "# ATOMDATA";
[23fd43]353 for (usedFields_t::const_iterator it=usedFields_save.begin();
354 it != usedFields_save.end(); ++it)
[b8d4a3]355 *file << "\t" << *it;
[23fd43]356 *file << std::endl;
357}
[ccb487]358
[23fd43]359/** Store Box info to \a file
360 *
361 * @param file output stream
362 */
363void FormatParser< tremolo >::save_BoxLine(std::ostream* file) const
364{
[ccb487]365 *file << "# Box";
366 const RealSpaceMatrix &M = World::getInstance().getDomain().getM();
367 for (size_t i=0; i<NDIM;++i)
368 for (size_t j=0; j<NDIM;++j)
369 *file << "\t" << M.at(i,j);
370 *file << std::endl;
[b8d4a3]371}
372
[6bc86c]373/** Add default info, when new atom is added to World.
374 *
375 * @param id of atom
376 */
[765f16]377void FormatParser< tremolo >::AtomInserted(atomId_t id)
[6bc86c]378{
[8bf9c6]379 std::map<const atomId_t, TremoloAtomInfoContainer>::iterator iter = additionalAtomData.find(id);
[6bc86c]380 ASSERT(iter == additionalAtomData.end(),
[765f16]381 "FormatParser< tremolo >::AtomInserted() - additionalAtomData already present for newly added atom "
[6bc86c]382 +toString(id)+".");
383 // don't add entry, as this gives a default resSeq of 0 not the molecule id
384 // additionalAtomData.insert( std::make_pair(id, TremoloAtomInfoContainer()) );
385}
386
387/** Remove additional AtomData info, when atom has been removed from World.
388 *
389 * @param id of atom
390 */
[765f16]391void FormatParser< tremolo >::AtomRemoved(atomId_t id)
[6bc86c]392{
[8bf9c6]393 std::map<const atomId_t, TremoloAtomInfoContainer>::iterator iter = additionalAtomData.find(id);
[6bc86c]394 // as we do not insert AtomData on AtomInserted, we cannot be assured of its presence
395// ASSERT(iter != additionalAtomData.end(),
[765f16]396// "FormatParser< tremolo >::AtomRemoved() - additionalAtomData is not present for atom "
[6bc86c]397// +toString(id)+" to remove.");
398 if (iter != additionalAtomData.end())
399 additionalAtomData.erase(iter);
400}
401
[4795cd]402template <class T>
403T NoOp(const atom * const)
404{
405 return T();
406}
407
408template <class T>
409void writeEntryFromAdditionalAtomData_ifpresent(
410 std::map<const atomId_t, TremoloAtomInfoContainer> &_additionalAtomData,
411 std::map<TremoloKey::atomDataKey, std::string> &_knownKeyNames,
412 std::ostream* _file,
413 const atom * const _currentAtom,
414 const TremoloKey::atomDataKey _currentField,
415 const typename boost::function<T (const atom * const)> _getter)
416{
417 if (_additionalAtomData.count(_currentAtom->getId())) {
418 LOG(3, "Writing for type " << _knownKeyNames[_currentField] << ": "
419 << _additionalAtomData[_currentAtom->getId()].get(_currentField));
420 *_file << _additionalAtomData[_currentAtom->getId()].get(_currentField);
421 } else if (_additionalAtomData.count(_currentAtom->GetTrueFather()->getId())) {
422 LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " stuff from father: "
423 << _additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField));
424 *_file << _additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField);
425 } else {
426 LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " its default value: "
427 << _getter(_currentAtom));
428 *_file << _getter(_currentAtom);
429 }
430 *_file << "\t";
431}
432
433template <class T>
434void writeAdditionalAtomDataEntry(
435 std::map<const atomId_t, TremoloAtomInfoContainer> &_additionalAtomData,
436 std::map<TremoloKey::atomDataKey, std::string> &_knownKeyNames,
437 TremoloAtomInfoContainer &_defaultAdditionalData,
438 std::ostream* _file,
439 const atom * const _currentAtom,
440 const TremoloKey::atomDataKey _currentField)
441{
442 if (_additionalAtomData.count(_currentAtom->getId())) {
443 LOG(3, "Writing for type " << _knownKeyNames[_currentField] << ": "
444 << _additionalAtomData[_currentAtom->getId()].get(_currentField));
445 *_file << _additionalAtomData[_currentAtom->getId()].get(_currentField);
446 } else if (_additionalAtomData.count(_currentAtom->GetTrueFather()->getId())) {
447 LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " stuff from father: "
448 << _additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField));
449 *_file << _additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField);
450 } else {
451 LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " its default value: "
452 << _defaultAdditionalData.get(_currentField));
453 *_file << _defaultAdditionalData.get(_currentField);
454 }
455 *_file << "\t";
456}
457
458template <class T>
459void writeEntryFromAdditionalAtomData_ifnotempty(
460 std::map<const atomId_t, TremoloAtomInfoContainer> &_additionalAtomData,
461 std::map<TremoloKey::atomDataKey, std::string> &_knownKeyNames,
462 TremoloAtomInfoContainer &_defaultAdditionalData,
463 std::ostream* _file,
464 const atom * const _currentAtom,
465 const TremoloKey::atomDataKey _currentField,
466 const typename boost::function<T (const atom * const)> _getter)
467{
468 if (_additionalAtomData.count(_currentAtom->getId())) {
469 if (_additionalAtomData[_currentAtom->getId()].get(_currentField) != "-") {
470 LOG(3, "Writing for type " << _knownKeyNames[_currentField] << ": "
471 << _additionalAtomData[_currentAtom->getId()].get(_currentField));
472 *_file << _additionalAtomData[_currentAtom->getId()].get(_currentField);
473 } else {
474 LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " default value: "
475 << _getter(_currentAtom));
476 *_file << _getter(_currentAtom);
477 }
478 } else if (_additionalAtomData.count(_currentAtom->GetTrueFather()->getId())) {
479 if (_additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField) != "-") {
480 LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " stuff from father: "
481 << _additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField));
482 *_file << _additionalAtomData[_currentAtom->GetTrueFather()->getId()].get(_currentField);
483 } else {
484 LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " default value from father: "
485 << _getter(_currentAtom->GetTrueFather()));
486 *_file << _getter(_currentAtom->GetTrueFather());
487 }
488 } else {
489 LOG(3, "Writing for type " << _knownKeyNames[_currentField] << " its default value: "
490 << _getter(_currentAtom));
491 *_file << _getter(_currentAtom);
492 }
493 *_file << "\t";
494}
495
[b8d4a3]496/**
497 * Writes one line of tremolo-formatted data to the provided stream.
498 *
499 * \param stream where to write the line to
500 * \param reference to the atom of which information should be written
501 */
[fac58f]502void FormatParser< tremolo >::saveLine(
503 std::ostream* file,
[33af20]504 const atom * const currentAtom,
505 const size_t _timestep)
[23fd43]506{
[b8d4a3]507 TremoloKey::atomDataKey currentField;
508
[33af20]509 LOG(4, "INFO: Saving atom " << *currentAtom << ", its father id is "
510 << currentAtom->GetTrueFather()->getId() << " at time step " << _timestep);
[4d4d33]511
[fba720]512 // note down default precision
513 std::streamsize defaultprecision=file->precision();
514 std::streamsize highprecision=10;
515
[23fd43]516 for (usedFields_t::iterator it = usedFields_save.begin(); it != usedFields_save.end(); it++) {
[b8d4a3]517 currentField = knownKeys[it->substr(0, it->find("="))];
518 switch (currentField) {
519 case TremoloKey::x :
520 // for the moment, assume there are always three dimensions
[33af20]521 LOG(3, "Writing for type " << knownKeyNames[currentField] << ": " << currentAtom->getPositionAtStep(_timestep));
[fba720]522 file->precision(highprecision);
[33af20]523 *file << currentAtom->atStep(0, _timestep) << "\t";
524 *file << currentAtom->atStep(1, _timestep) << "\t";
525 *file << currentAtom->atStep(2, _timestep) << "\t";
[fba720]526 file->precision(defaultprecision);
[b8d4a3]527 break;
528 case TremoloKey::u :
529 // for the moment, assume there are always three dimensions
[33af20]530 LOG(3, "Writing for type " << knownKeyNames[currentField] << ": " << currentAtom->getAtomicVelocityAtStep(_timestep));
[fba720]531 file->precision(highprecision);
[33af20]532 *file << currentAtom->getAtomicVelocityAtStep(_timestep)[0] << "\t";
533 *file << currentAtom->getAtomicVelocityAtStep(_timestep)[1] << "\t";
534 *file << currentAtom->getAtomicVelocityAtStep(_timestep)[2] << "\t";
[fba720]535 file->precision(defaultprecision);
[b8d4a3]536 break;
[e6e4a0]537 case TremoloKey::F :
538 // for the moment, assume there are always three dimensions
[33af20]539 LOG(3, "Writing for type " << knownKeyNames[currentField] << ": " << currentAtom->getAtomicForceAtStep(_timestep));
[fba720]540 file->precision(highprecision);
[33af20]541 *file << currentAtom->getAtomicForceAtStep(_timestep)[0] << "\t";
542 *file << currentAtom->getAtomicForceAtStep(_timestep)[1] << "\t";
543 *file << currentAtom->getAtomicForceAtStep(_timestep)[2] << "\t";
[fba720]544 file->precision(defaultprecision);
[e6e4a0]545 break;
[305e7e]546 case TremoloKey::type :
[4795cd]547 writeEntryFromAdditionalAtomData_ifnotempty<std::string>(
548 additionalAtomData,
549 knownKeyNames,
550 defaultAdditionalData,
551 file,
552 currentAtom,
553 currentField,
554 boost::bind(&element::getSymbol, boost::bind(&AtomInfo::getType, _1)));
[b8d4a3]555 break;
556 case TremoloKey::Id :
[47d041]557 LOG(3, "Writing for type " << knownKeyNames[currentField] << ": " << currentAtom->getId()+1);
[812155]558 *file << getLocalId(currentAtom->getId()) << "\t";
[b8d4a3]559 break;
560 case TremoloKey::neighbors :
[47d041]561 LOG(3, "Writing type " << knownKeyNames[currentField]);
[b8d4a3]562 writeNeighbors(file, atoi(it->substr(it->find("=") + 1, 1).c_str()), currentAtom);
563 break;
[05e2ed]564 case TremoloKey::imprData :
565 case TremoloKey::torsion :
566 LOG(3, "Writing type " << knownKeyNames[currentField]);
567 *file << adaptIdDependentDataString(
568 additionalAtomData[currentAtom->getId()].get(currentField),
569 idlocalizer)
570 << "\t";
571 break;
[74a444]572 case TremoloKey::resSeq :
[4d4d33]573 if (additionalAtomData.count(currentAtom->getId())) {
[47d041]574 LOG(3, "Writing for type " << knownKeyNames[currentField] << ": " << additionalAtomData[currentAtom->getId()].get(currentField));
[74a444]575 *file << additionalAtomData[currentAtom->getId()].get(currentField);
576 } else if (currentAtom->getMolecule() != NULL) {
[47d041]577 LOG(3, "Writing for type " << knownKeyNames[currentField] << " its own id: " << currentAtom->getMolecule()->getId()+1);
[67ab71]578 *file << setw(4) << currentAtom->getMolecule()->getId();
[74a444]579 } else {
[47d041]580 LOG(3, "Writing for type " << knownKeyNames[currentField] << " default value: " << defaultAdditionalData.get(currentField));
[74a444]581 *file << defaultAdditionalData.get(currentField);
582 }
583 *file << "\t";
[4d4d33]584 break;
[2034f3]585 case TremoloKey::charge :
586 if (currentAtom->getCharge() == 0.) {
[4795cd]587 writeEntryFromAdditionalAtomData_ifpresent<double>(
588 additionalAtomData,
589 knownKeyNames,
590 file,
591 currentAtom,
592 currentField,
593 boost::bind(&AtomInfo::getCharge, _1));
[2034f3]594 } else {
595 LOG(3, "Writing for type " << knownKeyNames[currentField] << " AtomInfo::charge : " << currentAtom->getCharge());
[4795cd]596 *file << currentAtom->getCharge() << "\t";
[2034f3]597 }
598 break;
[b8d4a3]599 default :
[4795cd]600 writeAdditionalAtomDataEntry<std::string>(
601 additionalAtomData,
602 knownKeyNames,
603 defaultAdditionalData,
604 file,
605 currentAtom,
606 currentField);
[b8d4a3]607 break;
608 }
609 }
610
[23fd43]611 *file << std::endl;
[b8d4a3]612}
613
614/**
615 * Writes the neighbor information of one atom to the provided stream.
616 *
[9d83b6]617 * Note that ListOfBonds of WorldTime::CurrentTime is used.
618 *
[b8d4a3]619 * \param stream where to write neighbor information to
620 * \param number of neighbors
621 * \param reference to the atom of which to take the neighbor information
622 */
[fac58f]623void FormatParser< tremolo >::writeNeighbors(
624 std::ostream* file,
625 const int numberOfNeighbors,
626 const atom * const currentAtom) {
[9d83b6]627 const BondList& ListOfBonds = currentAtom->getListOfBonds();
[ca2cfa]628 // sort bonded indices
629 typedef std::set<atomId_t> sortedIndices;
630 sortedIndices sortedBonds;
631 for (BondList::const_iterator iter = ListOfBonds.begin();
632 iter != ListOfBonds.end(); ++iter)
[812155]633 sortedBonds.insert(getLocalId((*iter)->GetOtherAtom(currentAtom)->getId()));
[ca2cfa]634 // print indices
635 sortedIndices::const_iterator currentBond = sortedBonds.begin();
[b8d4a3]636 for (int i = 0; i < numberOfNeighbors; i++) {
[812155]637 *file << (currentBond != sortedBonds.end() ? (*currentBond) : 0) << "\t";
[ca2cfa]638 if (currentBond != sortedBonds.end())
[0bbfa1]639 ++currentBond;
[b8d4a3]640 }
[9131f3]641}
642
643/**
[23fd43]644 * Stores keys from the ATOMDATA line in \a fields.
[9131f3]645 *
646 * \param line to parse the keys from
[23fd43]647 * \param offset with which offset the keys begin within the line
648 * \param fields which usedFields to use
[9131f3]649 */
[23fd43]650void FormatParser< tremolo >::parseAtomDataKeysLine(
651 const std::string &line,
652 const int offset,
653 usedFields_t &fields) {
[8bf9c6]654 std::string keyword;
655 std::stringstream lineStream;
[9131f3]656
657 lineStream << line.substr(offset);
[a86cda]658 lineStream >> ws;
[9131f3]659 while (lineStream.good()) {
660 lineStream >> keyword;
[b8d4a3]661 if (knownKeys[keyword.substr(0, keyword.find("="))] == TremoloKey::noKey) {
[ecb799]662 // TODO: throw exception about unknown key
[5a667d]663 cout << "Unknown key: " << keyword.substr(0, keyword.find("=")) << " is not part of the tremolo format specification." << endl;
664 throw IllegalParserKeyException();
[4415da]665 break;
666 }
[23fd43]667 fields.push_back(keyword);
[a86cda]668 lineStream >> ws;
[9131f3]669 }
[a86cda]670 LOG(2, "INFO: " << fields);
[9131f3]671}
672
[5a667d]673/**
674 * Tests whether the keys from the ATOMDATA line can be read correctly.
675 *
676 * \param line to parse the keys from
677 */
678bool FormatParser< tremolo >::testParseAtomDataKeysLine(
679 const std::string &line) {
680 std::string keyword;
681 std::stringstream lineStream;
682
683 // check string after ATOMDATA
684 const std::string AtomData("ATOMDATA");
685 const size_t AtomDataOffset = line.find(AtomData, 0);
686 if (AtomDataOffset == std::string::npos)
687 lineStream << line;
688 else
689 lineStream << line.substr(AtomDataOffset + AtomData.length());
690 while (lineStream.good()) {
691 lineStream >> keyword;
692 //LOG(2, "DEBUG: Checking key " << keyword.substr(0, keyword.find("=")) << ".");
693 if (knownKeys[keyword.substr(0, keyword.find("="))] == TremoloKey::noKey)
694 return false;
695 }
696 //LOG(1, "INFO: " << fields);
697 return true;
698}
699
[ca331c]700std::string FormatParser< tremolo >::getAtomData() const
701{
702 std::stringstream output;
703 std::for_each(usedFields_save.begin(), usedFields_save.end(),
704 output << boost::lambda::_1 << " ");
705 const std::string returnstring(output.str());
706 return returnstring.substr(0, returnstring.find_last_of(" "));
707}
708
709/** Appends the properties per atom to print to .data file by parsing line from
710 * \a atomdata_string.
711 *
712 * We just call \sa FormatParser< tremolo >::parseAtomDataKeysLine().
713 *
714 * @param atomdata_string line to parse with space-separated values
715 */
716void FormatParser< tremolo >::setAtomData(const std::string &atomdata_string)
717{
718 parseAtomDataKeysLine(atomdata_string, 0, usedFields_save);
719}
720
[81c980b]721/** Sets the properties per atom to print to .data file by parsing line from
722 * \a atomdata_string.
723 *
[23fd43]724 * We just call \sa FormatParser< tremolo >::parseAtomDataKeysLine(), however
725 * we clear FormatParser< tremolo >::usedFields_save.
[81c980b]726 *
727 * @param atomdata_string line to parse with space-separated values
728 */
[ca331c]729void FormatParser< tremolo >::resetAtomData(const std::string &atomdata_string)
[81c980b]730{
[23fd43]731 usedFields_save.clear();
732 parseAtomDataKeysLine(atomdata_string, 0, usedFields_save);
[81c980b]733}
734
735
[9131f3]736/**
737 * Reads one data line of a tremolo file and interprets it according to the keys
738 * obtained from the ATOMDATA line.
739 *
740 * \param line to parse as an atom
[dc1d9e]741 * \param *newmol molecule to add atom to
[220d2c]742 * \param _timestep time step to parse to
743 * \param _addedatom ref to added atom
[9131f3]744 */
[220d2c]745void FormatParser< tremolo >::readAtomDataLine(
746 const std::string &line,
747 molecule *newmol,
748 const size_t _timestep,
749 atom *&_addedatoms)
750{
[8bf9c6]751 std::stringstream lineStream;
[220d2c]752 atom* newAtom = NULL;
753 atomId_t atomid = -1;
754 if (_timestep == 0) {
755 newAtom = World::getInstance().createAtom();
756 _addedatoms = newAtom;
757 atomid = newAtom->getId();
758 additionalAtomData[atomid] = TremoloAtomInfoContainer(); // fill with default values
759 } else {
760 newAtom = _addedatoms;
761 atomid = newAtom->getId();
762 }
[89a31d]763 TremoloAtomInfoContainer *atomInfo = &additionalAtomData[atomid];
[b8d4a3]764 TremoloKey::atomDataKey currentField;
[72d108]765 ConvertTo<double> toDouble;
766 ConvertTo<int> toInt;
[056e70]767 Vector tempVector;
[740f9f]768 const ParticleRegistry& registry = ParticleRegistry::getConstInstance();
769 const periodentafel& periode = *World::getInstance().getPeriode();
[72d108]770
771 // setup tokenizer, splitting up white-spaced entries
772 typedef boost::tokenizer<boost::char_separator<char> >
773 tokenizer;
774 boost::char_separator<char> whitespacesep(" \t");
775 tokenizer tokens(line, whitespacesep);
776 ASSERT(tokens.begin() != tokens.end(),
[765f16]777 "FormatParser< tremolo >::readAtomDataLine - empty string, need at least ' '!");
[fc41df]778 tokenizer::const_iterator tok_iter = tokens.begin();
[72d108]779 // then associate each token to each file
[fc41df]780 for (usedFields_t::const_iterator it = usedFields_load.begin(); it != usedFields_load.end(); it++) {
[72d108]781 const std::string keyName = it->substr(0, it->find("="));
782 currentField = knownKeys[keyName];
[fc41df]783 ASSERT(tok_iter != tokens.end(),
784 "FormatParser< tremolo >::readAtomDataLine - too few entries in line '"+line+"'!");
785 const std::string &word = *tok_iter;
[47d041]786 LOG(4, "INFO: Parsing key " << keyName << " with remaining data " << word);
[4415da]787 switch (currentField) {
[b8d4a3]788 case TremoloKey::x :
[4415da]789 // for the moment, assume there are always three dimensions
[d74077]790 for (int i=0;i<NDIM;i++) {
[765f16]791 ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for x["+toString(i)+"]!");
[220d2c]792 LOG(4, "INFO: Parsing key " << keyName << " with next token " << word << " on step " << _timestep);
793 newAtom->setAtStep(i, _timestep, toDouble(word));
[72d108]794 tok_iter++;
[d74077]795 }
[4415da]796 break;
[b8d4a3]797 case TremoloKey::u :
[4415da]798 // for the moment, assume there are always three dimensions
[72d108]799 for (int i=0;i<NDIM;i++) {
[765f16]800 ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for u["+toString(i)+"]!");
[220d2c]801 LOG(4, "INFO: Parsing key " << keyName << " with next token " << word << " on step " << _timestep);
[fc41df]802 tempVector[i] = toDouble(word);
[72d108]803 tok_iter++;
804 }
[220d2c]805 newAtom->setAtomicVelocityAtStep(_timestep, tempVector);
[4415da]806 break;
[e6e4a0]807 case TremoloKey::F :
808 // for the moment, assume there are always three dimensions
809 for (int i=0;i<NDIM;i++) {
810 ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for F["+toString(i)+"]!");
[220d2c]811 LOG(4, "INFO: Parsing key " << keyName << " with next token " << word << " on step " << _timestep);
[fc41df]812 tempVector[i] = toDouble(word);
[e6e4a0]813 tok_iter++;
814 }
[220d2c]815 newAtom->setAtomicForceAtStep(_timestep, tempVector);
[e6e4a0]816 break;
[305e7e]817 case TremoloKey::type :
[4d4d33]818 {
[765f16]819 ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
[220d2c]820 LOG(4, "INFO: Parsing key " << keyName << " with next token " << word << " on step " << _timestep);
[740f9f]821 std::string elementname;
822 const element * elem = NULL;
823 if (!registry.isPresentByName(word)) {
824 std::string lowercase_word(word);
825 std::transform(word.begin()+1, word.end(), lowercase_word.begin()+1, ::tolower);
826 elem = periode.FindElement(lowercase_word);
827 if (elem == NULL) {
828 // clean up
829 World::getInstance().destroyAtom(newAtom);
830 // give an error
831 ELOG(0, "TremoloParser: tokens " << word << "/" << lowercase_word
832 << " is unknown to neither ParticleRegistry nor Periodentafel.");
833 return;
834 } else {
835 elementname = elem->getSymbol();
836 }
837 } else {
838 const Particle * const p = registry.getByName(word);
839 elementname = p->getElement();
840 elem = periode.FindElement(elementname);
[a275b3]841 }
[4d4d33]842 // put type name into container for later use
[fc41df]843 atomInfo->set(currentField, word);
[740f9f]844 LOG(4, "INFO: Parsing element " << (word) << " as " << elementname << " according to KnownTypes.");
[72d108]845 tok_iter++;
[740f9f]846 newAtom->setType(elem);
[b8d4a3]847 ASSERT(newAtom->getType(), "Type was not set for this atom");
[4415da]848 break;
[4d4d33]849 }
[b8d4a3]850 case TremoloKey::Id :
[765f16]851 ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
[220d2c]852 LOG(4, "INFO: Parsing key " << keyName << " with next token " << word << " on step " << _timestep);
853 if (_timestep == 0) {
854 associateLocaltoGlobalId(toInt(word), atomid);
855 } else {
856 // check association is the same
857 ASSERT( (atomId_t)getGlobalId(toInt(word)) == atomid,
858 "FormatParser< tremolo >::readAtomDataLine() - differing global id "+toString(atomid)
859 +" on timestep "+toString(_timestep));
860 ASSERT( getLocalId(atomid) == toInt(word),
861 "FormatParser< tremolo >::readAtomDataLine() - differing local id "+toString(toInt(word))
862 +" on timestep "+toString(_timestep));
863 }
[72d108]864 tok_iter++;
[4415da]865 break;
[b8d4a3]866 case TremoloKey::neighbors :
[72d108]867 for (int i=0;i<atoi(it->substr(it->find("=") + 1, 1).c_str());i++) {
[220d2c]868 ASSERT(tok_iter != tokens.end(),
869 "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
870 if (_timestep == 0)
871 LOG(4, "INFO: Parsing key " << keyName << " with next token " << word << " on step " << _timestep);
[fc41df]872 lineStream << word << "\t";
[72d108]873 tok_iter++;
874 }
[220d2c]875 if (_timestep == 0) {
876 readNeighbors(&lineStream,
877 atoi(it->substr(it->find("=") + 1, 1).c_str()), atomid);
878 }
[9131f3]879 break;
[2034f3]880 case TremoloKey::charge :
881 ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
[220d2c]882 if (_timestep == 0) {
883 LOG(4, "INFO: Parsing key " << keyName << " with next token " << word << " on step " << _timestep);
884 atomInfo->set(currentField, word);
885 newAtom->setCharge(boost::lexical_cast<double>(word));
886 }
[2034f3]887 tok_iter++;
888 break;
[9131f3]889 default :
[765f16]890 ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
[220d2c]891 if (_timestep == 0) {
892 LOG(4, "INFO: Parsing key " << keyName << " with next token " << word << " on step " << _timestep);
893 atomInfo->set(currentField, word);
894 }
[72d108]895 tok_iter++;
[9131f3]896 break;
897 }
898 }
[89a31d]899 LOG(3, "INFO: Parsed atom " << atomid << ".");
900 if (newmol != NULL)
[dc1d9e]901 newmol->AddAtom(newAtom);
[6bc51d]902}
[9131f3]903
[99db9b]904bool FormatParser< tremolo >::saveAtomsInExttypes(
905 std::ostream &output,
906 const std::vector<const atom*> &atoms,
907 const int id) const
[531f27]908{
909 bool status = true;
910 // parse the file
[99db9b]911 for (std::vector<const atom *>::const_iterator iter = atoms.begin();
[531f27]912 iter != atoms.end(); ++iter) {
913 const int atomicid = getLocalId((*iter)->getId());
914 if (atomicid == -1)
915 status = false;
916 output << atomicid << "\t" << id << std::endl;
917 }
918
919 return status;
920}
921
[b8d4a3]922/**
923 * Reads neighbor information for one atom from the input.
924 *
[0bbfa1]925 * \param line stream where to read the information from
926 * \param numberOfNeighbors number of neighbors to read
927 * \param atomid world id of the atom the information belongs to
[b8d4a3]928 */
[fac58f]929void FormatParser< tremolo >::readNeighbors(
930 std::stringstream* line,
931 const int numberOfNeighbors,
932 const int atomId) {
[b8d4a3]933 int neighborId = 0;
934 for (int i = 0; i < numberOfNeighbors; i++) {
935 *line >> neighborId;
936 // 0 is used to fill empty neighbor positions in the tremolo file.
937 if (neighborId > 0) {
[47d041]938 LOG(4, "INFO: Atom with global id " << atomId
939 << " has neighbour with serial " << neighborId);
[b8d4a3]940 additionalAtomData[atomId].neighbors.push_back(neighborId);
941 }
942 }
943}
[9131f3]944
945/**
[23fd43]946 * Checks whether the provided name is within \a fields.
[b8d4a3]947 *
[23fd43]948 * \param fields which usedFields to use
949 * \param fieldName name to check
[b8d4a3]950 * \return true if the field name is used
[9131f3]951 */
[fac58f]952bool FormatParser< tremolo >::isUsedField(
953 const usedFields_t &fields,
954 const std::string &fieldName) const
[23fd43]955{
[b8d4a3]956 bool fieldNameExists = false;
[23fd43]957 for (usedFields_t::const_iterator usedField = fields.begin();
958 usedField != fields.end(); usedField++) {
[b8d4a3]959 if (usedField->substr(0, usedField->find("=")) == fieldName)
960 fieldNameExists = true;
961 }
[9131f3]962
[b8d4a3]963 return fieldNameExists;
964}
965
966
967/**
968 * Adds the collected neighbor information to the atoms in the world. The atoms
969 * are found by their current ID and mapped to the corresponding atoms with the
970 * Id found in the parsed file.
[9f8b01]971 *
972 * @param atoms vector with all newly added (global) atomic ids
[b8d4a3]973 */
[fac58f]974void FormatParser< tremolo >::processNeighborInformation(
975 const std::vector<atomId_t> &atoms) {
[23fd43]976 if (!isUsedField(usedFields_load, "neighbors")) {
[b8d4a3]977 return;
978 }
979
[9f8b01]980 for (std::vector<atomId_t>::const_iterator iter = atoms.begin(); iter != atoms.end(); ++iter) {
981 ASSERT(additionalAtomData.count(*iter) != 0,
982 "FormatParser< tremolo >::processNeighborInformation() - global id "
983 +toString(*iter)+" unknown in additionalAtomData.");
984 TremoloAtomInfoContainer &currentInfo = additionalAtomData[*iter];
985 ASSERT (!currentInfo.neighbors_processed,
986 "FormatParser< tremolo >::processNeighborInformation() - neighbors of new atom "
987 +toString(*iter)+" are already processed.");
988 for(std::vector<int>::const_iterator neighbor = currentInfo.neighbors.begin();
989 neighbor != currentInfo.neighbors.end(); neighbor++
990 ) {
991 LOG(3, "INFO: Creating bond between ("
992 << *iter
993 << ") and ("
994 << getGlobalId(*neighbor) << "|" << *neighbor << ")");
995 ASSERT(getGlobalId(*neighbor) != -1,
996 "FormatParser< tremolo >::processNeighborInformation() - global id to local id "
997 +toString(*neighbor)+" is unknown.");
998 World::getInstance().getAtom(AtomById(*iter))
999 ->addBond(WorldTime::getTime(), World::getInstance().getAtom(AtomById(getGlobalId(*neighbor))));
[9131f3]1000 }
[9f8b01]1001 currentInfo.neighbors_processed = true;
[9131f3]1002 }
[6bc51d]1003}
1004
[9131f3]1005/**
[b8d4a3]1006 * Replaces atom IDs read from the file by the corresponding world IDs. All IDs
1007 * IDs of the input string will be replaced; expected separating characters are
1008 * "-" and ",".
[9131f3]1009 *
[b8d4a3]1010 * \param string in which atom IDs should be adapted
[05e2ed]1011 * \param idgetter function pointer to change the id
[b8d4a3]1012 *
1013 * \return input string with modified atom IDs
[9131f3]1014 */
[05e2ed]1015std::string FormatParser< tremolo >::adaptIdDependentDataString(
1016 const std::string &data,
1017 const boost::function<int (const int)> &idgetter
1018 ) {
[b8d4a3]1019 // there might be no IDs
1020 if (data == "-") {
1021 return "-";
1022 }
1023
1024 char separator;
1025 int id;
[8bf9c6]1026 std::stringstream line, result;
[b8d4a3]1027 line << data;
1028
1029 line >> id;
[05e2ed]1030 result << idgetter(id);
[b8d4a3]1031 while (line.good()) {
1032 line >> separator >> id;
[05e2ed]1033 result << separator << idgetter(id);
[b8d4a3]1034 }
1035
1036 return result.str();
[6bc51d]1037}
[b8d4a3]1038
[05e2ed]1039/** Corrects the atom IDs in each imprData entry to the corresponding world IDs
[b8d4a3]1040 * as they might differ from the originally read IDs.
[05e2ed]1041 *
1042 * \param atoms currently parsed in atoms
[b8d4a3]1043 */
[05e2ed]1044void FormatParser< tremolo >::adaptImprData(const std::vector<atomId_t> &atoms) {
[23fd43]1045 if (!isUsedField(usedFields_load, "imprData")) {
[b8d4a3]1046 return;
1047 }
1048
[05e2ed]1049 for (std::vector<atomId_t>::const_iterator iter = atoms.begin(); iter != atoms.end(); ++iter) {
1050 ASSERT(additionalAtomData.count(*iter) != 0,
1051 "FormatParser< tremolo >::processNeighborInformation() - global id "
1052 +toString(*iter)+" unknown in additionalAtomData.");
1053 TremoloAtomInfoContainer &currentInfo = additionalAtomData[*iter];
1054 currentInfo.imprData = adaptIdDependentDataString(currentInfo.imprData, idglobalizer);
[b8d4a3]1055 }
[6bc51d]1056}
[4415da]1057
[05e2ed]1058/** Corrects the atom IDs in each torsion entry to the corresponding world IDs
[b8d4a3]1059 * as they might differ from the originally read IDs.
[05e2ed]1060 *
1061 * \param atoms currently parsed in atoms
[b8d4a3]1062 */
[05e2ed]1063void FormatParser< tremolo >::adaptTorsion(const std::vector<atomId_t> &atoms) {
[23fd43]1064 if (!isUsedField(usedFields_load, "torsion")) {
[b8d4a3]1065 return;
1066 }
1067
[05e2ed]1068 for (std::vector<atomId_t>::const_iterator iter = atoms.begin(); iter != atoms.end(); ++iter) {
1069 ASSERT(additionalAtomData.count(*iter) != 0,
1070 "FormatParser< tremolo >::processNeighborInformation() - global id "
1071 +toString(*iter)+" unknown in additionalAtomData.");
1072 TremoloAtomInfoContainer &currentInfo = additionalAtomData[*iter];
1073 currentInfo.torsion = adaptIdDependentDataString(currentInfo.torsion, idglobalizer);
[b8d4a3]1074 }
1075}
1076
Note: See TracBrowser for help on using the repository browser.