source: src/World.hpp@ 9131f3

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 Candidate_v1.7.0 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 9131f3 was 31af19, checked in by Tillmann Crueger <crueger@…>, 16 years ago

Made the World Iterators conform to STL-Structure

  • Property mode set to 100644
File size: 10.2 KB
RevLine 
[5d1611]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
[7c4e29]11#include <string>
[d346b6]12#include <map>
[fc1b24]13#include <vector>
[354859]14#include <set>
[7c4e29]15#include <boost/thread.hpp>
[865a945]16#include <boost/shared_ptr.hpp>
[5d1611]17
[cbc5fb]18#include "defs.hpp"
[5d1611]19#include "Patterns/Observer.hpp"
20#include "Patterns/Cacheable.hpp"
21
22// forward declarations
23class periodentafel;
24class MoleculeListClass;
[4d9c01]25class atom;
[354859]26class molecule;
[fc1b24]27class AtomDescriptor;
[7a1ce5]28class AtomDescriptor_impl;
[1c51c8]29class MoleculeDescriptor;
30class MoleculeDescriptor_impl;
[7c4e29]31class ManipulateAtomsProcess;
[b54ac8]32template<typename T>
33class AtomsCalculation;
[5d1611]34
35class World : public Observable
36{
[b54ac8]37// necessary for coupling with descriptors
[7a1ce5]38friend class AtomDescriptor_impl;
[865a945]39friend class AtomDescriptor;
[1c51c8]40friend class MoleculeDescriptor_impl;
41friend class MoleculeDescriptor;
[865a945]42
[b54ac8]43// Actions, calculations etc associated with the World
[7c4e29]44friend class ManipulateAtomsProcess;
[b54ac8]45template<typename> friend class AtomsCalculation;
[5d1611]46public:
[7042f45]47 typedef std::map<atomId_t,atom*> AtomSet;
48 typedef std::map<moleculeId_t,molecule*> MoleculeSet;
[5d1611]49
50 /***** getter and setter *****/
[354859]51 // reference to pointer is used for legacy reason... reference will be removed latter to keep encapsulation of World object
[02ee15]52 /**
53 * returns the periodentafel for the world.
54 */
[354859]55 periodentafel *&getPeriode();
[02ee15]56
57 /**
58 * returns the first atom that matches a given descriptor.
59 * Do not rely on ordering for descriptors that match more than one atom.
60 */
[7a1ce5]61 atom* getAtom(AtomDescriptor descriptor);
[02ee15]62
63 /**
64 * returns a vector containing all atoms that match a given descriptor
65 */
[7a1ce5]66 std::vector<atom*> getAllAtoms(AtomDescriptor descriptor);
[0e2a47]67 std::vector<atom*> getAllAtoms();
[b54ac8]68
[02ee15]69 /**
70 * returns a calculation that calls a given function on all atoms matching a descriptor.
71 * the calculation is not called at this point and can be used as an action, i.e. be stored in
72 * menus, be kept around for later use etc.
73 */
[0e2a47]74 template<typename T> AtomsCalculation<T>* calcOnAtoms(boost::function<T(atom*)>,std::string,AtomDescriptor);
75 template<typename T> AtomsCalculation<T>* calcOnAtoms(boost::function<T(atom*)>,std::string);
[b54ac8]76
[02ee15]77 /**
78 * get the number of atoms in the World
79 */
[354859]80 int numAtoms();
[02ee15]81
[1c51c8]82 /**
83 * returns the first molecule that matches a given descriptor.
84 * Do not rely on ordering for descriptors that match more than one molecule.
85 */
86 molecule *getMolecule(MoleculeDescriptor descriptor);
87
88 /**
89 * returns a vector containing all molecules that match a given descriptor
90 */
91 std::vector<molecule*> getAllMolecules(MoleculeDescriptor descriptor);
92
[02ee15]93 /**
94 * get the number of molecules in the World
95 */
[354859]96 int numMolecules();
97
98 /***** Methods to work with the World *****/
[02ee15]99
100 /**
101 * create a new molecule. This method should be used whenever any kind of molecule is needed. Assigns a unique
102 * ID to the molecule and stores it in the World for later retrieval. Do not create molecules directly.
103 */
[354859]104 molecule *createMolecule();
[02ee15]105
[cbc5fb]106 void destroyMolecule(molecule*);
107 void destroyMolecule(moleculeId_t);
108
[02ee15]109 /**
110 * Create a new atom. This method should be used whenever any atom is needed. Assigns a unique ID and stores
111 * the atom in the World. If the atom is not destroyed it will automatically be destroyed when the world ends.
112 */
[46d958]113 atom *createAtom();
[02ee15]114
115 /**
116 * Registers a Atom unknown to world. Needed in some rare cases, e.g. when cloning atoms, or in some unittests.
117 * Do not re-register Atoms already known to the world since this will cause double-frees.
118 */
[46d958]119 int registerAtom(atom*);
[02ee15]120
121 /**
122 * Delete some atom and erase it from the world. Use this whenever you need to destroy any atom. Do not call delete on
123 * atom directly since this will leave the pointer inside the world.
124 */
[46d958]125 void destroyAtom(atom*);
[02ee15]126
127 /**
128 * Delete some atom and erase it from the world. Use this whenever you need to destroy any atom. Do not call delete on
129 * atom directly since this will leave the pointer inside the world.
130 */
[cbc5fb]131 void destroyAtom(atomId_t);
[865a945]132
[88d586]133 /**
134 * used when changing an atom Id.
135 * Unless you are calling this method from inside an atom don't fiddle with the third parameter.
136 *
137 * Return value indicates wether the change could be done or not.
138 */
139 bool changeAtomId(atomId_t oldId, atomId_t newId, atom* target=0);
140
[02ee15]141 /**
142 * Produces a process that calls a function on all Atoms matching a given descriptor. The process is not
143 * called at this time, so it can be passed around, stored inside menuItems etc.
144 */
[7c4e29]145 ManipulateAtomsProcess* manipulateAtoms(boost::function<void(atom*)>,std::string,AtomDescriptor);
[0e2a47]146 ManipulateAtomsProcess* manipulateAtoms(boost::function<void(atom*)>,std::string);
[7c4e29]147
[865a945]148protected:
149 /**** Iterators to use internal data structures */
[1c51c8]150
151 // Atoms
152
[31af19]153 class AtomIterator :
154 public std::iterator<std::iterator_traits<AtomSet::iterator>::difference_type,
155 std::iterator_traits<AtomSet::iterator>::value_type,
156 std::iterator_traits<AtomSet::iterator>::pointer,
157 std::iterator_traits<AtomSet::iterator>::reference>
158 {
[865a945]159 public:
[31af19]160
161 typedef AtomSet::iterator _Iter;
162 typedef _Iter::value_type value_type;
163 typedef _Iter::difference_type difference_type;
164 typedef _Iter::pointer pointer;
165 typedef _Iter::reference reference;
166 typedef _Iter::iterator_category iterator_category;
167
168
[7c4e29]169 AtomIterator();
[865a945]170 AtomIterator(AtomDescriptor, World*);
171 AtomIterator(const AtomIterator&);
[7c4e29]172 AtomIterator& operator=(const AtomIterator&);
173 AtomIterator& operator++(); // prefix
174 AtomIterator operator++(int); // postfix with dummy parameter
[865a945]175 bool operator==(const AtomIterator&);
[d2dbac0]176 bool operator==(const AtomSet::iterator&);
[865a945]177 bool operator!=(const AtomIterator&);
[d2dbac0]178 bool operator!=(const AtomSet::iterator&);
[865a945]179 atom* operator*();
[7c4e29]180
181 int getCount();
[865a945]182 protected:
183 void advanceState();
[d2dbac0]184 AtomSet::iterator state;
[865a945]185 boost::shared_ptr<AtomDescriptor_impl> descr;
[7c4e29]186 int index;
[24a5e0]187
188 World* world;
[865a945]189 };
190
[02ee15]191 /**
192 * returns an iterator over all Atoms matching a given descriptor.
193 * used for internal purposes, like AtomProcesses and AtomCalculations.
194 */
[865a945]195 AtomIterator getAtomIter(AtomDescriptor descr);
[02ee15]196
197 /**
[d2dbac0]198 * returns an iterator to the end of the AtomSet. Due to overloading this iterator
[02ee15]199 * can be compared to iterators produced by getAtomIter (see the mis-matching types).
200 * Thus it can be used to detect when such an iterator is at the end of the list.
201 * used for internal purposes, like AtomProcesses and AtomCalculations.
202 */
[d2dbac0]203 AtomSet::iterator atomEnd();
[865a945]204
[1c51c8]205 // Molecules
206
[31af19]207 class MoleculeIterator :
208 public std::iterator<std::iterator_traits<MoleculeSet::iterator>::difference_type,
209 std::iterator_traits<MoleculeSet::iterator>::value_type,
210 std::iterator_traits<MoleculeSet::iterator>::pointer,
211 std::iterator_traits<MoleculeSet::iterator>::reference>
212 {
[1c51c8]213 public:
[31af19]214
215 typedef MoleculeSet::iterator _Iter;
216 typedef _Iter::value_type value_type;
217 typedef _Iter::difference_type difference_type;
218 typedef _Iter::pointer pointer;
219 typedef _Iter::reference reference;
220 typedef _Iter::iterator_category iterator_category;
221
[1c51c8]222 MoleculeIterator();
223 MoleculeIterator(MoleculeDescriptor, World*);
224 MoleculeIterator(const MoleculeIterator&);
225 MoleculeIterator& operator=(const MoleculeIterator&);
226 MoleculeIterator& operator++(); // prefix
227 MoleculeIterator operator++(int); // postfix with dummy parameter
228 bool operator==(const MoleculeIterator&);
229 bool operator==(const MoleculeSet::iterator&);
230 bool operator!=(const MoleculeIterator&);
231 bool operator!=(const MoleculeSet::iterator&);
232 molecule* operator*();
233
234 int getCount();
235 protected:
236 void advanceState();
237 MoleculeSet::iterator state;
238 boost::shared_ptr<MoleculeDescriptor_impl> descr;
239 int index;
240
241 World* world;
242 };
243
244 /**
245 * returns an iterator over all Molecules matching a given descriptor.
246 * used for internal purposes, like MoleculeProcesses and MoleculeCalculations.
247 */
248 MoleculeIterator getMoleculeIter(MoleculeDescriptor descr);
249
250 /**
251 * returns an iterator to the end of the MoleculeSet. Due to overloading this iterator
252 * can be compared to iterators produced by getMoleculeIter (see the mis-matching types).
253 * Thus it can be used to detect when such an iterator is at the end of the list.
254 * used for internal purposes, like MoleculeProcesses and MoleculeCalculations.
255 */
256 MoleculeSet::iterator moleculeEnd();
257
258
[afb47f]259 /******* Internal manipulation routines for double callback and Observer mechanism ******/
260 void doManipulate(ManipulateAtomsProcess *);
261
[5d1611]262private:
[88d586]263
264 atomId_t getNextAtomId();
265 void releaseAtomId(atomId_t);
266 bool reserveAtomId(atomId_t);
267
[5d1611]268 periodentafel *periode;
[d2dbac0]269 AtomSet atoms;
[88d586]270 std::set<atomId_t> atomIdPool; //<!stores the pool for all available AtomIds below currAtomId
[cbc5fb]271 atomId_t currAtomId; //!< stores the next available Id for atoms
[d2dbac0]272 MoleculeSet molecules;
[cbc5fb]273 moleculeId_t currMoleculeId;
[5d1611]274
275
276 /***** singleton Stuff *****/
277public:
[02ee15]278
279 /**
280 * get the currently active instance of the World.
281 */
[5d1611]282 static World* get();
[02ee15]283
284 /**
285 * destroy the currently active instance of the World.
286 */
[5d1611]287 static void destroy();
[02ee15]288
289 /**
290 * destroy the currently active instance of the World and immidiately
291 * create a new one. Use this to reset while somebody is still Observing
292 * the world and should reset the observed instance. All observers will be
293 * sent the subjectKille() message from the old world.
294 */
[5d1611]295 static World* reset();
296
297private:
[02ee15]298 /**
299 * private constructor to ensure creation of the world using
300 * the singleton pattern.
301 */
[5d1611]302 World();
[02ee15]303
304 /**
305 * private destructor to ensure destruction of the world using the
306 * singleton pattern.
307 */
[5d1611]308 virtual ~World();
309
310 static World *theWorld;
311 // this mutex only saves the singleton pattern...
312 // use other mutexes to protect internal data as well
313 // this mutex handles access to the pointer, not to the object!!!
314 static boost::mutex worldLock;
315
316 /*****
317 * some legacy stuff that is include for now but will be removed later
318 *****/
319public:
[354859]320 MoleculeListClass *&getMolecules();
[4d9c01]321
[5d1611]322private:
[354859]323 MoleculeListClass *molecules_deprecated;
[5d1611]324};
325
326#endif /* WORLD_HPP_ */
Note: See TracBrowser for help on using the repository browser.