source: src/molecule.hpp@ 906822

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 906822 was 274d45, checked in by Frederik Heber <heber@…>, 15 years ago

FIX: Atoms were stored not in the sequence they were loaded.

  1. The main problem is molecule::atomSet which is a set<atom *>, i.e. atoms are sorted by their appearance in memory. As memory need not be allocated sequentially, this gives rise to extreme arbitririty which is not desired. Instead the atoms should be stored in the sequence they were loaded/created. The solution is as follows:
  • config::SaveAll()
  • molecule::atomSet is now a list<atom *>
  • molecule::atomIds is a new set<atomId_t> (atomIdSet) which controls that (global) ids remain unique in the no more Atomset's set (but list)
  • molecule::erase() erases also in atomIds
  • molecule::insert() checks whether id is present by atomIds
  • molecule::find() as std::list does not have a find, we just go through the list until the object is found (or not), this may be speeded up by another internal list.
  • molecule::InternalPointer made lots of confusion as virtual function GoToFirst() is const, hence begin() (needed therein) returns const_iterator, which then cannot be simply re-cast into an iterator: We make it a pointer, reinterpret_cast the pointer and reference it back. Although InternalPointer is mutable, the compiler cannot use the non-const function begin() (it cannot be made const, as overloading is not allowed). (this is noted in the code also extensively.)
  • molecule::containsAtom() does not use count but the new find, as it returns only boolean anyway.
  • rewrote MoleculeListClass::SimpleMerge() to get rid of the extra iterator, as we remove all atoms in the end anyway.
  • FIX: MoleculeListClass::SimpleMultiMerge() - the created mol was not inserted into the moleculelist in the end, although it is the only one to remain.
  1. All other databases had missing headers with respect to those stored in elements_db.cpp. Hence, valence of hydrogen was not parsed and this caused several failures in CalculateOrbitals() (Psi numbers and MaxMinSetp in pcp conf file).
  1. Subsequenytly, various test cases (12, 21, 30, 31, 36-38, 39) were broken. This had two reasons:
  • Seemingly, CalculateOrbitals() was broken before hence MaxMinStep (pcp config) and MaxPsiDouble/PsiMaxNn[Up|Down] were always 0. (10-21,30-31,39)
  • As the order is now correct, fixes from commits c9217161ec2a5d5db508557fe98a32068461f45b and 22a6da8380911571debebd69444d2615450bbbd8 were obselete and have been reverted (order of the Ion?_Type...): Molecules/6 (30), Molecules/7 (31), Filling/1 (39)
  • Due to different ordering, Tesselation/3 (38) had completely different .dat file (though same tesselation)
  • r3d had small differences, mostly order or epsilon (0 not being 0 but ..-e16), hence diffing was deactivated, as r3d is deprecated anyway (since vmd can render triangles as well and better).

Signed-off-by: Frederik Heber <heber@…>
  • Property mode set to 100755
