source: src/molecule.hpp@ 6e5084

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

Fixed PrincipalAxisSystemAction.

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