source: src/World.hpp@ ac5c36

Action_Thermostats Add_AtomRandomPerturbation Add_FitFragmentPartialChargesAction Add_RotateAroundBondAction Add_SelectAtomByNameAction Added_ParseSaveFragmentResults AddingActions_SaveParseParticleParameters Adding_Graph_to_ChangeBondActions Adding_MD_integration_tests Adding_ParticleName_to_Atom Adding_StructOpt_integration_tests AtomFragments 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_BoundInBox_CenterInBox_MoleculeActions 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 FragmentAction_writes_AtomFragments FragmentMolecule_checks_bonddegrees GeometryObjects Gui_Fixes Gui_displays_atomic_force_velocity ImplicitCharges IndependentFragmentGrids IndependentFragmentGrids_IndividualZeroInstances IndependentFragmentGrids_IntegrationTest IndependentFragmentGrids_Sole_NN_Calculation JobMarket_RobustOnKillsSegFaults JobMarket_StableWorkerPool JobMarket_unresolvable_hostname_fix MoreRobust_FragmentAutomation ODR_violation_mpqc_open PartialCharges_OrthogonalSummation PdbParser_setsAtomName PythonUI_with_named_parameters QtGui_reactivate_TimeChanged_changes Recreated_GuiChecks Rewrite_FitPartialCharges 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 ac5c36 was ac5c36, checked in by Frederik Heber <heber@…>, 13 years ago

FIX: Forgot to remove now unused idpool functions, were replaced by IdPool.

  • Property mode set to 100644
