source: src/molecule.hpp@ 835a0f

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 835a0f was 568be7, checked in by Frederik Heber <heber@…>, 15 years ago

Added config::SavePDB() and config::SaveMPQC().

  • note: for CODICE we need to know about the different connected subgraphs created by the DFSAnalysis(). Hence, we write a pdb file which contains a resid number to discern in VMD between the molecules. Also, we need neighbour construction from a simple xyz file for TREMOLO in order to measure MSDs per water molecule.
  • new function in config.cpp: config::SavePDB() gets molecule or MoleculeListClass and writes PDB file
  • new function in config.cpp: config::SaveTREMOLO() gets molecule or MoleculeListClass and writes TREMOLO data file (with neighbours, mapped to global ids, and resid and resname)
  • new function in moleculelist.cpp: MoleculeListClass::CountAllAtoms() - counts all atoms.
  • BUGFIX: In MoleculeListClass::DissectMoleculeIntoConnectedSubgraphs() we did not shift the chained bond list from mol into the connected subgraphs. Thus, they were free'd on delete(mol) and no bonds were present afterwards. This is fixed, now we unlink() in mol and re-link() in the respective subgraph
  • Property mode set to 100755
File size: 20.0 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 "graph.hpp"
30#include "stackclass.hpp"
31#include "tesselation.hpp"
32
33/****************************************** forward declarations *****************************/
34
35class atom;
36class bond;
37class BondedParticle;
38class BondGraph;
39class element;
40class ForceMatrix;
41class LinkedCell;
42class molecule;
43class MoleculeLeafClass;
44class MoleculeListClass;
45class periodentafel;
46class Vector;
47
48/******************************** Some definitions for easier reading **********************************/
49
50#define MoleculeList list <molecule *>
51#define MoleculeListTest pair <MoleculeList::iterator, bool>
52
53#define DistancePair pair < double, atom* >
54#define DistanceMap multimap < double, atom* >
55#define DistanceTestPair pair < DistanceMap::iterator, bool>
56
57
58/************************************* Class definitions ****************************************/
59
60/** Structure to contain parameters needed for evaluation of constraint potential.
61 */
62struct EvaluatePotential
63{
64 int startstep; //!< start configuration (MDStep in atom::trajectory)
65 int endstep; //!< end configuration (MDStep in atom::trajectory)
66 atom **PermutationMap; //!< gives target ptr for each atom, array of size molecule::AtomCount (this is "x" in \f$ V^{con}(x) \f$ )
67 DistanceMap **DistanceList; //!< distance list of each atom to each atom
68 DistanceMap::iterator *StepList; //!< iterator to ascend through NearestNeighbours \a **DistanceList
69 int *DoubleList; //!< count of which sources want to move to this target, basically the injective measure (>1 -> not injective)
70 DistanceMap::iterator *DistanceIterators; //!< marks which was the last picked target as injective candidate with smallest distance
71 bool IsAngstroem; //!< whether coordinates are in angstroem (true) or bohrradius (false)
72 double *PenaltyConstants; //!< penalty constant in front of each term
73};
74
75#define MaxThermostats 6 //!< maximum number of thermostat entries in Ions#ThermostatNames and Ions#ThermostatImplemented
76enum thermostats { None, Woodcock, Gaussian, Langevin, Berendsen, NoseHoover }; //!< Thermostat names for output
77
78
79/** The complete molecule.
80 * Class incorporates number of types
81 */
82class molecule : public PointCloud {
83 public:
84 double cell_size[6];//!< cell size
85 const periodentafel * const elemente; //!< periodic table with each element
86 atom *start; //!< start of atom list
87 atom *end; //!< end of atom list
88 bond *first; //!< start of bond list
89 bond *last; //!< end of bond list
90 int MDSteps; //!< The number of MD steps in Trajectories
91 int AtomCount; //!< number of atoms, brought up-to-date by CountAtoms()
92 int BondCount; //!< number of atoms, brought up-to-date by CountBonds()
93 int ElementCount; //!< how many unique elements are therein
94 int ElementsInMolecule[MAX_ELEMENTS]; //!< list whether element (sorted by atomic number) is alread present or not
95 mutable int NoNonHydrogen; //!< number of non-hydrogen atoms in molecule
96 mutable int NoNonBonds; //!< number of non-hydrogen bonds in molecule
97 mutable int NoCyclicBonds; //!< number of cyclic bonds in molecule, by DepthFirstSearchAnalysis()
98 double BondDistance; //!< typical bond distance used in CreateAdjacencyList() and furtheron
99 bool ActiveFlag; //!< in a MoleculeListClass used to discern active from inactive molecules
100 Vector Center; //!< Center of molecule in a global box
101 char name[MAXSTRINGSIZE]; //!< arbitrary name
102 int IndexNr; //!< index of molecule in a MoleculeListClass
103
104 molecule(const periodentafel * const teil);
105 virtual ~molecule();
106
107 // re-definition of virtual functions from PointCloud
108 Vector *GetCenter() const ;
109 TesselPoint *GetPoint() const ;
110 TesselPoint *GetTerminalPoint() const ;
111 void GoToNext() const ;
112 void GoToPrevious() const ;
113 void GoToFirst() const ;
114 void GoToLast() const ;
115 bool IsEmpty() const ;
116 bool IsEnd() const ;
117
118 // templates for allowing global manipulation of all vectors
119 template <typename res> void ActOnAllVectors( res (Vector::*f)() ) const;
120 template <typename res> void ActOnAllVectors( res (Vector::*f)() const) const;
121 template <typename res, typename T> void ActOnAllVectors( res (Vector::*f)(T), T t ) const;
122 template <typename res, typename T> void ActOnAllVectors( res (Vector::*f)(T) const, T t ) const;
123 template <typename res, typename T, typename U> void ActOnAllVectors( res (Vector::*f)(T, U), T t, U u ) const;
124 template <typename res, typename T, typename U> void ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u ) const;
125 template <typename res, typename T, typename U, typename V> void ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v) const;
126 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;
127
128 // templates for allowing global manipulation of molecule with each atom as single argument
129 template <typename res> void ActWithEachAtom( res (molecule::*f)(atom *) ) const;
130 template <typename res> void ActWithEachAtom( res (molecule::*f)(atom *) const) const;
131
132 // templates for allowing global copying of molecule with each atom as single argument
133 template <typename res> void ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const;
134 template <typename res> void ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const;
135
136 // templates for allowing global manipulation of all atoms
137 template <typename res, typename typ> void ActOnAllAtoms( res (typ::*f)() ) const;
138 template <typename res, typename typ> void ActOnAllAtoms( res (typ::*f)() const) const;
139 template <typename res, typename typ, typename T> void ActOnAllAtoms( res (typ::*f)(T), T t ) const;
140 template <typename res, typename typ, typename T> void ActOnAllAtoms( res (typ::*f)(T) const, T t ) const;
141 template <typename res, typename typ, typename T, typename U> void ActOnAllAtoms( res (typ::*f)(T, U), T t, U u ) const;
142 template <typename res, typename typ, typename T, typename U> void ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u ) const;
143 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;
144 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;
145 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;
146 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;
147
148 // templates for allowing conditional global copying of molecule with each atom as single argument
149 template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () ) const;
150 template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () const ) const;
151 template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () ) const;
152 template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () const ) const;
153 template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t ) const;
154 template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T) const, T t ) const;
155 template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T), T t ) const;
156 template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) (T) const, T t ) const;
157 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;
158 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;
159 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;
160 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;
161 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;
162 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;
163 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;
164 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;
165
166 // templates for allowing global manipulation of an array with one entry per atom
167 void SetIndexedArrayForEachAtomTo ( atom **array, int ParticleInfo::* index) const;
168 template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::* index, void (*Setor)(T *, T *)) const;
169 template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::* index, void (*Setor)(T *, T *), T t) const;
170 template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::* index, void (*Setor)(T *, T *), T *t) const;
171 template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::* index, void (*Setor)(T *, T *)) const;
172 template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::* index, void (*Setor)(T *, T *), T t) const;
173 template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::* index, void (*Setor)(T *, T *), T *t) const;
174 template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ atom::*value) const;
175 template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ atom::*value) const;
176 template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ &vect ) const;
177 template <typename T, typename typ> void SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ &vect ) const;
178
179 // templates for allowing global manipulation of each atom by entries in an array
180 template <typename T, typename typ, typename typ2> void SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value ) const;
181 template <typename T, typename typ> void SetAtomValueToValue ( T value, T typ::*ptr ) const;
182
183 template <typename res, typename typ> res SumPerAtom(res (typ::*f)() ) const;
184 template <typename res, typename typ> res SumPerAtom(res (typ::*f)() const ) const;
185 template <typename res, typename typ, typename T> res SumPerAtom(res (typ::*f)(T) , T t ) const;
186 template <typename res, typename typ, typename T> res SumPerAtom(res (typ::*f)(T) const, T t ) const;
187
188 /// remove atoms from molecule.
189 bool AddAtom(atom *pointer);
190 bool RemoveAtom(atom *pointer);
191 bool UnlinkAtom(atom *pointer);
192 bool CleanupMolecule();
193
194 /// Add/remove atoms to/from molecule.
195 atom * AddCopyAtom(atom *pointer);
196 bool AddXYZFile(string filename);
197 bool AddHydrogenReplacementAtom(bond *Bond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bool IsAngstroem);
198 bond * AddBond(atom *first, atom *second, int degree = 1);
199 bool RemoveBond(bond *pointer);
200 bool RemoveBonds(atom *BondPartner);
201
202 /// Find atoms.
203 atom * FindAtom(int Nr) const;
204 atom * AskAtom(string text);
205
206 /// Count and change present atoms' coordination.
207 void CountAtoms();
208 void CountElements();
209 void CalculateOrbitals(class config &configuration);
210 bool CenterInBox();
211 bool BoundInBox();
212 void CenterEdge(Vector *max);
213 void CenterOrigin();
214 void CenterPeriodic();
215 void CenterAtVector(Vector *newcenter);
216 void Translate(const Vector *x);
217 void TranslatePeriodically(const Vector *trans);
218 void Mirror(const Vector *x);
219 void Align(Vector *n);
220 void Scale(const double ** const factor);
221 void DeterminePeriodicCenter(Vector &center);
222 Vector * DetermineCenterOfGravity();
223 Vector * DetermineCenterOfAll() const;
224 void SetNameFromFilename(const char *filename);
225 void SetBoxDimension(Vector *dim);
226 void ScanForPeriodicCorrection();
227 bool VerletForceIntegration(char *file, config &configuration);
228 void Thermostats(config &configuration, double ActualTemp, int Thermostat);
229 void PrincipalAxisSystem(bool DoRotate);
230 double VolumeOfConvexEnvelope(bool IsAngstroem);
231
232 double ConstrainedPotential(struct EvaluatePotential &Params);
233 double MinimiseConstrainedPotential(atom **&permutation, int startstep, int endstep, bool IsAngstroem);
234 void EvaluateConstrainedForces(int startstep, int endstep, atom **PermutationMap, ForceMatrix *Force);
235 bool LinearInterpolationBetweenConfiguration(int startstep, int endstep, const char *prefix, config &configuration, bool MapByIdentity);
236
237 bool CheckBounds(const Vector *x) const;
238 void GetAlignvector(struct lsq_params * par) const;
239
240 /// Initialising routines in fragmentation
241 void CreateAdjacencyListFromDbondFile(ifstream *output);
242 void CreateAdjacencyList(double bonddistance, bool IsAngstroem, void (BondGraph::*f)(BondedParticle * const , BondedParticle * const , double &, double &, bool), BondGraph *BG = NULL);
243 int CorrectBondDegree() const;
244 void OutputBondsList() const;
245 void CyclicBondAnalysis() const;
246 void OutputGraphInfoPerAtom() const;
247 void OutputGraphInfoPerBond() const;
248
249
250 // Graph analysis
251 MoleculeLeafClass * DepthFirstSearchAnalysis(class StackClass<bond *> *&BackEdgeStack) const;
252 void CyclicStructureAnalysis(class StackClass<bond *> *BackEdgeStack, int *&MinimumRingSize) const;
253 bool PickLocalBackEdges(atom **ListOfLocalAtoms, class StackClass<bond *> *&ReferenceStack, class StackClass<bond *> *&LocalStack) const;
254 bond * FindNextUnused(atom *vertex) const;
255 void SetNextComponentNumber(atom *vertex, int nr) const;
256 void ResetAllBondsToUnused() const;
257 int CountCyclicBonds();
258 bool CheckForConnectedSubgraph(KeySet *Fragment);
259 string GetColor(enum Shading color) const;
260 bond * CopyBond(atom *left, atom *right, bond *CopyBond);
261
262
263 molecule *CopyMolecule();
264 molecule* CopyMoleculeFromSubRegion(const Vector offset, const double *parallelepiped) const;
265
266 /// Fragment molecule by two different approaches:
267 int FragmentMolecule(int Order, config *configuration);
268 bool CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, char *path = NULL);
269 bool StoreAdjacencyToFile(char *path);
270 bool CheckAdjacencyFileAgainstMolecule(char *path, atom **ListOfAtoms);
271 bool ParseOrderAtSiteFromFile(char *path);
272 bool StoreOrderAtSiteFile(char *path);
273 bool StoreForcesFile(MoleculeListClass *BondFragments, char *path, int *SortIndex);
274 bool CreateMappingLabelsToConfigSequence(int *&SortIndex);
275 void BreadthFirstSearchAdd(molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem);
276 /// -# BOSSANOVA
277 void FragmentBOSSANOVA(Graph *&FragmentList, KeyStack &RootStack, int *MinimumRingSize);
278 int PowerSetGenerator(int Order, struct UniqueFragments &FragmentSearch, KeySet RestrictedKeySet);
279 bool BuildInducedSubgraph(const molecule *Father);
280 molecule * StoreFragmentFromKeySet(KeySet &Leaflet, bool IsAngstroem);
281 void SPFragmentGenerator(struct UniqueFragments *FragmentSearch, int RootDistance, bond **BondsSet, int SetDimension, int SubOrder);
282 int LookForRemovalCandidate(KeySet *&Leaf, int *&ShortestPathList);
283 int GuesstimateFragmentCount(int order);
284
285 // Recognize doubly appearing molecules in a list of them
286 int * IsEqualToWithinThreshold(molecule *OtherMolecule, double threshold);
287 int * GetFatherSonAtomicMap(molecule *OtherMolecule);
288
289 // Output routines.
290 bool Output(ofstream * const output);
291 bool OutputTrajectories(ofstream * const output);
292 void OutputListOfBonds() const;
293 bool OutputXYZ(ofstream * const output) const;
294 bool OutputTrajectoriesXYZ(ofstream * const output);
295 bool Checkout(ofstream * const output) const;
296 bool OutputTemperatureFromTrajectories(ofstream * const output, int startstep, int endstep);
297
298 private:
299 int last_atom; //!< number given to last atom
300 mutable atom *InternalPointer; //!< internal pointer for PointCloud
301};
302
303#include "molecule_template.hpp"
304
305/** A list of \a molecule classes.
306 */
307class MoleculeListClass {
308 public:
309 MoleculeList ListOfMolecules; //!< List of the contained molecules
310 int MaxIndex;
311
312 MoleculeListClass();
313 ~MoleculeListClass();
314
315 bool AddHydrogenCorrection(char *path);
316 bool StoreForcesFile(char *path, int *SortIndex);
317 void insert(molecule *mol);
318 molecule * ReturnIndex(int index);
319 bool OutputConfigForListOfFragments(config *configuration, int *SortIndex);
320 int NumberOfActiveMolecules();
321 void Enumerate(ofstream *out);
322 void Output(ofstream *out);
323 void DissectMoleculeIntoConnectedSubgraphs(molecule * const mol, config * const configuration);
324 int CountAllAtoms() const;
325
326 // merging of molecules
327 bool SimpleMerge(molecule *mol, molecule *srcmol);
328 bool SimpleAdd(molecule *mol, molecule *srcmol);
329 bool SimpleMultiMerge(molecule *mol, int *src, int N);
330 bool SimpleMultiAdd(molecule *mol, int *src, int N);
331 bool ScatterMerge(molecule *mol, int *src, int N);
332 bool EmbedMerge(molecule *mol, molecule *srcmol);
333
334 private:
335};
336
337
338/** A leaf for a tree of \a molecule class
339 * Wraps molecules in a tree structure
340 */
341class MoleculeLeafClass {
342 public:
343 molecule *Leaf; //!< molecule of this leaf
344 //MoleculeLeafClass *UpLeaf; //!< Leaf one level up
345 //MoleculeLeafClass *DownLeaf; //!< First leaf one level down
346 MoleculeLeafClass *previous; //!< Previous leaf on this level
347 MoleculeLeafClass *next; //!< Next leaf on this level
348
349 //MoleculeLeafClass(MoleculeLeafClass *Up, MoleculeLeafClass *Previous);
350 MoleculeLeafClass(MoleculeLeafClass *PreviousLeaf);
351 ~MoleculeLeafClass();
352
353 bool AddLeaf(molecule *ptr, MoleculeLeafClass *Previous);
354 bool FillBondStructureFromReference(const molecule * const reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList = false);
355 bool FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter);
356 bool AssignKeySetsToFragment(molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList = false);
357 bool FillListOfLocalAtoms(atom ***&ListOfLocalAtoms, const int FragmentCounter, const int GlobalAtomCount, bool &FreeList);
358 void TranslateIndicesToGlobalIDs(Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets, Graph &TotalGraph);
359 int Count() const;
360};
361
362
363#endif /*MOLECULES_HPP_*/
364
Note: See TracBrowser for help on using the repository browser.