source: src/Parser/TremoloParser.cpp@ 35d171

Action_Thermostats Add_AtomRandomPerturbation Add_FitFragmentPartialChargesAction Add_RotateAroundBondAction Add_SelectAtomByNameAction Added_ParseSaveFragmentResults Adding_Graph_to_ChangeBondActions Adding_MD_integration_tests Adding_StructOpt_integration_tests Automaking_mpqc_open AutomationFragmentation_failures Candidate_v1.5.4 Candidate_v1.6.0 Candidate_v1.6.1 ChangeBugEmailaddress ChangingTestPorts ChemicalSpaceEvaluator CombiningParticlePotentialParsing Combining_Subpackages Debian_Package_split Debian_package_split_molecuildergui_only Disabling_MemDebug Docu_Python_wait EmpiricalPotential_contain_HomologyGraph EmpiricalPotential_contain_HomologyGraph_documentation Enable_parallel_make_install Enhance_userguide Enhanced_StructuralOptimization Enhanced_StructuralOptimization_continued Example_ManyWaysToTranslateAtom Exclude_Hydrogens_annealWithBondGraph FitPartialCharges_GlobalError Fix_ChargeSampling_PBC Fix_ChronosMutex Fix_FitPartialCharges Fix_FitPotential_needs_atomicnumbers Fix_ForceAnnealing Fix_IndependentFragmentGrids Fix_ParseParticles Fix_ParseParticles_split_forward_backward_Actions Fix_PopActions Fix_QtFragmentList_sorted_selection Fix_Restrictedkeyset_FragmentMolecule Fix_StatusMsg Fix_StepWorldTime_single_argument Fix_Verbose_Codepatterns Fix_fitting_potentials Fixes ForceAnnealing_goodresults ForceAnnealing_oldresults ForceAnnealing_tocheck ForceAnnealing_with_BondGraph ForceAnnealing_with_BondGraph_continued ForceAnnealing_with_BondGraph_continued_betteresults ForceAnnealing_with_BondGraph_contraction-expansion FragmentMolecule_checks_bonddegrees GeometryObjects Gui_Fixes Gui_displays_atomic_force_velocity IndependentFragmentGrids IndependentFragmentGrids_IndividualZeroInstances IndependentFragmentGrids_IntegrationTest IndependentFragmentGrids_Sole_NN_Calculation JobMarket_RobustOnKillsSegFaults JobMarket_StableWorkerPool JobMarket_unresolvable_hostname_fix ODR_violation_mpqc_open PartialCharges_OrthogonalSummation PythonUI_with_named_parameters QtGui_reactivate_TimeChanged_changes Recreated_GuiChecks RotateToPrincipalAxisSystem_UndoRedo SaturateAtoms_findBestMatching SaturateAtoms_singleDegree StoppableMakroAction Subpackage_CodePatterns Subpackage_JobMarket Subpackage_LinearAlgebra Subpackage_levmar Subpackage_mpqc_open Subpackage_vmg Switchable_LogView ThirdParty_MPQC_rebuilt_buildsystem TrajectoryDependenant_MaxOrder TremoloParser_IncreasedPrecision TremoloParser_MultipleTimesteps TremoloParser_setsAtomName Ubuntu_1604_changes stable
Last change on this file since 35d171 was 4795cd, checked in by Frederik Heber <heber@…>, 9 years ago

Extracted writeEntry() in TremoloParser::saveLine().

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