File size: 22.5 KB
Line 
1/** \file molecule.hpp
2 *
3 * Class definitions of atom and molecule, element and periodentafel
4 */
5
6#ifndef MOLECULES_HPP_
7#define MOLECULES_HPP_
8
9using namespace std;
10
11/*********************************************** includes ***********************************/
12
13// GSL headers
14#include <gsl/gsl_eigen.h>
15#include <gsl/gsl_heapsort.h>
16#include <gsl/gsl_linalg.h>
17#include <gsl/gsl_matrix.h>
18#include <gsl/gsl_multimin.h>
19#include <gsl/gsl_vector.h>
20#include <gsl/gsl_randist.h>
21
22//// STL headers
23#include <map>
24#include <set>
25#include <deque>
26#include <list>
27#include <vector>
28
29#include <string>
30
31#include "defs.hpp"
32#include "graph.hpp"
33#include "stackclass.hpp"
34#include "tesselation.hpp"
35#include "Patterns/Observer.hpp"
36#include "Patterns/ObservedIterator.hpp"
37#include "Patterns/Cacheable.hpp"
38
39#include "Descriptors/MoleculeDescriptor_impl.hpp"
40
41/****************************************** forward declarations *****************************/
42
43class atom;
44class bond;
45class BondedParticle;
46class BondGraph;
47class element;
48class ForceMatrix;
49class LinkedCell;
50class molecule;
51class MoleculeLeafClass;
52class MoleculeListClass;
53class periodentafel;
54class Vector;
55
56/******************************** Some definitions for easier reading **********************************/
57
58#define MoleculeList list <molecule *>
59#define MoleculeListTest pair <MoleculeList::iterator, bool>
60
61#define DistancePair pair < double, atom* >
62#define DistanceMap multimap < double, atom* >
63#define DistanceTestPair pair < DistanceMap::iterator, bool>
64
65
66/************************************* Class definitions ****************************************/
67
68/** Structure to contain parameters needed for evaluation of constraint potential.
69 */
70struct EvaluatePotential
71{
72 int startstep; //!< start configuration (MDStep in atom::trajectory)
73 int endstep; //!< end configuration (MDStep in atom::trajectory)
74 atom **PermutationMap; //!< gives target ptr for each atom, array of size molecule::AtomCount (this is "x" in \f$ V^{con}(x) \f$ )
75 DistanceMap **DistanceList; //!< distance list of each atom to each atom
76 DistanceMap::iterator *StepList; //!< iterator to ascend through NearestNeighbours \a **DistanceList
77 int *DoubleList; //!< count of which sources want to move to this target, basically the injective measure (>1 -> not injective)
78 DistanceMap::iterator *DistanceIterators; //!< marks which was the last picked target as injective candidate with smallest distance
79 bool IsAngstroem; //!< whether coordinates are in angstroem (true) or bohrradius (false)
80 double *PenaltyConstants; //!< penalty constant in front of each term
81};
82
83#define MaxThermostats 6 //!< maximum number of thermostat entries in Ions#ThermostatNames and Ions#ThermostatImplemented
84enum thermostats { None, Woodcock, Gaussian, Langevin, Berendsen, NoseHoover }; //!< Thermostat names for output
85
86
87/** The complete molecule.
88 * Class incorporates number of types
89 */
90class molecule : public PointCloud , public Observable {
91 friend molecule *NewMolecule();
92 friend void DeleteMolecule(molecule *);
93
94 public:
95 typedef std::list<atom*> atomSet;
96 typedef std::set<atomId_t> atomIdSet;
97 typedef ObservedIterator<atomSet> iterator;
98 typedef atomSet::const_iterator const_iterator;
99
100 const periodentafel * const elemente; //!< periodic table with each element
101 // old deprecated atom handling
102 //atom *start; //!< start of atom list
103 //atom *end; //!< end of atom list
104 //bond *first; //!< start of bond list
105 //bond *last; //!< end of bond list
106 int MDSteps; //!< The number of MD steps in Trajectories
107 //int AtomCount; //!< number of atoms, brought up-to-date by CountAtoms()
108 int BondCount; //!< number of atoms, brought up-to-date by CountBonds()
109 int ElementCount; //!< how many unique elements are therein
110 int ElementsInMolecule[MAX_ELEMENTS]; //!< list whether element (sorted by atomic number) is alread present or not
111 mutable int NoNonHydrogen; //!< number of non-hydrogen atoms in molecule
112 mutable int NoNonBonds; //!< number of non-hydrogen bonds in molecule
113 mutable int NoCyclicBonds; //!< number of cyclic bonds in molecule, by DepthFirstSearchAnalysis()
114 double BondDistance; //!< typical bond distance used in CreateAdjacencyList() and furtheron
115 bool ActiveFlag; //!< in a MoleculeListClass used to discern active from inactive molecules
116 Vector Center; //!< Center of molecule in a global box
117 int IndexNr; //!< index of molecule in a MoleculeListClass
118 char name[MAXSTRINGSIZE]; //!< arbitrary name
119
120 private:
121 Cacheable<string> formula;
122 Cacheable<int> AtomCount;
123 moleculeId_t id;
124 atomSet atoms; //<!list of atoms
125 atomIdSet atomIds; //<!set of atomic ids to check uniqueness of atoms
126 protected:
127 //void CountAtoms();
128 /**
129 * this iterator type should be used for internal variables, \
130 * since it will not lock
131 */
132 typedef atomSet::iterator internal_iterator;
133
134
135 molecule(const periodentafel * const teil);
136 virtual ~molecule();
137
138
139public:
140 //getter and setter
141 const std::string getName();
142 int getAtomCount() const;
143 int doCountAtoms();
144 moleculeId_t getId();
145 void setId(moleculeId_t);
146 void setName(const std::string);
147 const std::string getFormula();
148 std::string calcFormula();
149
150 iterator begin();
151 const_iterator begin() const;
152 iterator end();
153 const_iterator end() const;
154 bool empty() const;
155 size_t size() const;
156 const_iterator erase( const_iterator loc );
157 const_iterator erase( atom * key );
158 const_iterator find ( atom * key ) const;
159 pair<iterator,bool> insert ( atom * const key );
160 bool containsAtom(atom* key);
161
162
163 // re-definition of virtual functions from PointCloud
164 const char * const GetName() const;
165 Vector *GetCenter() const ;
166 TesselPoint *GetPoint() const ;
167 int GetMaxId() const;
168 void GoToNext() const ;
169 void GoToFirst() const ;
170 bool IsEmpty() const ;
171 bool IsEnd() const ;
172
173 // templates for allowing global manipulation of all vectors
174 template <typename res> void ActOnAllVectors( res (Vector::*f)() ) const;
175 template <typename res> void ActOnAllVectors( res (Vector::*f)() const) const;
176 template <typename res, typename T> void ActOnAllVectors( res (Vector::*f)(T), T t ) const;
177 template <typename res, typename T> void ActOnAllVectors( res (Vector::*f)(T) const, T t ) const;
178 template <typename res, typename T> void ActOnAllVectors( res (Vector::*f)(T&), T &t ) const;
179 template <typename res, typename T> void ActOnAllVectors( res (Vector::*f)(T&) const, T &t ) const;
180 template <typename res, typename T, typename U> void ActOnAllVectors( res (Vector::*f)(T, U), T t, U u ) const;
181 template <typename res, typename T, typename U> void ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u ) const;
182 template <typename res, typename T, typename U, typename V> void ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v) const;
183 template <typename res, typename T, typename U, typename V> void ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v) const;
184
185 // templates for allowing global manipulation of molecule with each atom as single argument
186 template <typename res> void ActWithEachAtom( res (molecule::*f)(atom *) ) const;
187 template <typename res> void ActWithEachAtom( res (molecule::*f)(atom *) const) const;
188
189 // templates for allowing global copying of molecule with each atom as single argument
190 template <typename res> void ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const;
191 template <typename res> void ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const;
192
193 // templates for allowing global manipulation of all atoms
194 template <typename res, typename typ> void ActOnAllAtoms( res (typ::*f)() ) const;
195 template <typename res, typename typ> void ActOnAllAtoms( res (typ::*f)() const) const;
196 template <typename res, typename typ, typename T> void ActOnAllAtoms( res (typ::*f)(T), T t ) const;
197 template <typename res, typename typ, typename T> void ActOnAllAtoms( res (typ::*f)(T) const, T t ) const;
198 template <typename res, typename typ, typename T, typename U> void ActOnAllAtoms( res (typ::*f)(T, U), T t, U u ) const;
199 template <typename res, typename typ, typename T, typename U> void ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u ) const;
200 template <typename res, typename typ, typename T, typename U, typename V> void ActOnAllAtoms( res (typ::*f)(T, U, V), T t, U u, V v) const;
201 template <typename res, typename typ, typename T, typename U, typename V> void ActOnAllAtoms( res (typ::*f)(T, U, V) const, T t, U u, V v) const;
202 template <typename res, typename typ, typename T, typename U, typename V, typename W> void ActOnAllAtoms( res (typ::*f)(T, U, V, W), T t, U u, V v, W w) const;
203 template <typename res, typename typ, typename T, typename U, typename V, typename W> void ActOnAllAtoms( res (typ::*f)(T, U, V, W) const, T t, U u, V v, W w) const;
204
205 // templates for allowing conditional global copying of molecule with each atom as single argument
206 template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () ) const;
207 template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () const ) const;
208 template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () ) const;
209 template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () const ) const;
210 template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t ) const;
211 template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T) const, T t ) const;
212 template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T), T t ) const;
213 template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T) const, T t ) const;
214 template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const;
215 template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const;
216 template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const;
217 template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const;
218 template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const;
219 template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const;
220 template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const;
221 template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const;
222
223 // templates for allowing global manipulation of an array with one entry per atom
224 void SetIndexedArrayForEachAtomTo ( atom **array, int ParticleInfo::* index) const;
225 template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::* index, void (*Setor)(T *, T *)) const;
226 template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::* index, void (*Setor)(T *, T *), T t) const;
227 template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::* index, void (*Setor)(T *, T *), T *t) const;
228 template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::* index, void (*Setor)(T *, T *)) const;
229 template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::* index, void (*Setor)(T *, T *), T t) const;
230 template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::* index, void (*Setor)(T *, T *), T *t) const;
231 template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ atom::*value) const;
232 template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ atom::*value) const;
233 template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ &vect ) const;
234 template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ &vect ) const;
235
236 // templates for allowing global manipulation of each atom by entries in an array
237 template <typename T, typename typ, typename typ2> void SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value ) const;
238 template <typename T, typename typ> void SetAtomValueToValue ( T value, T typ::*ptr ) const;
239
240 template <typename res, typename typ> res SumPerAtom(res (typ::*f)() ) const;
241 template <typename res, typename typ> res SumPerAtom(res (typ::*f)() const ) const;
242 template <typename res, typename typ, typename T> res SumPerAtom(res (typ::*f)(T) , T t ) const;
243 template <typename res, typename typ, typename T> res SumPerAtom(res (typ::*f)(T) const, T t ) const;
244
245 /// remove atoms from molecule.
246 bool AddAtom(atom *pointer);
247 bool RemoveAtom(atom *pointer);
248 bool UnlinkAtom(atom *pointer);
249 bool CleanupMolecule();
250
251 /// Add/remove atoms to/from molecule.
252 atom * AddCopyAtom(atom *pointer);
253 bool AddXYZFile(string filename);
254 bool AddHydrogenReplacementAtom(bond *Bond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bool IsAngstroem);
255 bond * AddBond(atom *first, atom *second, int degree = 1);
256 bool RemoveBond(bond *pointer);
257 bool RemoveBonds(atom *BondPartner);
258 bool hasBondStructure();
259 unsigned int CountBonds() const;
260
261 /// Find atoms.
262 atom * FindAtom(int Nr) const;
263 atom * AskAtom(string text);
264
265 /// Count and change present atoms' coordination.
266 void CountElements();
267 void CalculateOrbitals(class config &configuration);
268 bool CenterInBox();
269 bool BoundInBox();
270 void CenterEdge(Vector *max);
271 void CenterOrigin();
272 void CenterPeriodic();
273 void CenterAtVector(Vector *newcenter);
274 void Translate(const Vector *x);
275 void TranslatePeriodically(const Vector *trans);
276 void Mirror(const Vector *x);
277 void Align(Vector *n);
278 void Scale(const double ** const factor);
279 void DeterminePeriodicCenter(Vector &center);
280 Vector * DetermineCenterOfGravity();
281 Vector * DetermineCenterOfAll() const;
282 Vector * DetermineCenterOfBox() const;
283 void SetNameFromFilename(const char *filename);
284 void SetBoxDimension(Vector *dim);
285 void ScanForPeriodicCorrection();
286 bool VerletForceIntegration(char *file, config &configuration);
287 void Thermostats(config &configuration, double ActualTemp, int Thermostat);
288 void PrincipalAxisSystem(bool DoRotate);
289 double VolumeOfConvexEnvelope(bool IsAngstroem);
290
291 double ConstrainedPotential(struct EvaluatePotential &Params);
292 double MinimiseConstrainedPotential(atom **&permutation, int startstep, int endstep, bool IsAngstroem);
293 void EvaluateConstrainedForces(int startstep, int endstep, atom **PermutationMap, ForceMatrix *Force);
294 bool LinearInterpolationBetweenConfiguration(int startstep, int endstep, const char *prefix, config &configuration, bool MapByIdentity);
295
296 bool CheckBounds(const Vector *x) const;
297 void GetAlignvector(struct lsq_params * par) const;
298
299 /// Initialising routines in fragmentation
300 void CreateAdjacencyListFromDbondFile(ifstream *output);
301 void CreateAdjacencyList(double bonddistance, bool IsAngstroem, void (BondGraph::*f)(BondedParticle * const , BondedParticle * const , double &, double &, bool), BondGraph *BG = NULL);
302 int CorrectBondDegree() const;
303 void OutputBondsList() const;
304 void CyclicBondAnalysis() const;
305 void OutputGraphInfoPerAtom() const;
306 void OutputGraphInfoPerBond() const;
307
308
309 // Graph analysis
310 MoleculeLeafClass * DepthFirstSearchAnalysis(class StackClass<bond *> *&BackEdgeStack) const;
311 void CyclicStructureAnalysis(class StackClass<bond *> *BackEdgeStack, int *&MinimumRingSize) const;
312 bool PickLocalBackEdges(atom **ListOfLocalAtoms, class StackClass<bond *> *&ReferenceStack, class StackClass<bond *> *&LocalStack) const;
313 bond * FindNextUnused(atom *vertex) const;
314 void SetNextComponentNumber(atom *vertex, int nr) const;
315 void ResetAllBondsToUnused() const;
316 int CountCyclicBonds();
317 bool CheckForConnectedSubgraph(KeySet *Fragment);
318 string GetColor(enum Shading color) const;
319 bond * CopyBond(atom *left, atom *right, bond *CopyBond);
320
321
322 molecule *CopyMolecule();
323 molecule* CopyMoleculeFromSubRegion(const Vector offset, const double *parallelepiped) const;
324
325 /// Fragment molecule by two different approaches:
326 int FragmentMolecule(int Order, config *configuration);
327 bool CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, char *path = NULL);
328 bool StoreBondsToFile(char *path, char *filename);
329 bool StoreAdjacencyToFile(char *path, char *filename);
330 bool CheckAdjacencyFileAgainstMolecule(char *path, atom **ListOfAtoms);
331 bool ParseOrderAtSiteFromFile(char *path);
332 bool StoreOrderAtSiteFile(char *path);
333 bool StoreForcesFile(MoleculeListClass *BondFragments, char *path, int *SortIndex);
334 bool CreateMappingLabelsToConfigSequence(int *&SortIndex);
335 bool CreateFatherLookupTable(atom **&LookupTable, int count = 0);
336 void BreadthFirstSearchAdd(molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem);
337 /// -# BOSSANOVA
338 void FragmentBOSSANOVA(Graph *&FragmentList, KeyStack &RootStack, int *MinimumRingSize);
339 int PowerSetGenerator(int Order, struct UniqueFragments &FragmentSearch, KeySet RestrictedKeySet);
340 bool BuildInducedSubgraph(const molecule *Father);
341 molecule * StoreFragmentFromKeySet(KeySet &Leaflet, bool IsAngstroem);
342 void SPFragmentGenerator(struct UniqueFragments *FragmentSearch, int RootDistance, bond **BondsSet, int SetDimension, int SubOrder);
343 int LookForRemovalCandidate(KeySet *&Leaf, int *&ShortestPathList);
344 int GuesstimateFragmentCount(int order);
345
346 // Recognize doubly appearing molecules in a list of them
347 int * IsEqualToWithinThreshold(molecule *OtherMolecule, double threshold);
348 int * GetFatherSonAtomicMap(molecule *OtherMolecule);
349
350 // Output routines.
351 bool Output(ofstream * const output);
352 bool OutputTrajectories(ofstream * const output);
353 void OutputListOfBonds() const;
354 bool OutputXYZ(ofstream * const output) const;
355 bool OutputTrajectoriesXYZ(ofstream * const output);
356 bool Checkout(ofstream * const output) const;
357 bool OutputTemperatureFromTrajectories(ofstream * const output, int startstep, int endstep);
358
359 // Manipulation routines
360 void flipActiveFlag();
361
362 private:
363 int last_atom; //!< number given to last atom
364 mutable internal_iterator InternalPointer; //!< internal pointer for PointCloud
365};
366
367molecule *NewMolecule();
368void DeleteMolecule(molecule* mol);
369
370#include "molecule_template.hpp"
371
372/** A list of \a molecule classes.
373 */
374class MoleculeListClass : public Observable {
375 public:
376 MoleculeList ListOfMolecules; //!< List of the contained molecules
377 int MaxIndex;
378
379 MoleculeListClass(World *world);
380 ~MoleculeListClass();
381
382 bool AddHydrogenCorrection(char *path);
383 bool StoreForcesFile(char *path, int *SortIndex);
384 void insert(molecule *mol);
385 void erase(molecule *mol);
386 molecule * ReturnIndex(int index);
387 bool OutputConfigForListOfFragments(config *configuration, int *SortIndex);
388 int NumberOfActiveMolecules();
389 void Enumerate(ostream *out);
390 void Output(ofstream *out);
391 void DissectMoleculeIntoConnectedSubgraphs(const periodentafel * const periode, config * const configuration);
392 int CountAllAtoms() const;
393
394 // Methods moved here from the menus
395 // TODO: more refactoring needed on these methods
396 void flipChosen();
397 void createNewMolecule(periodentafel *periode);
398 void loadFromXYZ(periodentafel *periode);
399 void setMoleculeFilename();
400 void parseXYZIntoMolecule();
401 void eraseMolecule();
402
403
404 // merging of molecules
405 bool SimpleMerge(molecule *mol, molecule *srcmol);
406 bool SimpleAdd(molecule *mol, molecule *srcmol);
407 bool SimpleMultiMerge(molecule *mol, int *src, int N);
408 bool SimpleMultiAdd(molecule *mol, int *src, int N);
409 bool ScatterMerge(molecule *mol, int *src, int N);
410 bool EmbedMerge(molecule *mol, molecule *srcmol);
411
412 private:
413 World *world; //!< The world this List belongs to. Needed to avoid deadlocks in the destructor
414};
415
416
417/** A leaf for a tree of \a molecule class
418 * Wraps molecules in a tree structure
419 */
420class MoleculeLeafClass {
421 public:
422 molecule *Leaf; //!< molecule of this leaf
423 //MoleculeLeafClass *UpLeaf; //!< Leaf one level up
424 //MoleculeLeafClass *DownLeaf; //!< First leaf one level down
425 MoleculeLeafClass *previous; //!< Previous leaf on this level
426 MoleculeLeafClass *next; //!< Next leaf on this level
427
428 //MoleculeLeafClass(MoleculeLeafClass *Up, MoleculeLeafClass *Previous);
429 MoleculeLeafClass(MoleculeLeafClass *PreviousLeaf);
430 ~MoleculeLeafClass();
431
432 bool AddLeaf(molecule *ptr, MoleculeLeafClass *Previous);
433 bool FillBondStructureFromReference(const molecule * const reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList = false);
434 bool FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter);
435 bool AssignKeySetsToFragment(molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList = false);
436 bool FillListOfLocalAtoms(atom ***&ListOfLocalAtoms, const int FragmentCounter, const int GlobalAtomCount, bool &FreeList);
437 void TranslateIndicesToGlobalIDs(Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets, Graph &TotalGraph);
438 int Count() const;
439};
440
441
442#endif /*MOLECULES_HPP_*/
443
Note: See TracBrowser for help on using the repository browser.