source: src/molecule.hpp@ c38826

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 c38826 was e4afb4, checked in by Frederik Heber <heber@…>, 14 years ago

Huge refactoring: Introduction of Traits to Actions.

This change is really big but the introduction of the Trait concept (at least
in its current light form) is so fundamental that lots of pieces had to be
changed in order to get everything working.

The main point why it was necessary to add these traits in the first place was
to comfortably allow for adding extension of Actions information-wise, i.e.
with stuff that is only important for the QtUI, such as icons, or tooltips, ...
This extra information should not be stored with Action itself, as it has
nothing to do with the workings of the Action. And neither should it get
stored with some blown-out-of-proportions MapOfActions class ...

The gist of the change is as follows:

  • OptionTrait contains the token, description, shortform and type of an option, such as ("position", "position in space, none, typeid(Vector)).
  • ActionTrait is the derived form for actions where additionally MenuPosition and MenuName are stored (and probably more to come for the GUI), also we have a set of OptionTrait instances, one for each option of the Action.
  • Action then contains this ActionTrait, specialized for each Action.
  • the preprocessor macros have been enhanced to gather all this information from the .def files.
  • MapOfActions is gone. Completely. Most of its use was to store this extra information and the ValueStorage part now is just in class ValueStorage.
  • ValueStorage is no more an interface to MapOfActions but as the name says a (type-safe) ValueStorage.

Listing the (remaining) changes in alphabetical order of the class:

  • Action
    • member value ::name dropped, ::getName() uses ActionTraits::getName()
    • new define NODEFAULT which is used in paramdefaults in .def files
    • all derived actions classes such as Process, Calculations, MakroAction,... have been adapated to use the ActionTrait concept as well.
  • ActionHistory
    • extraced RedoAction and UndoAction, shifted implementation into their own object files and they use .def files as well (i.e. streamlined with method used for other actions)
  • MenuDescription
    • contain information on Menus such as name, ...
    • new unit test checks for consistency
  • molecule
    • const member functions: Copy(), Output() and OutputBonds()
  • OptionRegistry
    • new registry class for options only
    • we want the same type throughout the code for each token, e.g. "position"
    • the registry containts checks for consistency
  • OptionTrait
    • default values are specified in paramdefaults, none are given by NODEFAULT
    • introduced default for translate-atoms, point-correlation, pair-correlation
  • Registry pattern
    • new unit test, but only sceleton code so far
  • ...Query, also ...Pipe
    • atoms, molecule and elements are now all const
    • also ValueStorage's signatures all have const therein
  • ValueStorage
    • set/queryCurrentValue from MapOfActions
    • at times VectorValue has been in .def files where Vector was in the signature. This is cleared. Such stuff is only present for e.g. BoxVector being queried as a Vector. But this is a feature and intended.
  • World
    • most of the (un)selection functions now work on const atoms and molecules
    • in one case we need a const_cast to remove this, but this is intentional, as the vector of selected atoms stores non-const pointers and this is ok.

There is only one test which had to be changed slightly because a specific
option token as "position" must now have the same type everywhere, e.g. always
Vector.

  • TESTFIX: Simple_configuration/2: --position -> --domain-position (and associated to BoxVector)
  • Property mode set to 100755
File size: 13.3 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
9/*********************************************** includes ***********************************/
10
11#ifdef HAVE_CONFIG_H
12#include <config.h>
13#endif
14
15//// STL headers
16#include <map>
17#include <set>
18#include <deque>
19#include <list>
20#include <vector>
21
22#include <string>
23
24#include "types.hpp"
25#include "graph.hpp"
26#include "PointCloud.hpp"
27#include "Patterns/Observer.hpp"
28#include "Patterns/ObservedIterator.hpp"
29#include "Patterns/Cacheable.hpp"
30#include "Formula.hpp"
31#include "AtomSet.hpp"
32
33#include "Descriptors/MoleculeDescriptor_impl.hpp"
34
35/****************************************** forward declarations *****************************/
36
37class atom;
38class bond;
39class BondedParticle;
40class BondGraph;
41class element;
42class ForceMatrix;
43class LinkedCell;
44class molecule;
45class MoleculeLeafClass;
46class MoleculeListClass;
47class periodentafel;
48class Vector;
49class Shape;
50template <class> class StackClass;
51
52/******************************** Some definitions for easier reading **********************************/
53
54#define MoleculeList list <molecule *>
55#define MoleculeListTest pair <MoleculeList::iterator, bool>
56
57#define DistancePair pair < double, atom* >
58#define DistanceMap multimap < double, atom* >
59#define DistanceTestPair pair < DistanceMap::iterator, bool>
60
61
62/************************************* Class definitions ****************************************/
63
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};
78
79/** The complete molecule.
80 * Class incorporates number of types
81 */
82class molecule : public PointCloud, public Observable
83{
84 friend molecule *NewMolecule();
85 friend void DeleteMolecule(molecule *);
86
87public:
88 typedef ATOMSET(std::list) atomSet;
89 typedef std::set<atomId_t> atomIdSet;
90 typedef ObservedIterator<atomSet> iterator;
91 typedef atomSet::const_iterator const_iterator;
92
93 const periodentafel * const elemente; //!< periodic table with each element
94 // old deprecated atom handling
95 //atom *start; //!< start of atom list
96 //atom *end; //!< end of atom list
97 //bond *first; //!< start of bond list
98 //bond *last; //!< end of bond list
99 int MDSteps; //!< The number of MD steps in Trajectories
100 //int AtomCount; //!< number of atoms, brought up-to-date by CountAtoms()
101 int BondCount; //!< number of atoms, brought up-to-date by CountBonds()
102 mutable int NoNonHydrogen; //!< number of non-hydrogen atoms in molecule
103 mutable int NoNonBonds; //!< number of non-hydrogen bonds in molecule
104 mutable int NoCyclicBonds; //!< number of cyclic bonds in molecule, by DepthFirstSearchAnalysis()
105 double BondDistance; //!< typical bond distance used in CreateAdjacencyList() and furtheron
106 bool ActiveFlag; //!< in a MoleculeListClass used to discern active from inactive molecules
107 //Vector Center; //!< Center of molecule in a global box
108 int IndexNr; //!< index of molecule in a MoleculeListClass
109 char name[MAXSTRINGSIZE]; //!< arbitrary name
110
111private:
112 Formula formula;
113 Cacheable<int> AtomCount;
114 moleculeId_t id;
115 atomSet atoms; //<!list of atoms
116 atomIdSet atomIds; //<!set of atomic ids to check uniqueness of atoms
117protected:
118 //void CountAtoms();
119 /**
120 * this iterator type should be used for internal variables, \
121 * since it will not lock
122 */
123 typedef atomSet::iterator internal_iterator;
124
125 molecule(const periodentafel * const teil);
126 virtual ~molecule();
127
128public:
129 //getter and setter
130 const std::string getName() const;
131 int getAtomCount() const;
132 int doCountAtoms();
133 moleculeId_t getId() const;
134 void setId(moleculeId_t);
135 void setName(const std::string);
136 const Formula &getFormula() const;
137 unsigned int getElementCount() const;
138 bool hasElement(const element*) const;
139 bool hasElement(atomicNumber_t) const;
140 bool hasElement(const std::string&) const;
141
142 virtual bool changeId(atomId_t newId);
143
144 TesselPoint * getValue(const_iterator &rhs) const;
145 TesselPoint * getValue(iterator &rhs) const;
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 // re-definition of virtual functions from PointCloud
159 const char * const GetName() const;
160 Vector *GetCenter() const;
161 TesselPoint *GetPoint() const;
162 int GetMaxId() const;
163 void GoToNext() const;
164 void GoToFirst() const;
165 bool IsEmpty() const;
166 bool IsEnd() const;
167
168 /// remove atoms from molecule.
169 bool AddAtom(atom *pointer);
170 bool RemoveAtom(atom *pointer);
171 bool UnlinkAtom(atom *pointer);
172 bool CleanupMolecule();
173
174 /// Add/remove atoms to/from molecule.
175 atom * AddCopyAtom(atom *pointer);
176 bool AddXYZFile(string filename);
177 bool AddHydrogenReplacementAtom(bond *Bond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bool IsAngstroem);
178 bond * AddBond(atom *first, atom *second, int degree = 1);
179 bool RemoveBond(bond *pointer);
180 bool RemoveBonds(atom *BondPartner);
181 bool hasBondStructure() const;
182 unsigned int CountBonds() const;
183
184 /// Find atoms.
185 atom * FindAtom(int Nr) const;
186 atom * AskAtom(string text);
187
188 /// Count and change present atoms' coordination.
189 bool CenterInBox();
190 bool BoundInBox();
191 void CenterEdge(Vector *max);
192 void CenterOrigin();
193 void CenterPeriodic();
194 void CenterAtVector(Vector *newcenter);
195 void Translate(const Vector *x);
196 void TranslatePeriodically(const Vector *trans);
197 void Mirror(const Vector *x);
198 void Align(Vector *n);
199 void Scale(const double ** const factor);
200 void DeterminePeriodicCenter(Vector &center);
201 Vector * DetermineCenterOfGravity() const;
202 Vector * DetermineCenterOfAll() const;
203 Vector * DetermineCenterOfBox() const;
204 void SetNameFromFilename(const char *filename);
205 void SetBoxDimension(Vector *dim);
206 void ScanForPeriodicCorrection();
207 bool VerletForceIntegration(char *file, config &configuration, const size_t offset);
208 double VolumeOfConvexEnvelope(bool IsAngstroem);
209
210 double ConstrainedPotential(struct EvaluatePotential &Params);
211 double MinimiseConstrainedPotential(atom **&permutation, int startstep, int endstep, bool IsAngstroem);
212 void EvaluateConstrainedForces(int startstep, int endstep, atom **PermutationMap, ForceMatrix *Force);
213 bool LinearInterpolationBetweenConfiguration(int startstep, int endstep, std::string prefix, config &configuration, bool MapByIdentity);
214
215 bool CheckBounds(const Vector *x) const;
216 void GetAlignvector(struct lsq_params * par) const;
217
218 /// Initialising routines in fragmentation
219 void CreateAdjacencyListFromDbondFile(ifstream *output);
220 void CreateAdjacencyList(double bonddistance, bool IsAngstroem, void(BondGraph::*f)(BondedParticle * const , BondedParticle * const , double &, double &, bool), BondGraph *BG = NULL);
221 int CorrectBondDegree() const;
222 void OutputBondsList() const;
223 void CyclicBondAnalysis() const;
224 void OutputGraphInfoPerAtom() const;
225 void OutputGraphInfoPerBond() const;
226
227 // Graph analysis
228 MoleculeLeafClass * DepthFirstSearchAnalysis(class StackClass<bond *> *&BackEdgeStack) const;
229 void CyclicStructureAnalysis(class StackClass<bond *> *BackEdgeStack, int *&MinimumRingSize) const;
230 bool PickLocalBackEdges(atom **ListOfLocalAtoms, class StackClass<bond *> *&ReferenceStack, class StackClass<bond *> *&LocalStack) const;
231 bond * FindNextUnused(atom *vertex) const;
232 void SetNextComponentNumber(atom *vertex, int nr) const;
233 void ResetAllBondsToUnused() const;
234 int CountCyclicBonds();
235 bool CheckForConnectedSubgraph(KeySet *Fragment);
236 string GetColor(enum Shading color) const;
237 bond * CopyBond(atom *left, atom *right, bond *CopyBond);
238
239 molecule *CopyMolecule() const;
240 molecule* CopyMoleculeFromSubRegion(const Shape&) const;
241
242 /// Fragment molecule by two different approaches:
243 int FragmentMolecule(int Order, std::string &prefix);
244 bool CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, std::string path = "");
245 bool StoreBondsToFile(std::string filename, std::string path = "");
246 bool StoreAdjacencyToFile(std::string filename, std::string path = "");
247 bool CheckAdjacencyFileAgainstMolecule(std::string &path, atom **ListOfAtoms);
248 bool ParseOrderAtSiteFromFile(std::string &path);
249 bool StoreOrderAtSiteFile(std::string &path);
250 bool StoreForcesFile(MoleculeListClass *BondFragments, std::string &path, int *SortIndex);
251 bool CreateMappingLabelsToConfigSequence(int *&SortIndex);
252 bool CreateFatherLookupTable(atom **&LookupTable, int count = 0);
253 void BreadthFirstSearchAdd(molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem);
254 /// -# BOSSANOVA
255 void FragmentBOSSANOVA(Graph *&FragmentList, KeyStack &RootStack, int *MinimumRingSize);
256 int PowerSetGenerator(int Order, struct UniqueFragments &FragmentSearch, KeySet RestrictedKeySet);
257 bool BuildInducedSubgraph(const molecule *Father);
258 molecule * StoreFragmentFromKeySet(KeySet &Leaflet, bool IsAngstroem);
259 void SPFragmentGenerator(struct UniqueFragments *FragmentSearch, int RootDistance, bond **BondsSet, int SetDimension, int SubOrder);
260 int LookForRemovalCandidate(KeySet *&Leaf, int *&ShortestPathList);
261 int GuesstimateFragmentCount(int order);
262
263 // Recognize doubly appearing molecules in a list of them
264 int * GetFatherSonAtomicMap(molecule *OtherMolecule);
265
266 // Output routines.
267 bool Output(std::ostream * const output) const;
268 bool OutputTrajectories(ofstream * const output) const;
269 void OutputListOfBonds() const;
270 bool OutputXYZ(ofstream * const output) const;
271 bool OutputTrajectoriesXYZ(ofstream * const output);
272 bool Checkout(ofstream * const output) const;
273 bool OutputTemperatureFromTrajectories(ofstream * const output, int startstep, int endstep);
274
275 // Manipulation routines
276 void flipActiveFlag();
277
278private:
279 void init_DFS(struct DFSAccounting&) const;
280 int last_atom; //!< number given to last atom
281 mutable internal_iterator InternalPointer; //!< internal pointer for PointCloud
282};
283
284molecule *NewMolecule();
285void DeleteMolecule(molecule* mol);
286
287/** A list of \a molecule classes.
288 */
289class MoleculeListClass : public Observable
290{
291public:
292 MoleculeList ListOfMolecules; //!< List of the contained molecules
293 int MaxIndex;
294
295 MoleculeListClass(World *world);
296 ~MoleculeListClass();
297
298 bool AddHydrogenCorrection(std::string &path);
299 bool StoreForcesFile(std::string &path, int *SortIndex);
300 void insert(molecule *mol);
301 void erase(molecule *mol);
302 molecule * ReturnIndex(int index);
303 bool OutputConfigForListOfFragments(std::string &prefix, int *SortIndex);
304 int NumberOfActiveMolecules();
305 void Enumerate(ostream *out);
306 void Output(ofstream *out);
307 int CountAllAtoms() const;
308
309 // Methods moved here from the menus
310 // TODO: more refactoring needed on these methods
311 void createNewMolecule(periodentafel *periode);
312 void loadFromXYZ(periodentafel *periode);
313 void setMoleculeFilename();
314 void parseXYZIntoMolecule();
315 void eraseMolecule();
316
317private:
318 World *world; //!< The world this List belongs to. Needed to avoid deadlocks in the destructor
319};
320
321/** A leaf for a tree of \a molecule class
322 * Wraps molecules in a tree structure
323 */
324class MoleculeLeafClass
325{
326public:
327 molecule *Leaf; //!< molecule of this leaf
328 //MoleculeLeafClass *UpLeaf; //!< Leaf one level up
329 //MoleculeLeafClass *DownLeaf; //!< First leaf one level down
330 MoleculeLeafClass *previous; //!< Previous leaf on this level
331 MoleculeLeafClass *next; //!< Next leaf on this level
332
333 //MoleculeLeafClass(MoleculeLeafClass *Up, MoleculeLeafClass *Previous);
334 MoleculeLeafClass(MoleculeLeafClass *PreviousLeaf);
335 ~MoleculeLeafClass();
336
337 bool AddLeaf(molecule *ptr, MoleculeLeafClass *Previous);
338 bool FillBondStructureFromReference(const molecule * const reference, atom **&ListOfLocalAtoms, bool FreeList = false);
339 bool FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter);
340 bool AssignKeySetsToFragment(molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList = false);
341 bool FillListOfLocalAtoms(atom **&ListOfLocalAtoms, const int GlobalAtomCount, bool &FreeList);
342 void TranslateIndicesToGlobalIDs(Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets, Graph &TotalGraph);
343 int Count() const;
344};
345
346#endif /*MOLECULES_HPP_*/
347
Note: See TracBrowser for help on using the repository browser.