File size: 15.3 KB
Line 
1/*
2 * World.hpp
3 *
4 * Created on: Feb 3, 2010
5 * Author: crueger
6 */
7
8#ifndef WORLD_HPP_
9#define WORLD_HPP_
10
11// include config.h
12#ifdef HAVE_CONFIG_H
13#include <config.h>
14#endif
15
16/*********************************************** includes ***********************************/
17
18#include <string>
19#include <map>
20#include <vector>
21#include <set>
22#include <boost/thread.hpp>
23#include <boost/shared_ptr.hpp>
24
25#include "Actions/ActionTrait.hpp"
26#include "Atom/AtomSet.hpp"
27#include "Descriptors/SelectiveIterator.hpp"
28#include "CodePatterns/Observer/Observable.hpp"
29#include "CodePatterns/Observer/Observer.hpp"
30#include "CodePatterns/Cacheable.hpp"
31#include "CodePatterns/Singleton.hpp"
32#include "CodePatterns/Observer/ObservedContainer.hpp"
33#include "CodePatterns/Range.hpp"
34#include "IdPool_policy.hpp"
35#include "IdPool.hpp"
36#include "LinkedCell/LinkedCell_View.hpp"
37#include "types.hpp"
38
39
40// forward declarations
41class atom;
42class AtomDescriptor;
43class AtomDescriptor_impl;
44class BondGraph;
45class Box;
46class config;
47class RealSpaceMatrix;
48class molecule;
49class MoleculeDescriptor;
50class MoleculeDescriptor_impl;
51class MoleculeListClass;
52class periodentafel;
53class ThermoStatContainer;
54
55namespace LinkedCell {
56 class LinkedCell_Controller;
57}
58
59namespace MoleCuilder {
60 class ManipulateAtomsProcess;
61 template<typename T> class AtomsCalculation;
62}
63
64/****************************************** forward declarations *****************************/
65
66/********************************************** Class World *******************************/
67
68namespace detail {
69 template <class T> const T* lastChanged()
70 {
71 ASSERT(0, "detail::lastChanged() - only specializations may be used.");
72 return NULL;
73 }
74}
75
76class World : public Singleton<World>, public Observable
77{
78
79// Make access to constructor and destructor possible from inside the singleton
80friend class Singleton<World>;
81
82// necessary for coupling with descriptors
83friend class AtomDescriptor_impl;
84friend class AtomDescriptor;
85friend class MoleculeDescriptor_impl;
86friend class MoleculeDescriptor;
87// coupling with descriptors over selection
88friend class AtomSelectionDescriptor_impl;
89friend class MoleculeSelectionDescriptor_impl;
90
91// Actions, calculations etc associated with the World
92friend class MoleCuilder::ManipulateAtomsProcess;
93template<typename> friend class MoleCuilder::AtomsCalculation;
94public:
95 // some typedefs for the CONSTRUCT_... macros (no "," allows in a single parameter name)
96 typedef std::map<atomId_t,atom*> AtomSTLSet;
97 typedef std::map<moleculeId_t,molecule*> MoleculeSTLSet;
98
99 // Types for Atom and Molecule structures
100 typedef ObservedContainer< AtomSTLSet > AtomSet;
101 typedef ObservedContainer< MoleculeSTLSet > MoleculeSet;
102
103 typedef ATOMSET(std::vector) AtomComposite;
104
105 /******* Notifications *******/
106
107 //!> enumeration of present notification types
108 enum NotificationType {
109 AtomInserted,
110 AtomRemoved,
111 AtomPositionChanged,
112 AtomChanged,
113 MoleculeInserted,
114 MoleculeRemoved,
115 MoleculeChanged,
116 NotificationType_MAX
117 };
118
119 //>! access to last changed element (atom or molecule)
120 template <class T> const T* lastChanged() const
121 { return detail::lastChanged<T>(); }
122
123 /***** getter and setter *****/
124 // reference to pointer is used for legacy reason... reference will be removed latter to keep encapsulation of World object
125 /**
126 * returns the periodentafel for the world.
127 */
128 periodentafel *&getPeriode();
129
130 /** Returns the BondGraph for the World.
131 *
132 * @return reference to BondGraph
133 */
134 BondGraph *&getBondGraph();
135
136 /** Sets the World's BondGraph.
137 *
138 * @param _BG new BondGraph
139 */
140 void setBondGraph(BondGraph *_BG);
141 /**
142 * returns the configuration for the world.
143 */
144 config *&getConfig();
145
146 /** Returns a notification_ptr for a specific type.
147 *
148 * @param type request type
149 * @return reference to instance
150 */
151 Notification_ptr getNotification(enum NotificationType type) const;
152
153 /**
154 * returns the first atom that matches a given descriptor.
155 * Do not rely on ordering for descriptors that match more than one atom.
156 */
157 atom* getAtom(AtomDescriptor descriptor);
158
159 /**
160 * returns a vector containing all atoms that match a given descriptor
161 */
162 AtomComposite getAllAtoms(AtomDescriptor descriptor);
163 AtomComposite getAllAtoms();
164
165 /**
166 * returns a calculation that calls a given function on all atoms matching a descriptor.
167 * the calculation is not called at this point and can be used as an action, i.e. be stored in
168 * menus, be kept around for later use etc.
169 */
170 template<typename T> MoleCuilder::AtomsCalculation<T>* calcOnAtoms(boost::function<T(atom*)>,const MoleCuilder::ActionTrait &_trait,AtomDescriptor);
171 template<typename T> MoleCuilder::AtomsCalculation<T>* calcOnAtoms(boost::function<T(atom*)>,const MoleCuilder::ActionTrait &_trait);
172
173 /**
174 * get the number of atoms in the World
175 */
176 int numAtoms();
177
178 /**
179 * returns the first molecule that matches a given descriptor.
180 * Do not rely on ordering for descriptors that match more than one molecule.
181 */
182 molecule *getMolecule(MoleculeDescriptor descriptor);
183
184 /**
185 * returns a vector containing all molecules that match a given descriptor
186 */
187 std::vector<molecule*> getAllMolecules(MoleculeDescriptor descriptor);
188 std::vector<molecule*> getAllMolecules();
189
190 /**
191 * get the number of molecules in the World
192 */
193 int numMolecules();
194
195 /**
196 * get the domain size as a symmetric matrix (6 components)
197 */
198 Box& getDomain();
199
200 /**
201 * Set the domain size from a matrix object
202 *
203 * Matrix needs to be symmetric
204 */
205 void setDomain(const RealSpaceMatrix &mat);
206
207 /**
208 * set the domain size as a symmetric matrix (6 components)
209 */
210 void setDomain(double * matrix);
211
212 /** Returns a LinkedCell structure for obtaining neighbors quickly.
213 *
214 * @param distance desired linked cell edge length
215 * @return view of restricted underlying LinkedCell_Model
216 */
217 LinkedCell::LinkedCell_View getLinkedCell(const double distance);
218
219 /**
220 * set the current time of the world.
221 *
222 * @param _step time step to set to
223 */
224 void setTime(const unsigned int _step);
225
226 /**
227 * get the default name
228 */
229 std::string getDefaultName();
230
231 /**
232 * set the default name
233 */
234 void setDefaultName(std::string name);
235
236 /**
237 * get pointer to World's ThermoStatContainer
238 */
239 ThermoStatContainer * getThermostats();
240
241 /*
242 * get the ExitFlag
243 */
244 int getExitFlag();
245
246 /*
247 * set the ExitFlag
248 */
249 void setExitFlag(int flag);
250
251 /***** Methods to work with the World *****/
252
253 /**
254 * create a new molecule. This method should be used whenever any kind of molecule is needed. Assigns a unique
255 * ID to the molecule and stores it in the World for later retrieval. Do not create molecules directly.
256 */
257 molecule *createMolecule();
258
259 void destroyMolecule(molecule*);
260 void destroyMolecule(moleculeId_t);
261
262 /**
263 * Create a new atom. This method should be used whenever any atom is needed. Assigns a unique ID and stores
264 * the atom in the World. If the atom is not destroyed it will automatically be destroyed when the world ends.
265 */
266 atom *createAtom();
267
268 /**
269 * Registers a Atom unknown to world. Needed in some rare cases, e.g. when cloning atoms, or in some unittests.
270 * Do not re-register Atoms already known to the world since this will cause double-frees.
271 */
272 int registerAtom(atom*);
273
274 /**
275 * Delete some atom and erase it from the world. Use this whenever you need to destroy any atom. Do not call delete on
276 * atom directly since this will leave the pointer inside the world.
277 */
278 void destroyAtom(atom*);
279
280 /**
281 * Delete some atom and erase it from the world. Use this whenever you need to destroy any atom. Do not call delete on
282 * atom directly since this will leave the pointer inside the world.
283 */
284 void destroyAtom(atomId_t);
285
286 /**
287 * used when changing an atom Id.
288 * Unless you are calling this method from inside an atom don't fiddle with the third parameter.
289 *
290 * Return value indicates wether the change could be done or not.
291 */
292 bool changeAtomId(atomId_t oldId, atomId_t newId, atom* target=0);
293
294 /**
295 * used when changing an molecule Id.
296 * Unless you are calling this method from inside an moleucle don't fiddle with the third parameter.
297 *
298 * Return value indicates wether the change could be done or not.
299 */
300 bool changeMoleculeId(moleculeId_t oldId, moleculeId_t newId, molecule* target=0);
301
302 /**
303 * Produces a process that calls a function on all Atoms matching a given descriptor. The process is not
304 * called at this time, so it can be passed around, stored inside menuItems etc.
305 */
306 MoleCuilder::ManipulateAtomsProcess* manipulateAtoms(boost::function<void(atom*)>,std::string,AtomDescriptor);
307 MoleCuilder::ManipulateAtomsProcess* manipulateAtoms(boost::function<void(atom*)>,std::string);
308
309 /****
310 * Iterators to use internal data structures
311 * All these iterators are observed to track changes.
312 * There is a corresponding protected section with unobserved iterators,
313 * which can be used internally when the extra speed is needed
314 */
315
316 typedef SelectiveIterator<atom*,AtomSet,AtomDescriptor> AtomIterator;
317
318 /**
319 * returns an iterator over all Atoms matching a given descriptor.
320 * This iterator is observed, so don't keep it around unnecessary to
321 * avoid unintended blocking.
322 */
323 AtomIterator getAtomIter(AtomDescriptor descr);
324 AtomIterator getAtomIter();
325
326 AtomIterator atomEnd();
327
328 typedef SelectiveIterator<molecule*,MoleculeSet,MoleculeDescriptor> MoleculeIterator;
329
330 /**
331 * returns an iterator over all Molecules matching a given descriptor.
332 * This iterator is observed, so don't keep it around unnecessary to
333 * avoid unintended blocking.
334 */
335 MoleculeIterator getMoleculeIter(MoleculeDescriptor descr);
336 MoleculeIterator getMoleculeIter();
337
338 MoleculeIterator moleculeEnd();
339
340 /******** Selections of molecules and Atoms *************/
341 void clearAtomSelection();
342 void selectAtom(const atom*);
343 void selectAtom(const atomId_t);
344 void selectAllAtoms(AtomDescriptor);
345 void selectAtomsOfMolecule(const molecule*);
346 void selectAtomsOfMolecule(const moleculeId_t);
347 void unselectAtom(const atom*);
348 void unselectAtom(const atomId_t);
349 void unselectAllAtoms(AtomDescriptor);
350 void unselectAtomsOfMolecule(const molecule*);
351 void unselectAtomsOfMolecule(const moleculeId_t);
352 size_t countSelectedAtoms() const;
353 bool isSelected(const atom *_atom) const;
354 bool isAtomSelected(const atomId_t no) const;
355 const std::vector<atom *> getSelectedAtoms() const;
356
357 void clearMoleculeSelection();
358 void selectMolecule(const molecule*);
359 void selectMolecule(const moleculeId_t);
360 void selectAllMolecules(MoleculeDescriptor);
361 void selectMoleculeOfAtom(const atom*);
362 void selectMoleculeOfAtom(const atomId_t);
363 void unselectMolecule(const molecule*);
364 void unselectMolecule(const moleculeId_t);
365 void unselectAllMolecules(MoleculeDescriptor);
366 void unselectMoleculeOfAtom(const atom*);
367 void unselectMoleculeOfAtom(const atomId_t);
368 size_t countSelectedMolecules() const;
369 bool isSelected(const molecule *_mol) const;
370 bool isMoleculeSelected(const moleculeId_t no) const;
371 const std::vector<molecule *> getSelectedMolecules() const;
372
373 /******************** Iterators to selections *****************/
374 typedef AtomSet::iterator AtomSelectionIterator;
375 AtomSelectionIterator beginAtomSelection();
376 AtomSelectionIterator endAtomSelection();
377 typedef AtomSet::const_iterator AtomSelectionConstIterator;
378 AtomSelectionConstIterator beginAtomSelection() const;
379 AtomSelectionConstIterator endAtomSelection() const;
380
381 typedef MoleculeSet::iterator MoleculeSelectionIterator;
382 MoleculeSelectionIterator beginMoleculeSelection();
383 MoleculeSelectionIterator endMoleculeSelection();
384 typedef MoleculeSet::const_iterator MoleculeSelectionConstIterator;
385 MoleculeSelectionConstIterator beginMoleculeSelection() const;
386 MoleculeSelectionConstIterator endMoleculeSelection() const;
387
388protected:
389 /****
390 * Iterators to use internal data structures
391 * All these iterators are unobserved for speed reasons.
392 * There is a corresponding public section to these methods,
393 * which produce observed iterators.*/
394
395 // Atoms
396 typedef SelectiveIterator<atom*,AtomSet::set_t,AtomDescriptor> internal_AtomIterator;
397
398 /**
399 * returns an iterator over all Atoms matching a given descriptor.
400 * used for internal purposes, like AtomProcesses and AtomCalculations.
401 */
402 internal_AtomIterator getAtomIter_internal(AtomDescriptor descr);
403
404 /**
405 * returns an iterator to the end of the AtomSet. Due to overloading this iterator
406 * can be compared to iterators produced by getAtomIter (see the mis-matching types).
407 * Thus it can be used to detect when such an iterator is at the end of the list.
408 * used for internal purposes, like AtomProcesses and AtomCalculations.
409 */
410 internal_AtomIterator atomEnd_internal();
411
412 // Molecules
413 typedef SelectiveIterator<molecule*,MoleculeSet::set_t,MoleculeDescriptor> internal_MoleculeIterator;
414
415
416 /**
417 * returns an iterator over all Molecules matching a given descriptor.
418 * used for internal purposes, like MoleculeProcesses and MoleculeCalculations.
419 */
420 internal_MoleculeIterator getMoleculeIter_internal(MoleculeDescriptor descr);
421
422 /**
423 * returns an iterator to the end of the MoleculeSet. Due to overloading this iterator
424 * can be compared to iterators produced by getMoleculeIter (see the mis-matching types).
425 * Thus it can be used to detect when such an iterator is at the end of the list.
426 * used for internal purposes, like MoleculeProcesses and MoleculeCalculations.
427 */
428 internal_MoleculeIterator moleculeEnd_internal();
429
430
431 /******* Internal manipulation routines for double callback and Observer mechanism ******/
432 void doManipulate(MoleCuilder::ManipulateAtomsProcess *);
433
434private:
435
436 friend const atom *detail::lastChanged<atom>();
437 friend const molecule *detail::lastChanged<molecule>();
438 static atom *_lastchangedatom;
439 static molecule*_lastchangedmol;
440
441 BondGraph *BG;
442 periodentafel *periode;
443 config *configuration;
444 Box *cell_size;
445 LinkedCell::LinkedCell_Controller *LCcontroller;
446 std::string defaultName;
447 class ThermoStatContainer *Thermostats;
448 int ExitFlag;
449private:
450
451 AtomSet atoms;
452 AtomSet selectedAtoms;
453 /**
454 * stores the pool for all available AtomIds below currAtomId
455 *
456 * The pool contains ranges of free ids in the form [bottom,top).
457 */
458 IdPool<atomId_t, uniqueId> atomIdPool;
459
460 MoleculeSet molecules;
461 MoleculeSet selectedMolecules;
462 /**
463 * stores the pool for all available AtomIds below currAtomId
464 *
465 * The pool contains ranges of free ids in the form [bottom,top).
466 */
467 IdPool<moleculeId_t, continuousId> moleculeIdPool;
468
469private:
470 /**
471 * private constructor to ensure creation of the world using
472 * the singleton pattern.
473 */
474 World();
475
476 /**
477 * private destructor to ensure destruction of the world using the
478 * singleton pattern.
479 */
480 virtual ~World();
481
482 /*****
483 * some legacy stuff that is include for now but will be removed later
484 *****/
485public:
486 MoleculeListClass *&getMolecules();
487
488private:
489 MoleculeListClass *molecules_deprecated;
490};
491
492/** Externalized stuff as member functions cannot be specialized without
493 * specializing the class, too.
494 */
495namespace detail {
496 template <> inline const atom* lastChanged<atom>() { return World::_lastchangedatom; }
497 template <> inline const molecule* lastChanged<molecule>() { return World::_lastchangedmol; }
498}
499
500
501#endif /* WORLD_HPP_ */
Note: See TracBrowser for help on using the repository browser.