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