source: src/World.hpp@ 1a6bda

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 1a6bda was ad011c, checked in by Frederik Heber <heber@…>, 14 years ago

CodePatterns places all includes now in subfolder CodePatterns/.

  • change all includes accordingly.
  • this was necessary as Helpers and Patterns are not very distinctive names for include folders. Already now, we had a conflict between Helpers from CodePatterns and Helpers from this project.
  • changed compilation test in ax_codepatterns.m4 when changing CodePatterns includes.
  • Property mode set to 100644
File size: 13.2 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/*********************************************** includes ***********************************/
12
13#include <string>
14#include <map>
15#include <vector>
16#include <set>
17#include <boost/thread.hpp>
18#include <boost/shared_ptr.hpp>
19
20#include "types.hpp"
21#include "Actions/ActionTraits.hpp"
22#include "Descriptors/SelectiveIterator.hpp"
23#include "CodePatterns/Observer.hpp"
24#include "CodePatterns/Cacheable.hpp"
25#include "CodePatterns/Singleton.hpp"
26#include "CodePatterns/ObservedContainer.hpp"
27#include "CodePatterns/Range.hpp"
28#include "AtomSet.hpp"
29
30// include config.h
31#ifdef HAVE_CONFIG_H
32#include <config.h>
33#endif
34
35// forward declarations
36class atom;
37class AtomDescriptor;
38class AtomDescriptor_impl;
39template<typename T> class AtomsCalculation;
40class Box;
41class config;
42class ManipulateAtomsProcess;
43class RealSpaceMatrix;
44class molecule;
45class MoleculeDescriptor;
46class MoleculeDescriptor_impl;
47class MoleculeListClass;
48class periodentafel;
49class ThermoStatContainer;
50
51
52/****************************************** forward declarations *****************************/
53
54/********************************************** Class World *******************************/
55
56class World : public Singleton<World>, public Observable
57{
58
59// Make access to constructor and destructor possible from inside the singleton
60friend class Singleton<World>;
61
62// necessary for coupling with descriptors
63friend class AtomDescriptor_impl;
64friend class AtomDescriptor;
65friend class MoleculeDescriptor_impl;
66friend class MoleculeDescriptor;
67// coupling with descriptors over selection
68friend class AtomSelectionDescriptor_impl;
69friend class MoleculeSelectionDescriptor_impl;
70
71// Actions, calculations etc associated with the World
72friend class ManipulateAtomsProcess;
73template<typename> friend class AtomsCalculation;
74public:
75 // some typedefs for the CONSTRUCT_... macros (no "," allows in a single parameter name)
76 typedef std::map<atomId_t,atom*> AtomSTLSet;
77 typedef std::map<moleculeId_t,molecule*> MoleculeSTLSet;
78
79 // Types for Atom and Molecule structures
80 typedef ObservedContainer< AtomSTLSet > AtomSet;
81 typedef ObservedContainer< MoleculeSTLSet > MoleculeSet;
82
83 typedef ATOMSET(std::vector) AtomComposite;
84
85 /***** getter and setter *****/
86 // reference to pointer is used for legacy reason... reference will be removed latter to keep encapsulation of World object
87 /**
88 * returns the periodentafel for the world.
89 */
90 periodentafel *&getPeriode();
91
92 /**
93 * returns the configuration for the world.
94 */
95 config *&getConfig();
96
97 /**
98 * returns the first atom that matches a given descriptor.
99 * Do not rely on ordering for descriptors that match more than one atom.
100 */
101 atom* getAtom(AtomDescriptor descriptor);
102
103 /**
104 * returns a vector containing all atoms that match a given descriptor
105 */
106 AtomComposite getAllAtoms(AtomDescriptor descriptor);
107 AtomComposite getAllAtoms();
108
109 /**
110 * returns a calculation that calls a given function on all atoms matching a descriptor.
111 * the calculation is not called at this point and can be used as an action, i.e. be stored in
112 * menus, be kept around for later use etc.
113 */
114 template<typename T> AtomsCalculation<T>* calcOnAtoms(boost::function<T(atom*)>,const ActionTraits &_trait,AtomDescriptor);
115 template<typename T> AtomsCalculation<T>* calcOnAtoms(boost::function<T(atom*)>,const ActionTraits &_trait);
116
117 /**
118 * get the number of atoms in the World
119 */
120 int numAtoms();
121
122 /**
123 * returns the first molecule that matches a given descriptor.
124 * Do not rely on ordering for descriptors that match more than one molecule.
125 */
126 molecule *getMolecule(MoleculeDescriptor descriptor);
127
128 /**
129 * returns a vector containing all molecules that match a given descriptor
130 */
131 std::vector<molecule*> getAllMolecules(MoleculeDescriptor descriptor);
132 std::vector<molecule*> getAllMolecules();
133
134 /**
135 * get the number of molecules in the World
136 */
137 int numMolecules();
138
139 /**
140 * get the domain size as a symmetric matrix (6 components)
141 */
142 Box& getDomain();
143
144 /**
145 * Set the domain size from a matrix object
146 *
147 * Matrix needs to be symmetric
148 */
149 void setDomain(const RealSpaceMatrix &mat);
150
151 /**
152 * set the domain size as a symmetric matrix (6 components)
153 */
154 void setDomain(double * matrix);
155
156 /**
157 * get the default name
158 */
159 std::string getDefaultName();
160
161 /**
162 * set the default name
163 */
164 void setDefaultName(std::string name);
165
166 /**
167 * get pointer to World's ThermoStatContainer
168 */
169 ThermoStatContainer * getThermostats();
170
171 /*
172 * get the ExitFlag
173 */
174 int getExitFlag();
175
176 /*
177 * set the ExitFlag
178 */
179 void setExitFlag(int flag);
180
181 /***** Methods to work with the World *****/
182
183 /**
184 * create a new molecule. This method should be used whenever any kind of molecule is needed. Assigns a unique
185 * ID to the molecule and stores it in the World for later retrieval. Do not create molecules directly.
186 */
187 molecule *createMolecule();
188
189 void destroyMolecule(molecule*);
190 void destroyMolecule(moleculeId_t);
191
192 /**
193 * Create a new atom. This method should be used whenever any atom is needed. Assigns a unique ID and stores
194 * the atom in the World. If the atom is not destroyed it will automatically be destroyed when the world ends.
195 */
196 atom *createAtom();
197
198 /**
199 * Registers a Atom unknown to world. Needed in some rare cases, e.g. when cloning atoms, or in some unittests.
200 * Do not re-register Atoms already known to the world since this will cause double-frees.
201 */
202 int registerAtom(atom*);
203
204 /**
205 * Delete some atom and erase it from the world. Use this whenever you need to destroy any atom. Do not call delete on
206 * atom directly since this will leave the pointer inside the world.
207 */
208 void destroyAtom(atom*);
209
210 /**
211 * Delete some atom and erase it from the world. Use this whenever you need to destroy any atom. Do not call delete on
212 * atom directly since this will leave the pointer inside the world.
213 */
214 void destroyAtom(atomId_t);
215
216 /**
217 * used when changing an atom Id.
218 * Unless you are calling this method from inside an atom don't fiddle with the third parameter.
219 *
220 * Return value indicates wether the change could be done or not.
221 */
222 bool changeAtomId(atomId_t oldId, atomId_t newId, atom* target=0);
223
224 /**
225 * used when changing an molecule Id.
226 * Unless you are calling this method from inside an moleucle don't fiddle with the third parameter.
227 *
228 * Return value indicates wether the change could be done or not.
229 */
230 bool changeMoleculeId(moleculeId_t oldId, moleculeId_t newId, molecule* target=0);
231
232 /**
233 * Produces a process that calls a function on all Atoms matching a given descriptor. The process is not
234 * called at this time, so it can be passed around, stored inside menuItems etc.
235 */
236 ManipulateAtomsProcess* manipulateAtoms(boost::function<void(atom*)>,std::string,AtomDescriptor);
237 ManipulateAtomsProcess* manipulateAtoms(boost::function<void(atom*)>,std::string);
238
239 /****
240 * Iterators to use internal data structures
241 * All these iterators are observed to track changes.
242 * There is a corresponding protected section with unobserved iterators,
243 * which can be used internally when the extra speed is needed
244 */
245
246 typedef SelectiveIterator<atom*,AtomSet,AtomDescriptor> AtomIterator;
247
248 /**
249 * returns an iterator over all Atoms matching a given descriptor.
250 * This iterator is observed, so don't keep it around unnecessary to
251 * avoid unintended blocking.
252 */
253 AtomIterator getAtomIter(AtomDescriptor descr);
254 AtomIterator getAtomIter();
255
256 AtomIterator atomEnd();
257
258 typedef SelectiveIterator<molecule*,MoleculeSet,MoleculeDescriptor> MoleculeIterator;
259
260 /**
261 * returns an iterator over all Molecules matching a given descriptor.
262 * This iterator is observed, so don't keep it around unnecessary to
263 * avoid unintended blocking.
264 */
265 MoleculeIterator getMoleculeIter(MoleculeDescriptor descr);
266 MoleculeIterator getMoleculeIter();
267
268 MoleculeIterator moleculeEnd();
269
270 /******** Selections of molecules and Atoms *************/
271 void clearAtomSelection();
272 void selectAtom(const atom*);
273 void selectAtom(const atomId_t);
274 void selectAllAtoms(AtomDescriptor);
275 void selectAtomsOfMolecule(const molecule*);
276 void selectAtomsOfMolecule(const moleculeId_t);
277 void unselectAtom(const atom*);
278 void unselectAtom(const atomId_t);
279 void unselectAllAtoms(AtomDescriptor);
280 void unselectAtomsOfMolecule(const molecule*);
281 void unselectAtomsOfMolecule(const moleculeId_t);
282 size_t countSelectedAtoms() const;
283 bool isSelected(const atom *_atom) const;
284 const std::vector<atom *> getSelectedAtoms() const;
285
286 void clearMoleculeSelection();
287 void selectMolecule(const molecule*);
288 void selectMolecule(const moleculeId_t);
289 void selectAllMolecules(MoleculeDescriptor);
290 void selectMoleculeOfAtom(const atom*);
291 void selectMoleculeOfAtom(const atomId_t);
292 void unselectMolecule(const molecule*);
293 void unselectMolecule(const moleculeId_t);
294 void unselectAllMolecules(MoleculeDescriptor);
295 void unselectMoleculeOfAtom(const atom*);
296 void unselectMoleculeOfAtom(const atomId_t);
297 size_t countSelectedMolecules() const;
298 bool isSelected(const molecule *_mol) const;
299 const std::vector<molecule *> getSelectedMolecules() const;
300
301 /******************** Iterators to selections *****************/
302 typedef AtomSet::iterator AtomSelectionIterator;
303 AtomSelectionIterator beginAtomSelection();
304 AtomSelectionIterator endAtomSelection();
305
306 typedef MoleculeSet::iterator MoleculeSelectionIterator;
307 MoleculeSelectionIterator beginMoleculeSelection();
308 MoleculeSelectionIterator endMoleculeSelection();
309
310protected:
311 /****
312 * Iterators to use internal data structures
313 * All these iterators are unobserved for speed reasons.
314 * There is a corresponding public section to these methods,
315 * which produce observed iterators.*/
316
317 // Atoms
318 typedef SelectiveIterator<atom*,AtomSet::set_t,AtomDescriptor> internal_AtomIterator;
319
320 /**
321 * returns an iterator over all Atoms matching a given descriptor.
322 * used for internal purposes, like AtomProcesses and AtomCalculations.
323 */
324 internal_AtomIterator getAtomIter_internal(AtomDescriptor descr);
325
326 /**
327 * returns an iterator to the end of the AtomSet. Due to overloading this iterator
328 * can be compared to iterators produced by getAtomIter (see the mis-matching types).
329 * Thus it can be used to detect when such an iterator is at the end of the list.
330 * used for internal purposes, like AtomProcesses and AtomCalculations.
331 */
332 internal_AtomIterator atomEnd_internal();
333
334 // Molecules
335 typedef SelectiveIterator<molecule*,MoleculeSet::set_t,MoleculeDescriptor> internal_MoleculeIterator;
336
337
338 /**
339 * returns an iterator over all Molecules matching a given descriptor.
340 * used for internal purposes, like MoleculeProcesses and MoleculeCalculations.
341 */
342 internal_MoleculeIterator getMoleculeIter_internal(MoleculeDescriptor descr);
343
344 /**
345 * returns an iterator to the end of the MoleculeSet. Due to overloading this iterator
346 * can be compared to iterators produced by getMoleculeIter (see the mis-matching types).
347 * Thus it can be used to detect when such an iterator is at the end of the list.
348 * used for internal purposes, like MoleculeProcesses and MoleculeCalculations.
349 */
350 internal_MoleculeIterator moleculeEnd_internal();
351
352
353 /******* Internal manipulation routines for double callback and Observer mechanism ******/
354 void doManipulate(ManipulateAtomsProcess *);
355
356private:
357
358 atomId_t getNextAtomId();
359 void releaseAtomId(atomId_t);
360 bool reserveAtomId(atomId_t);
361 void defragAtomIdPool();
362
363 moleculeId_t getNextMoleculeId();
364 void releaseMoleculeId(moleculeId_t);
365 bool reserveMoleculeId(moleculeId_t);
366 void defragMoleculeIdPool();
367
368 periodentafel *periode;
369 config *configuration;
370 Box *cell_size;
371 std::string defaultName;
372 class ThermoStatContainer *Thermostats;
373 int ExitFlag;
374private:
375
376 AtomSet atoms;
377 AtomSet selectedAtoms;
378 typedef std::set<range<atomId_t> > atomIdPool_t;
379 /**
380 * stores the pool for all available AtomIds below currAtomId
381 *
382 * The pool contains ranges of free ids in the form [bottom,top).
383 */
384 atomIdPool_t atomIdPool;
385 atomId_t currAtomId; //!< stores the next available Id for atoms
386 size_t lastAtomPoolSize; //!< size of the pool after last defrag, to skip some defrags
387 unsigned int numAtomDefragSkips;
388
389 MoleculeSet molecules;
390 MoleculeSet selectedMolecules;
391 typedef std::set<range<atomId_t> > moleculeIdPool_t;
392 /**
393 * stores the pool for all available AtomIds below currAtomId
394 *
395 * The pool contains ranges of free ids in the form [bottom,top).
396 */
397 moleculeIdPool_t moleculeIdPool;
398 moleculeId_t currMoleculeId;
399 size_t lastMoleculePoolSize; //!< size of the pool after last defrag, to skip some defrags
400 unsigned int numMoleculeDefragSkips;
401private:
402 /**
403 * private constructor to ensure creation of the world using
404 * the singleton pattern.
405 */
406 World();
407
408 /**
409 * private destructor to ensure destruction of the world using the
410 * singleton pattern.
411 */
412 virtual ~World();
413
414 /*****
415 * some legacy stuff that is include for now but will be removed later
416 *****/
417public:
418 MoleculeListClass *&getMolecules();
419
420private:
421 MoleculeListClass *molecules_deprecated;
422};
423
424#endif /* WORLD_HPP_ */
Note: See TracBrowser for help on using the repository browser.