Diff [8006eed2788de714f5d76c85a5cb7d0c5891ef58:994713afde7cd130d68e8417cfee8669e3d96182] for / – MoleCuilder

AUTHORS

r8006ee	r994713
1		Frederik Heber (heber@ins.uni-bonn.de)
	1	Tillmann Crueger (crueger@ins.uni-bonn.de)
	2	Daniel Dueck (dueck@ins.uni-bonn.de)
	3	Frederik Heber (heber@ins.uni-bonn.de)
	4	Saskia Metzler (metzler@ins.uni-bonn.de)
	5	Christian Neuen (neuen@ins.uni-bonn.de)

COPYING

-              r8006ee
+              r994713
-<<<<<<< HEAD
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-                            Preamble
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-=======
                     GNU GENERAL PUBLIC LICENSE
                        Version 2, June 1991
 …
 using it.  (Some other Free Software Foundation software is covered by
 the GNU Library General Public License instead.)  You can apply it to
->>>>>>> FETCH_HEAD
 your programs, too.
 …
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
-<<<<<<< HEAD
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-  The precise terms and conditions for copying, distribution and
-modification follow.
-                       TERMS AND CONDITIONS
-. Definitions.
-  "This License" refers to version 3 of the GNU General Public License.
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-. Source Code.
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-  The Corresponding Source for a work in source code form is that
-same work.
-. Basic Permissions.
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-. Protecting Users' Legal Rights From Anti-Circumvention Law.
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-. Conveying Verbatim Copies.
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-. Conveying Modified Source Versions.
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-. Conveying Non-Source Forms.
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-. Additional Terms.
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-. Termination.
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-. Acceptance Not Required for Having Copies.
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-. Automatic Licensing of Downstream Recipients.
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-. Patents.
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-. No Surrender of Others' Freedom.
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-. Use with the GNU Affero General Public License.
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-. Revised Versions of this License.
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-. Disclaimer of Warranty.
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-. Limitation of Liability.
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-. Interpretation of Sections 15 and 16.
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-                     END OF TERMS AND CONDITIONS
-            How to Apply These Terms to Your New Programs
-=======
 this service if you wish), that you receive source code or can get it
 if you want it, that you can change the software or use pieces of it
 …
             How to Apply These Terms to Your New Programs
->>>>>>> FETCH_HEAD
   If you develop a new program, and you want it to be of the greatest
 …
   To do so, attach the following notices to the program.  It is safest
 to attach them to the start of each source file to most effectively
-<<<<<<< HEAD
-state the exclusion of warranty; and each file should have at least
-=======
 convey the exclusion of warranty; and each file should have at least
->>>>>>> FETCH_HEAD
 the "copyright" line and a pointer to where the full notice is found.
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+<<<<<<< HEAD
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+=======
+    MoleCuilder - to create and alter molecular systems
+    Copyright (C) 2010  Frederik Heber
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
->>>>>>> FETCH_HEAD
     (at your option) any later version.
 …
     You should have received a copy of the GNU General Public License
-<<<<<<< HEAD
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-Also add information on how to contact you by electronic and paper mail.
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-=======
     along with this program; if not, write to the Free Software
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 …
 when it starts in an interactive mode:
     Gnomovision version 69, Copyright (C) year  name of author
     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+>>>>>>> FETCH_HEAD
+    MoleCuilder version ??, Copyright (C) 2010  Frederik Heber
+    MoleCuilder comes with ABSOLUTELY NO WARRANTY; for details type
+    `molecuilder --help-warranty'.
     This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+    under certain conditions; type `molecuilder --help-redistribute'
+    for details.
 The hypothetical commands `show w' and `show c' should show the appropriate
-<<<<<<< HEAD
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.
-=======
 parts of the General Public License.  Of course, the commands you use may
 be called something other than `show w' and `show c'; they could even be
 …
 necessary.  Here is a sample; alter the names:
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+  University of Bonn, hereby disclaims all copyright interest in the program
+  `MoleCuilder' (which creates molecular systems) written by Frederik Heber.
+  Frederik Heber, 17 Aug 2010
 This General Public License does not permit incorporating your program into
 …
 library.  If this is what you want to do, use the GNU Library General
 Public License instead of this License.
->>>>>>> FETCH_HEAD

README

-              r8006ee
+              r994713
+<<<<<<< HEAD
+# Project: Molecuilder
+# Project: MoleCuilder
+#
 # heber@ins.uni-bonn.de
         Molecuilder
+        MoleCuilder
 ... is a tool that started as a mean to edit pcp configuration files (adding/remvoing groups of atoms, measuring bond lengths and so forth) and has grown into the many-body fragmentation test base of a new method coined BOSSANOVA (Bond Order diSSection in an ANOVA (ANalysis Of VAriance) -like fashion). It spills out configuration files for each fragment and includes joining and analyzing programs, to put together the partial energies and forces of each fragment to the total energy and forces. It allows for a complete Born-Oppenheimer molecular dynamics run.
+=======
+# Project: ParallelCarParrinello
+# Jan Hamaekers
+# Frederik Heber
+# 2005
+#
+# File: README
+... is a tool that started as a mean to edit pcp configuration files (adding/
+removing groups of atoms, measuring bond lengths and so forth), grew forth into
+a many-body fragmentation test base of a new method coined BOSSANOVA (Bond
+Order diSSection in an ANOVA (ANalysis Of VAriance) - like fashion). It spilled
+out configuration files for each fragment and included joining and analyzing
+programs, to put together the partial energies and forces of each fragment to
+the total energy and forces. Since then it has evolved into a complete toolbox
+for creating molecular systems and worlds.
-        Electronic Structure PACKage
-Is a collection of mathematical-physical programs to calculate via various ab-initio methods
-such as density functional theory or Hartree-Fock electronic(-magnetic) properties including
-the molecular (Car&Parrinello) dynamics of a many electron system. Especially, the linear
-response of the system to a external magnetic field in a perturbation approach in terms of
-susceptibility and chemical shielding is implemented via the Density Functional Perturbation
-Theory. It was developed mainly by Jan Hamaekers (pcp) with additional code by Frederik Heber
-(dfpt part in pcp) and also Ralf Wildenhuis (Gauss) at the Institute for Numerical Simulation
-at the University of Bonn[1].
->>>>>>> FETCH_HEAD
 INSTALLATION NOTES
 ==================
-<<<<<<< HEAD
 The following packages are needed
 * GCC or alike
 * GSL (GNU Scientific Library, available at http://www.gnu.org/software/gsl)
 * Boost 1.4 or newer
-=======
-In general gcc or alike is needed to compile the sources, for more specific demands see the README files in the sub directory of each package part.
 LINKS
 =====
 [1] http://www.ins.uni-bonn.de/
->>>>>>> FETCH_HEAD

configure.ac

-              r8006ee
+              r994713
 AC_PREREQ(2.59)
 AC_INIT(Molecuilder, 1.0, heber@ins.uni-bonn.de, molecuilder)
+AC_INIT(MoleCuilder, 1.0.0, heber@ins.uni-bonn.de, molecuilder)
 AC_CONFIG_AUX_DIR(config)
 AC_CONFIG_SRCDIR([src/builder.cpp])
 …
 AC_CONFIG_MACRO_DIR([m4])
 AM_INIT_AUTOMAKE(dist-bzip2 parallel-tests)
+AM_INIT_AUTOMAKE([dist-bzip2 1.11 parallel-tests color-tests])
 # Checks for programs.
 …
 AC_PROG_CXX
 AC_PROG_CC
-# obselete by LT_INIT
-#AC_PROG_RANLIB
 AC_PROG_INSTALL
 AC_CHECK_PROG([LATEX],[latex],[latex],[:])
 …
 fi
 # add replacement/saturation hydrogen or not
+# use CppUnit TestRunner or not
 AC_ARG_ENABLE([ecut],AS_HELP_STRING([--enable-ecut],[Use ECut TestRunnerClient (default is no)]),
               [enable_ecut=$enableval], [enable_ecut=no])
 …
   AC_DEFINE(HAVE_ECUT,1, ["Use ECut TestRunnerClient instead of our own."])
   AC_SUBST(HAVE_ECUT)
+fi
+# with valgrinding testsuite or not
+AC_ARG_WITH([valgrind],AS_HELP_STRING([--with-valgrind],[Use Valgrind on the testsuite (default is no)]),
+              [with_valgrind=$withval], [with_valgrind=no])
+if test x"$with_valgrind" = xyes; then
+  AC_CHECK_HEADER([valgrind/valgrind.h],
+    [
+      # check header
+      AC_DEFINE(HAVE_VALGRIND_TESTSUITE,1, ["Use Valgrind to check the testsuite."])
+      # check path
+      AC_PATH_PROG(VALGRIND, [valgrind], [/bin/false])
+      # set variables
+      AC_SUBST(HAVE_VALGRIND_TESTSUITE)
+      AC_SUBST(VALGRIND)
+    ],
+    [
+      AC_MSG_ERROR(["Valgrind support requested but headers not available."])
+    ]
+  )
 fi

src/Actions/Action.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Action.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/ActionHistory.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ActionHistory.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/ActionRegistry.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Registry<Action>.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/ActionSequence.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ActionSequenze.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/AnalysisAction/MolecularVolumeAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MolecularVolumeAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/AnalysisAction/MolecularVolumeAction.hpp

-              r8006ee
+              r994713
 #ifndef MOLECULARVOLUMEACTION_HPP_
 #define MOLECULARVOLUMEACTION_HPP_
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Actions/Action.hpp"

src/Actions/AnalysisAction/PairCorrelationAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * PairCorrelationAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
   ofstream output;
   ofstream binoutput;
   std::vector< element *> elements;
+  std::vector<const element *> elements;
   string type;
   Vector Point;

src/Actions/AnalysisAction/PairCorrelationAction.hpp

-              r8006ee
+              r994713
 #ifndef PAIRCORRELATIONACTION_HPP_
 #define PAIRCORRELATIONACTION_HPP_
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Actions/Action.hpp"

src/Actions/AnalysisAction/PointCorrelationAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * PointCorrelationAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 #include "World.hpp"
+#include <cmath>
 #include <iostream>
 #include <string>
 …
   ofstream output;
   ofstream binoutput;
   std::vector< element *> elements;
+  std::vector<const element *> elements;
   string type;
   Vector Point;
 …
   cout << "Point to correlate to is  " << Point << endl;
   CorrelationToPointMap *correlationmap = NULL;
   for(std::vector< element *>::iterator iter = elements.begin(); iter != elements.end(); ++iter)
     cout << "element is " << (*iter)->symbol << endl;
+  for(std::vector<const element *>::iterator iter = elements.begin(); iter != elements.end(); ++iter)
+    cout << "element is " << (*iter)->getSymbol() << endl;
   std::vector<molecule*> molecules = World::getInstance().getSelectedMolecules();
   if (periodic)

src/Actions/AnalysisAction/PointCorrelationAction.hpp

-              r8006ee
+              r994713
 #ifndef POINTCORRELATIONACTION_HPP_
 #define POINTCORRELATIONACTION_HPP_
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Actions/Action.hpp"

src/Actions/AnalysisAction/PrincipalAxisSystemAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * PrincipalAxisSystemAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
       Vector x = (*iter)->getPosition();
       x -= *CenterOfGravity;
       const double mass = (*iter)->getType()->mass;
+      const double mass = (*iter)->getType()->getMass();
       InertiaTensor.at(0,0) += mass*(x[1]*x[1] + x[2]*x[2]);
       InertiaTensor.at(0,1) += mass*(-x[0]*x[1]);

src/Actions/AnalysisAction/SurfaceCorrelationAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SurfaceCorrelationAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
   ofstream output;
   ofstream binoutput;
   std::vector< element *> elements;
+  std::vector<const element *> elements;
   string type;
   Vector Point;
 …
   // find biggest molecule
   std::vector<molecule*> molecules = World::getInstance().getSelectedMolecules();
+  std::cout << "There are " << molecules.size() << " selected molecules." << std::endl;
   LCList = new LinkedCell(Boundary, LCWidth);
   FindNonConvexBorder(Boundary, TesselStruct, LCList, radius, NULL);

src/Actions/AtomAction/AddAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * AddAction.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 #include "Actions/AtomAction/AddAction.hpp"
 #include "Actions/ActionRegistry.hpp"
+#include "Descriptors/AtomIdDescriptor.hpp"
 #include "atom.hpp"
 #include "element.hpp"
 …
 #include "UIElements/Dialog.hpp"
 #include "Actions/ValueStorage.hpp"
+// memento to remember the state when undoing
+class AtomAddState : public ActionState {
+public:
+  AtomAddState(const Vector &_position, const element *_elemental, const atomId_t _id) :
+    position(_position),
+    elemental(_elemental),
+    id(_id)
+  {}
+  Vector position;
+  const element *elemental;
+  atomId_t id;
+};
 const char AtomAddAction::NAME[] = "add-atom";
 …
 Action::state_ptr AtomAddAction::performCall() {
   element * elemental = NULL;
+  const element * elemental = NULL;
   Vector position;
 …
   first->setType(elemental);
   first->setPosition(position);
   DoLog(1) && (Log() << Verbose(1) << "Adding new atom with element " << first->getType()->name << " at " << (first->getPosition()) << "." << endl);
+  DoLog(1) && (Log() << Verbose(1) << "Adding new atom with element " << first->getType()->getName() << " at " << (first->getPosition()) << "." << endl);
   // TODO: remove when all of World's atoms are stored.
   std::vector<molecule *> molecules = World::getInstance().getAllMolecules();
 …
     (*iter)->AddAtom(first);
+  }
   return Action::success;
+  return Action::state_ptr(new AtomAddState(position, elemental, first->getId()));
+}
 Action::state_ptr AtomAddAction::performUndo(Action::state_ptr _state) {
 //  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  AtomAddState *state = assert_cast<AtomAddState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  DoLog(1) && (Log() << Verbose(1) << "Removing atom with id " << state->id << "." << endl);
+  World::getInstance().destroyAtom(state->id);
+  return Action::state_ptr(_state);
+}
 Action::state_ptr AtomAddAction::performRedo(Action::state_ptr _state){
+  return Action::failure;
+  AtomAddState *state = assert_cast<AtomAddState*>(_state.get());
+  atom * first = World::getInstance().createAtom();
+  first->setType(state->elemental);
+  first->setPosition(state->position);
+  DoLog(1) && (Log() << Verbose(1) << "Re-adding new atom with element " << state->elemental->getName() << " at " << state->position << "." << endl);
+  // TODO: remove when all of World's atoms are stored.
+  std::vector<molecule *> molecules = World::getInstance().getAllMolecules();
+  if (!molecules.empty()) {
+    std::vector<molecule *>::iterator iter = molecules.begin();
+    (*iter)->AddAtom(first);
+  }
+  if (first->getId() != state->id)
+    if (!first->changeId(state->id))
+      return Action::failure;
+  return Action::state_ptr(_state);
+}
 bool AtomAddAction::canUndo() {
   return false;
+  return true;
+}
 bool AtomAddAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/AtomAction/ChangeElementAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ChangeElementAction.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 #include "Actions/AtomAction/ChangeElementAction.hpp"
 #include "Actions/ActionRegistry.hpp"
+#include "Descriptors/AtomIdDescriptor.hpp"
 #include "atom.hpp"
 #include "element.hpp"
 …
 #include <iostream>
+#include <map>
 #include <string>
 …
 #include "UIElements/Dialog.hpp"
 #include "Actions/ValueStorage.hpp"
+typedef std::map<int, const element *> ElementMap;
+// memento to remember the state when undoing
+class AtomChangeElementState : public ActionState {
+public:
+  AtomChangeElementState(ElementMap _Elements, const element *_elemental) :
+    Elements(_Elements),
+    elemental(_elemental)
+  {}
+  ElementMap Elements;
+  const element *elemental;
+};
 const char AtomChangeElementAction::NAME[] = "change-element";
 …
 Action::state_ptr AtomChangeElementAction::performCall() {
   atom *first = NULL;
   element *elemental = NULL;
+  const element *elemental;
   molecule *mol = NULL;
   ValueStorage::getInstance().queryCurrentValue(NAME, elemental);
+  // create undo state
+  ElementMap Elements;
+  for (World::AtomSelectionIterator iter = World::getInstance().beginAtomSelection(); iter != World::getInstance().endAtomSelection(); ++iter) {
+    Elements.insert(std::pair<int, const element *> (iter->second->getId(), iter->second->getType()));
+  }
+  AtomChangeElementState *UndoState = new AtomChangeElementState(Elements, elemental);
   for (World::AtomSelectionIterator iter = World::getInstance().beginAtomSelection(); iter != World::getInstance().endAtomSelection(); ++iter) {
     first = iter->second;
     DoLog(1) && (Log() << Verbose(1) << "Changing atom " << *first << " to element " << elemental->symbol << "." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "Changing atom " << *first << " to element " << *elemental << "." << endl);
     mol = first->getMolecule();
     first->removeFromMolecule(); // remove atom
 …
     mol->AddAtom(first);  // add atom to ensure correctness of formula
+  }
   return Action::success;
+  return Action::state_ptr(UndoState);
+}
 Action::state_ptr AtomChangeElementAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  AtomChangeElementState *state = assert_cast<AtomChangeElementState*>(_state.get());
+  atom *first = NULL;
+  molecule *mol = NULL;
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  for(ElementMap::const_iterator iter = state->Elements.begin(); iter != state->Elements.end(); ++iter) {
+    first = World::getInstance().getAtom(AtomById(iter->first));
+    mol = first->getMolecule();
+    first->removeFromMolecule(); // remove atom
+    first->setType(iter->second);
+    mol->AddAtom(first);  // add atom to ensure correctness of formula
+  }
+  return Action::state_ptr(_state);
+}
 Action::state_ptr AtomChangeElementAction::performRedo(Action::state_ptr _state){
+  return Action::failure;
+  AtomChangeElementState *state = assert_cast<AtomChangeElementState*>(_state.get());
+  atom *first = NULL;
+  molecule *mol = NULL;
+  for(ElementMap::const_iterator iter = state->Elements.begin(); iter != state->Elements.end(); ++iter) {
+    first = World::getInstance().getAtom(AtomById(iter->first));
+    mol = first->getMolecule();
+    first->removeFromMolecule(); // remove atom
+    first->setType(state->elemental);
+    mol->AddAtom(first);  // add atom to ensure correctness of formula
+  }
+  return Action::state_ptr(_state);
+}
 bool AtomChangeElementAction::canUndo() {
   return false;
+  return true;
+}
 bool AtomChangeElementAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/AtomAction/RemoveAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * RemoveAction.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 #include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
+#include "AtomicInfo.hpp"
 #include "Descriptors/AtomDescriptor.hpp"
 #include "Helpers/Log.hpp"
 …
 #include "UIElements/Dialog.hpp"
 #include "Actions/ValueStorage.hpp"
+// memento to remember the state when undoing
+class AtomRemoveState : public ActionState {
+public:
+  AtomRemoveState(std::vector<AtomicInfo> _Walkers) :
+    Walkers(_Walkers)
+  {}
+  std::vector<AtomicInfo> Walkers;
+};
 const char AtomRemoveAction::NAME[] = "remove-atom";
 …
   atom *first = NULL;
+  std::vector<molecule *> molecules = World::getInstance().getAllMolecules();
+  // create undo state
+  std::vector<AtomicInfo> Walkers;
+  for (World::AtomSelectionIterator iter = World::getInstance().beginAtomSelection(); iter != World::getInstance().endAtomSelection(); ++iter) {
+    Walkers.push_back(AtomicInfo(*(iter->second)));
+  }
+  AtomRemoveState *UndoState = new AtomRemoveState(Walkers);
+  // remove all selected atoms
+//  std::vector<molecule *> molecules = World::getInstance().getAllMolecules();
   for (World::AtomSelectionIterator iter = World::getInstance().beginAtomSelection(); iter != World::getInstance().endAtomSelection(); ++iter) {
     first = iter->second;
     DoLog(1) && (Log() << Verbose(1) << "Removing atom " << first->getId() << "." << endl);
     // TODO: this is not necessary when atoms and their storing to file are handled by the World
     // simply try to erase in every molecule found
     for (std::vector<molecule *>::iterator iter = molecules.begin();iter != molecules.end(); ++iter) {
       (*iter)->erase(first);
+    }
+//    // TODO: this is not necessary when atoms and their storing to file are handled by the World
+//    // simply try to erase in every molecule found
+//    for (std::vector<molecule *>::iterator iter = molecules.begin();iter != molecules.end(); ++iter) {
+//      (*iter)->erase(first);
+//    }
     World::getInstance().destroyAtom(first);
+  }
   return Action::success;
+  return Action::state_ptr(UndoState);
+}
 Action::state_ptr AtomRemoveAction::performUndo(Action::state_ptr _state) {
 //  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  AtomRemoveState *state = assert_cast<AtomRemoveState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  size_t i=0;
+  for (; i<state->Walkers.size(); ++i) {
+    // re-create the atom
+    DoLog(1) && (Log() << Verbose(1) << "Re-adding atom " << state->Walkers[i].getId() << "." << endl);
+    atom *Walker = World::getInstance().createAtom();
+    if (!state->Walkers[i].setAtom(*Walker)) {
+      DoeLog(1) && (eLog() << Verbose(1) << "Failed to set id." << endl);
+      World::getInstance().destroyAtom(Walker);
+      break;
+    }
+  }
+  if (i<state->Walkers.size()) {
+    // remove all previous ones, too
+    for (size_t j=0;j<i;++j)
+      World::getInstance().destroyAtom(state->Walkers[j].getId());
+    // and announce the failure of the undo
+    return Action::failure;
+  }
+  return Action::state_ptr(_state);
+}
 Action::state_ptr AtomRemoveAction::performRedo(Action::state_ptr _state){
+  return Action::failure;
+  AtomRemoveState *state = assert_cast<AtomRemoveState*>(_state.get());
+  // simple remove again all previously added atoms
+  for (size_t i=0; i<state->Walkers.size(); ++i) {
+    DoLog(1) && (Log() << Verbose(1) << "Re-removing atom " << state->Walkers[i].getId() << "." << endl);
+    World::getInstance().destroyAtom(state->Walkers[i].getId());
+  }
+  return Action::state_ptr(_state);
+}
 bool AtomRemoveAction::canUndo() {
   return false;
+  return true;
+}
 bool AtomRemoveAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/AtomAction/RotateAroundOriginByAngleAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * RotateAroundOriginByAngleAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
+#include <cmath>
 #include <iostream>
 #include <fstream>

src/Actions/AtomAction/TranslateAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * TranslateAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 class AtomTranslateState : public ActionState {
 public:
   AtomTranslateState(std::vector<atom*> _selectedAtoms, Vector &_v) :
+  AtomTranslateState(const std::vector<atom*> &_selectedAtoms, const Vector &_v, const bool _periodic) :
     selectedAtoms(_selectedAtoms),
+    v(_v)
+    v(_v),
+    periodic(_periodic)
   {}
   std::vector<atom*> selectedAtoms;
   Vector v;
+  bool periodic;
 };
 …
 {}
 void AtomTranslate(Vector &x) {
+void AtomTranslate(Vector &x, bool periodic = false) {
   ValueStorage::getInstance().setCurrentValue(AtomTranslateAction::NAME, x);
+  ValueStorage::getInstance().setCurrentValue("periodic", periodic);
   ActionRegistry::getInstance().getActionByName(AtomTranslateAction::NAME)->call(Action::NonInteractive);
 };
 …
   dialog->queryVector(NAME, false, ValueStorage::getInstance().getDescription(NAME));
+  dialog->queryBoolean("periodic", ValueStorage::getInstance().getDescription("periodic"));
   return dialog;
 …
 Action::state_ptr AtomTranslateAction::performCall() {
   Vector v;
+  bool periodic = false;
+  Box &domain = World::getInstance().getDomain();
   std::vector<atom *> selectedAtoms = World::getInstance().getSelectedAtoms();
   ValueStorage::getInstance().queryCurrentValue(NAME, v);
+  if (!ValueStorage::getInstance().queryCurrentValue("periodic", periodic, true))
+    periodic = false;
   // TODO: use AtomSet::translate
   for (std::vector<atom *>::iterator iter = selectedAtoms.begin(); iter != selectedAtoms.end(); ++iter) {
     *(*iter) += v;
+    if (periodic)
+      (*iter)->setPosition(domain.WrapPeriodically((*iter)->getPosition()));
+  }
+  return Action::state_ptr(new AtomTranslateState(selectedAtoms, v));
+  return Action::state_ptr(new AtomTranslateState(selectedAtoms, v, periodic));
+}
 Action::state_ptr AtomTranslateAction::performUndo(Action::state_ptr _state) {
   AtomTranslateState *state = assert_cast<AtomTranslateState*>(_state.get());
+  Box &domain = World::getInstance().getDomain();
   for (std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter) {
     *(*iter) -= state->v;
+    if (state->periodic)
+      (*iter)->setPosition(domain.WrapPeriodically((*iter)->getPosition()));
+  }
   return Action::state_ptr(new AtomTranslateState(state->selectedAtoms, state->v));
+  return Action::state_ptr(_state);
+}
 Action::state_ptr AtomTranslateAction::performRedo(Action::state_ptr _state){
   AtomTranslateState *state = assert_cast<AtomTranslateState*>(_state.get());
+  Box &domain = World::getInstance().getDomain();
   for (std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter) {
     *(*iter) += state->v;
+    if (state->periodic)
+      (*iter)->setPosition(domain.WrapPeriodically((*iter)->getPosition()));
+  }
   return Action::state_ptr(new AtomTranslateState(state->selectedAtoms, state->v));
+  return Action::state_ptr(_state);
+}

src/Actions/AtomAction/TranslateAction.hpp

r8006ee	r994713
15	15
16	16	class AtomTranslateAction : public Action {
17		friend void AtomTranslate(Vector &x);
	17	friend void AtomTranslate(Vector &x, bool periodic);
18	18
19	19	public:

src/Actions/CmdAction/BondLengthTableAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * BondLengthTableAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/CmdAction/ElementDbAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ElementDbAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/CmdAction/FastParsingAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * FastParsingAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 class CommandLineFastParsingState : public ActionState {
 public:
+  CommandLineFastParsingState(bool _bool) :
+    boolean(_bool)
+  CommandLineFastParsingState(const bool _oldvalue, const bool _newvalue) :
+    oldvalue(_oldvalue),
+    newvalue(_newvalue)
   {}
+  bool boolean;
+  bool oldvalue;
+  bool newvalue;
 };
 …
 Action::state_ptr CommandLineFastParsingAction::performCall() {
   config *configuration = World::getInstance().getConfig();
+  ValueStorage::getInstance().queryCurrentValue(NAME, configuration->FastParsing);
+  bool oldvalue = configuration->FastParsing;
+  bool newvalue;
+  ValueStorage::getInstance().queryCurrentValue(NAME, newvalue);
+  configuration->FastParsing = newvalue;
   if (configuration->FastParsing)
     DoLog(0) && (Log() << Verbose(0) << "I won't parse trajectories." << endl);
   else
     DoLog(0) && (Log() << Verbose(0) << "I will parse trajectories." << endl);
   return Action::success;
+  return Action::state_ptr(new CommandLineFastParsingState(oldvalue, newvalue));
+}
 …
   config *configuration = World::getInstance().getConfig();
+  configuration->FastParsing = state->boolean;
+  configuration->FastParsing = state->oldvalue;
+  if (configuration->FastParsing)
+    DoLog(0) && (Log() << Verbose(0) << "I won't parse trajectories." << endl);
+  else
+    DoLog(0) && (Log() << Verbose(0) << "I will parse trajectories." << endl);
   return Action::state_ptr(new CommandLineFastParsingState(!state->boolean));
+  return Action::state_ptr(_state);
+}
 Action::state_ptr CommandLineFastParsingAction::performRedo(Action::state_ptr _state){
+  return performUndo(_state);
+  CommandLineFastParsingState *state = assert_cast<CommandLineFastParsingState*>(_state.get());
+  config *configuration = World::getInstance().getConfig();
+  configuration->FastParsing = state->newvalue;
+  if (configuration->FastParsing)
+    DoLog(0) && (Log() << Verbose(0) << "I won't parse trajectories." << endl);
+  else
+    DoLog(0) && (Log() << Verbose(0) << "I will parse trajectories." << endl);
+  return Action::state_ptr(_state);
+}

src/Actions/CmdAction/HelpAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * HelpAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/CmdAction/VerboseAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * VerboseAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 class CommandLineVerboseState : public ActionState {
 public:
+  CommandLineVerboseState(int _verbosity) :
+    verbosity(_verbosity)
+  CommandLineVerboseState(const int _oldverbosity, const int _newverbosity) :
+    oldverbosity(_oldverbosity),
+    newverbosity(_newverbosity)
   {}
+  int verbosity;
+  int oldverbosity;
+  int newverbosity;
 };
 …
 Action::state_ptr CommandLineVerboseAction::performCall() {
+  int verbosity = 2;
+  int oldverbosity = getVerbosity();
+  int newverbosity = 2;
   ValueStorage::getInstance().queryCurrentValue(NAME, verbosity);
+  ValueStorage::getInstance().queryCurrentValue(NAME, newverbosity);
+  setVerbosity(verbosity);
+  DoLog(0) && (Log() << Verbose(0) << "Setting verbosity to " << verbosity << "." << endl);
+  return Action::success;
+  if (oldverbosity != newverbosity) {
+    CommandLineVerboseState *UndoState = new CommandLineVerboseState(oldverbosity, newverbosity);
+    setVerbosity(newverbosity);
+    DoLog(0) && (Log() << Verbose(0) << "Setting verbosity from " << oldverbosity << " to " << newverbosity << "." << endl);
+    return Action::state_ptr(UndoState);
+  } else {
+    DoLog(0) && (Log() << Verbose(0) << "Verbosity remains unchanged at " << oldverbosity << "." << endl);
+    return Action::failure;
+  }
+}
 …
   CommandLineVerboseState *state = assert_cast<CommandLineVerboseState*>(_state.get());
   int verbosity = 2;
   ValueStorage::getInstance().queryCurrentValue(NAME, verbosity);
+  DoLog(0) && (Log() << Verbose(0) << "Setting verbosity from " << state->newverbosity << " to " << state->oldverbosity << "." << endl);
+  setVerbosity(state->oldverbosity);
+  setVerbosity(state->verbosity);
+  return Action::state_ptr(new CommandLineVerboseState(verbosity));
+  return Action::state_ptr(_state);
+}
 Action::state_ptr CommandLineVerboseAction::performRedo(Action::state_ptr _state){
+  return performUndo(_state);
+  CommandLineVerboseState *state = assert_cast<CommandLineVerboseState*>(_state.get());
+  DoLog(0) && (Log() << Verbose(0) << "Setting verbosity from " << state->oldverbosity << " to " << state->newverbosity << "." << endl);
+  setVerbosity(state->newverbosity);
+  return Action::state_ptr(_state);
+}

src/Actions/CmdAction/VersionAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * VersionAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
   ASSERT(dialog,"No Dialog given when filling action dialog");
   dialog->queryEmpty(NAME, ESPACKVersion);
+  dialog->queryEmpty(NAME, MOLECUILDERVERSION);
   return dialog;

src/Actions/ErrorAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ErrorAction.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/FragmentationAction/DepthFirstSearchAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * DepthFirstSearchAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/FragmentationAction/FragmentationAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * FragmentationAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/FragmentationAction/SubgraphDissectionAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SubgraphDissectionAction.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 #include "Actions/FragmentationAction/SubgraphDissectionAction.hpp"
 #include "Actions/ActionRegistry.hpp"
+#include "Descriptors/AtomIdDescriptor.hpp"
 #include "Descriptors/MoleculeDescriptor.hpp"
 …
 #include "config.hpp"
 #include "Helpers/Log.hpp"
+#include "Helpers/Verbose.hpp"
 #include "molecule.hpp"
 #include "stackclass.hpp"
 …
 #include "Actions/ValueStorage.hpp"
+// memento to remember the state when undoing
+typedef std::map< moleculeId_t, std::vector<atomId_t> > MolAtomList;
+class FragmentationSubgraphDissectionState : public ActionState {
+public:
+  FragmentationSubgraphDissectionState(const MolAtomList &_moleculelist) :
+   moleculelist(_moleculelist)
+  {}
+  MolAtomList moleculelist;
+};
 const char FragmentationSubgraphDissectionAction::NAME[] = "subgraph-dissect";
 …
 {}
+/** Dissects given \a *mol into connected subgraphs and inserts them as new molecules but with old atoms into \a this.
+ */
 void FragmentationSubgraphDissection() {
   ActionRegistry::getInstance().getActionByName(FragmentationSubgraphDissectionAction::NAME)->call(Action::NonInteractive);
 …
 Action::state_ptr FragmentationSubgraphDissectionAction::performCall() {
   DoLog(1) && (Log() << Verbose(1) << "Dissecting molecular system into a set of disconnected subgraphs ... " << endl);
+  // @TODO rather do the dissection afterwards
+  // first create undo state
+  MolAtomList moleculelist;
+  vector<molecule *> allmolecules = World::getInstance().getAllMolecules();
+  for (vector<molecule *>::const_iterator moliter = allmolecules.begin(); moliter != allmolecules.end(); ++moliter) {
+    std::vector<atomId_t> atomlist;
+    atomlist.resize((*moliter)->size());
+    for (molecule::const_iterator atomiter = (*moliter)->begin(); atomiter != (*moliter)->end(); ++atomiter) {
+      atomlist.push_back((*atomiter)->getId());
+    }
+    moleculelist.insert( std::pair< moleculeId_t, std::vector<atomId_t> > ((*moliter)->getId(), atomlist));
+  }
+  FragmentationSubgraphDissectionState *UndoState = new FragmentationSubgraphDissectionState(moleculelist);
   MoleculeListClass *molecules = World::getInstance().getMolecules();
   config * const configuration = World::getInstance().getConfig();
   // 0a. remove all present molecules
-  vector<molecule *> allmolecules = World::getInstance().getAllMolecules();
   for (vector<molecule *>::iterator MolRunner = allmolecules.begin(); MolRunner != allmolecules.end(); ++MolRunner) {
     molecules->erase(*MolRunner);
 …
   // 0b. remove all bonds and construct a molecule with all atoms
   molecule *mol = World::getInstance().createMolecule();
+  vector <atom *> allatoms = World::getInstance().getAllAtoms();
+  for(vector<atom *>::iterator AtomRunner = allatoms.begin(); AtomRunner != allatoms.end(); ++AtomRunner) {
+    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); !(*AtomRunner)->ListOfBonds.empty(); BondRunner = (*AtomRunner)->ListOfBonds.begin())
+      delete(*BondRunner);
+    mol->AddAtom(*AtomRunner);
+  {
+    vector <atom *> allatoms = World::getInstance().getAllAtoms();
+    for(vector<atom *>::iterator AtomRunner = allatoms.begin(); AtomRunner != allatoms.end(); ++AtomRunner) {
+      for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); !(*AtomRunner)->ListOfBonds.empty(); BondRunner = (*AtomRunner)->ListOfBonds.begin())
+        delete(*BondRunner);
+      mol->AddAtom(*AtomRunner);
+    }
+  }
 …
   delete(BackEdgeStack);
   if ((Subgraphs == NULL) || (Subgraphs->next == NULL)) {
     World::getInstance().destroyMolecule(mol);
+    //World::getInstance().destroyMolecule(mol);
     DoeLog(1) && (eLog()<< Verbose(1) << "There are no atoms." << endl);
     return Action::failure;
+  }
+  // 3. dissect (the following construct is needed to have the atoms not in the order of the DFS, but in
+  // the original one as parsed in)
+  // TODO: Optimize this, when molecules just contain pointer list of global atoms!
+  // 4a. create array of molecules to fill
+  const int MolCount = Subgraphs->next->Count();
+  char number[MAXSTRINGSIZE];
+  molecule **moleculelist = new molecule *[MolCount];
+  int FragmentCounter = Subgraphs->next->Count();
+  // TODO: When DepthFirstSearchAnalysis does not use AddCopyAtom() anymore, we don't need to delete all original atoms
+  {
+    // 3a. destroy the original molecule
+    for (molecule::iterator AtomRunner = mol->begin(); !mol->empty(); AtomRunner = mol->begin())
+      World::getInstance().destroyAtom(*AtomRunner);
+    World::getInstance().destroyMolecule(mol);
+    // 3b. correct fathers (AddCopyAtom sets father to original atom, which has been destroyed).
+    vector <atom *> allatoms = World::getInstance().getAllAtoms();
+    for(vector<atom *>::iterator AtomRunner = allatoms.begin(); AtomRunner != allatoms.end(); ++AtomRunner) {
+      (*AtomRunner)->father = *AtomRunner;
+    }
+  }
+  // 4. free Leafs
   MoleculeLeafClass *MolecularWalker = Subgraphs;
-  for (int i=0;i<MolCount;i++) {
-    MolecularWalker = MolecularWalker->next;
-    moleculelist[i] = World::getInstance().createMolecule();
-    moleculelist[i]->ActiveFlag = true;
-    strncpy(moleculelist[i]->name, mol->name, MAXSTRINGSIZE);
-    if (MolCount > 1) {
-      sprintf(number, "-%d", i+1);
-      strncat(moleculelist[i]->name, number, MAXSTRINGSIZE - strlen(mol->name) - 1);
+    }
-    DoLog(1) && (Log() << Verbose(1) << "MolName is " << moleculelist[i]->name << ", id is " << moleculelist[i]->getId() << endl);
-    for (molecule::iterator iter = MolecularWalker->Leaf->begin(); iter != MolecularWalker->Leaf->end(); ++iter) {
-      DoLog(1) && (Log() << Verbose(1) << **iter << endl);
+    }
-    molecules->insert(moleculelist[i]);
+  }
-  // 4b. create and fill map of which atom is associated to which connected molecule (note, counting starts at 1)
-  int FragmentCounter = 0;
-  map<int, atom *> AtomToFragmentMap;
-  MolecularWalker = Subgraphs;
   while (MolecularWalker->next != NULL) {
+    MolecularWalker = MolecularWalker->next;
+    for (molecule::iterator iter = MolecularWalker->Leaf->begin(); !MolecularWalker->Leaf->empty(); iter = MolecularWalker->Leaf->begin()) {
+      atom * Walker = *iter;
+      DoLog(1) && (Log() << Verbose(1) << "Re-linking " << Walker << "..." << endl);
+      MolecularWalker->Leaf->erase(iter);
+      moleculelist[FragmentCounter]->AddAtom(Walker);    // counting starts at 1
+    }
+    FragmentCounter++;
+  }
+  // TODO: When DepthFirstSearchAnalysis does not use AddCopyAtom() anymore, we don't need to delete all original atoms.
+  // 4d. destroy the original molecule
+  for (molecule::iterator AtomRunner = mol->begin(); !mol->empty(); AtomRunner = mol->begin())
+    World::getInstance().destroyAtom(*AtomRunner);
+  World::getInstance().destroyMolecule(mol);
+  // 4d. we don't need to redo bonds, as they are connected subgraphs and still maintain their ListOfBonds, but we have to remove them from first..last list
+  // TODO: check whether this is really not needed anymore
+  // 4e. free Leafs
+  MolecularWalker = Subgraphs;
+  while (MolecularWalker->next != NULL) {
+    MolecularWalker->Leaf = NULL;
     MolecularWalker = MolecularWalker->next;
     delete(MolecularWalker->previous);
+  }
+  MolecularWalker->Leaf = NULL;
   delete(MolecularWalker);
-  delete[](moleculelist);
   DoLog(1) && (Log() << Verbose(1) << "I scanned " << FragmentCounter << " molecules." << endl);
   return Action::success;
+  return Action::state_ptr(UndoState);
+}
 Action::state_ptr FragmentationSubgraphDissectionAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  FragmentationSubgraphDissectionState *state = assert_cast<FragmentationSubgraphDissectionState*>(_state.get());
+  {
+    // remove all present molecules
+    MoleculeListClass *molecules = World::getInstance().getMolecules();
+    vector<molecule *> allmolecules = World::getInstance().getAllMolecules();
+    for (vector<molecule *>::iterator MolRunner = allmolecules.begin(); MolRunner != allmolecules.end(); ++MolRunner) {
+      molecules->erase(*MolRunner);
+      World::getInstance().destroyMolecule(*MolRunner);
+    }
+  }
+  {
+    // construct the old state
+    molecule *mol = NULL;
+    for (MolAtomList::const_iterator iter = state->moleculelist.begin(); iter != state->moleculelist.end(); ++iter) {
+      mol = World::getInstance().createMolecule();
+      if (mol->getId() != (*iter).first)
+        World::getInstance().changeMoleculeId(mol->getId(), (*iter).first);
+      for (std::vector<atomId_t>::const_iterator atomiter = (*iter).second.begin(); atomiter != (*iter).second.end(); ++atomiter)
+        mol->AddAtom(World::getInstance().getAtom(AtomById(*atomiter)));
+    }
+  }
+  return Action::state_ptr(_state);
+}
 Action::state_ptr FragmentationSubgraphDissectionAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return performCall();
+}
 bool FragmentationSubgraphDissectionAction::canUndo() {
   return false;
+  return true;
+}
 bool FragmentationSubgraphDissectionAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/Makefile.am

-              r8006ee
+              r994713
 SELECTIONACTIONSOURCE = \
         SelectionAction/AllAtomsAction.cpp \
+        SelectionAction/AllAtomsInsideCuboidAction.cpp \
+        SelectionAction/AllAtomsInsideSphereAction.cpp \
         SelectionAction/AllAtomsOfMoleculeAction.cpp \
         SelectionAction/AllMoleculesAction.cpp \
+        SelectionAction/AtomByElementAction.cpp \
         SelectionAction/AtomByIdAction.cpp \
         SelectionAction/ClearAllAtomsAction.cpp \
         SelectionAction/ClearAllMoleculesAction.cpp \
+        SelectionAction/MoleculeByFormulaAction.cpp \
         SelectionAction/MoleculeByIdAction.cpp \
         SelectionAction/MoleculeOfAtomAction.cpp \
         SelectionAction/NotAllAtomsAction.cpp \
+        SelectionAction/NotAllAtomsInsideCuboidAction.cpp \
+        SelectionAction/NotAllAtomsInsideSphereAction.cpp \
         SelectionAction/NotAllAtomsOfMoleculeAction.cpp \
         SelectionAction/NotAllMoleculesAction.cpp \
+        SelectionAction/NotAtomByElementAction.cpp \
         SelectionAction/NotAtomByIdAction.cpp \
+        SelectionAction/NotMoleculeByFormulaAction.cpp \
         SelectionAction/NotMoleculeByIdAction.cpp \
         SelectionAction/NotMoleculeOfAtomAction.cpp
 SELECTIONACTIONHEADER = \
         SelectionAction/AllAtomsAction.hpp \
+        SelectionAction/AllAtomsInsideCuboidAction.hpp \
+        SelectionAction/AllAtomsInsideSphereAction.hpp \
         SelectionAction/AllAtomsOfMoleculeAction.hpp \
         SelectionAction/AllMoleculesAction.hpp \
+        SelectionAction/AtomByElementAction.hpp \
         SelectionAction/AtomByIdAction.hpp \
         SelectionAction/ClearAllAtomsAction.hpp \
         SelectionAction/ClearAllMoleculesAction.hpp \
+        SelectionAction/MoleculeByFormulaAction.hpp \
         SelectionAction/MoleculeByIdAction.hpp \
         SelectionAction/MoleculeOfAtomAction.hpp \
         SelectionAction/NotAllAtomsAction.hpp \
+        SelectionAction/NotAllAtomsInsideCuboidAction.hpp \
+        SelectionAction/NotAllAtomsInsideSphereAction.hpp \
         SelectionAction/NotAllAtomsOfMoleculeAction.hpp \
         SelectionAction/NotAllMoleculesAction.hpp \
+        SelectionAction/NotAtomByElementAction.hpp \
         SelectionAction/NotAtomByIdAction.hpp \
+        SelectionAction/NotMoleculeByFormulaAction.hpp \
         SelectionAction/NotMoleculeByIdAction.hpp \
         SelectionAction/NotMoleculeOfAtomAction.cpp
 …
   WorldAction/InputAction.cpp \
   WorldAction/OutputAction.cpp \
-  WorldAction/RemoveSphereOfAtomsAction.cpp \
   WorldAction/RepeatBoxAction.cpp \
   WorldAction/ScaleBoxAction.cpp \
 …
   WorldAction/InputAction.hpp \
   WorldAction/OutputAction.hpp \
-  WorldAction/RemoveSphereOfAtomsAction.hpp \
   WorldAction/RepeatBoxAction.hpp \
   WorldAction/ScaleBoxAction.hpp \

src/Actions/MakroAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MakroAction.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/ManipulateAtomsProcess.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ManipulateAtomsProcess.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/MapOfActions.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MapOfActions.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 #include "Actions/ParserAction/SaveXyzAction.hpp"
 #include "Actions/SelectionAction/AllAtomsAction.hpp"
+#include "Actions/SelectionAction/AllAtomsInsideCuboidAction.hpp"
+#include "Actions/SelectionAction/AllAtomsInsideSphereAction.hpp"
 #include "Actions/SelectionAction/AllAtomsOfMoleculeAction.hpp"
 #include "Actions/SelectionAction/AllMoleculesAction.hpp"
+#include "Actions/SelectionAction/AtomByElementAction.hpp"
 #include "Actions/SelectionAction/AtomByIdAction.hpp"
 #include "Actions/SelectionAction/ClearAllAtomsAction.hpp"
 #include "Actions/SelectionAction/ClearAllMoleculesAction.hpp"
+#include "Actions/SelectionAction/MoleculeByFormulaAction.hpp"
 #include "Actions/SelectionAction/MoleculeByIdAction.hpp"
 #include "Actions/SelectionAction/MoleculeOfAtomAction.hpp"
 #include "Actions/SelectionAction/NotAllAtomsAction.hpp"
+#include "Actions/SelectionAction/NotAllAtomsInsideCuboidAction.hpp"
+#include "Actions/SelectionAction/NotAllAtomsInsideSphereAction.hpp"
 #include "Actions/SelectionAction/NotAllAtomsOfMoleculeAction.hpp"
 #include "Actions/SelectionAction/NotAllMoleculesAction.hpp"
+#include "Actions/SelectionAction/NotAtomByElementAction.hpp"
 #include "Actions/SelectionAction/NotAtomByIdAction.hpp"
+#include "Actions/SelectionAction/NotMoleculeByFormulaAction.hpp"
 #include "Actions/SelectionAction/NotMoleculeByIdAction.hpp"
 #include "Actions/SelectionAction/NotMoleculeOfAtomAction.hpp"
 …
 #include "Actions/WorldAction/InputAction.hpp"
 #include "Actions/WorldAction/OutputAction.hpp"
-#include "Actions/WorldAction/RemoveSphereOfAtomsAction.hpp"
 #include "Actions/WorldAction/RepeatBoxAction.hpp"
 #include "Actions/WorldAction/ScaleBoxAction.hpp"
 …
   DescriptionMap["redo"] = "redo last action";
   DescriptionMap["remove-atom"] = "remove a specified atom";
-  DescriptionMap["remove-sphere"] = "remove sphere of atoms of around a specified atom";
   DescriptionMap["repeat-box"] = "create periodic copies of the simulation box per axis";
   DescriptionMap["rotate-origin"] = "rotate selected atoms by a specific angle around origin";
 …
   DescriptionMap["select-all-atoms"] = "select all atoms";
   DescriptionMap["select-all-molecules"] = "select all molecules";
+  DescriptionMap["select-atom-by-element"] = "select an atom by element";
   DescriptionMap["select-atom-by-id"] = "select an atom by index";
+  DescriptionMap["select-atoms-inside-cuboid"] = "select all atoms inside a cuboid";
+  DescriptionMap["select-atoms-inside-sphere"] = "select all atoms inside a sphere";
   DescriptionMap["select-molecule-by-id"] = "select a molecule by index";
+  DescriptionMap["select-molecule-by-formula"] = "select a molecule by chemical formula";
   DescriptionMap["select-molecule-of-atom"] = "select a molecule to which a given atom belongs";
   DescriptionMap["select-molecules-atoms"] = "select all atoms of a molecule";
 …
   DescriptionMap["unselect-all-atoms"] = "unselect all atoms";
   DescriptionMap["unselect-all-molecules"] = "unselect all molecules";
+  DescriptionMap["unselect-atom-by-element"] = "unselect an atom by element";
   DescriptionMap["unselect-atom-by-id"] = "unselect an atom by index";
+  DescriptionMap["unselect-atoms-inside-cuboid"] = "unselect all atoms inside a cuboid";
+  DescriptionMap["unselect-atoms-inside-sphere"] = "unselect all atoms inside a sphere";
+  DescriptionMap["unselect-molecule-by-formula"] = "unselect a molecule by chemical formula";
   DescriptionMap["unselect-molecule-by-id"] = "unselect a molecule by index";
   DescriptionMap["unselect-molecule-of-atom"] = "unselect a molecule to which a given atom belongs";
 …
   DescriptionMap["version"] = "show version";
   // keys for values
+  DescriptionMap["angle-x"] = "angle of a rotation around x axis";
+  DescriptionMap["angle-y"] = "angle of a rotation around y axis";
+  DescriptionMap["angle-z"] = "angle of a rotation around z axis";
   DescriptionMap["bin-output-file"] = "name of the bin output file";
   DescriptionMap["bin-end"] = "start of the last bin";
 …
   ShortFormMap["parse-xyz"] = "p";
   ShortFormMap["remove-atom"] = "r";
-  ShortFormMap["remove-sphere"] = "R";
   ShortFormMap["repeat-box"] = "d";
   ShortFormMap["rotate-to-pas"] = "m";
 …
   // value types for the actions
   TypeMap["add-atom"] = &typeid(element);
+  TypeMap["add-atom"] = &typeid(const element);
   TypeMap["bond-file"] = &typeid(std::string);
   TypeMap["bond-table"] = &typeid(std::string);
 …
   TypeMap["center-in-box"] = &typeid(BoxValue);
   TypeMap["change-box"] = &typeid(BoxValue);
   TypeMap["change-element"] = &typeid(element);
+  TypeMap["change-element"] = &typeid(const element);
   TypeMap["change-molname"] = &typeid(std::string);
   TypeMap["clear-atom-selection"] = &typeid(void);
 …
   TypeMap["redo"] = &typeid(void);
   TypeMap["remove-atom"] = &typeid(void);
-  TypeMap["remove-sphere"] = &typeid(double);
   TypeMap["repeat-box"] = &typeid(VectorValue);
   TypeMap["rotate-origin"] = &typeid(double);
 …
   TypeMap["select-all-atoms"] = &typeid(void);
   TypeMap["select-all-molecules"] = &typeid(void);
+  TypeMap["select-atom-by-element"] = &typeid(const element);
   TypeMap["select-atom-by-id"] = &typeid(atom);
+  TypeMap["select-atoms-inside-cuboid"] = &typeid(VectorValue);
+  TypeMap["select-atoms-inside-sphere"] = &typeid(double);
+  TypeMap["select-molecule-by-formula"] = &typeid(std::string);
   TypeMap["select-molecule-by-id"] = &typeid(molecule);
   TypeMap["select-molecule-of-atom"] = &typeid(atom);
 …
   TypeMap["unselect-all-atoms"] = &typeid(void);
   TypeMap["unselect-all-molecules"] = &typeid(void);
+  TypeMap["unselect-atom-by-element"] = &typeid(const element);
   TypeMap["unselect-atom-by-id"] = &typeid(atom);
+  TypeMap["unselect-atoms-inside-cuboid"] = &typeid(VectorValue);
+  TypeMap["unselect-atoms-inside-sphere"] = &typeid(double);
+  TypeMap["unselect-molecule-by-formula"] = &typeid(std::string);
   TypeMap["unselect-molecule-by-id"] = &typeid(molecule);
   TypeMap["unselect-molecule-of-atom"] = &typeid(atom);
 …
   // value types for the values
+  TypeMap["angle-x"] = &typeid(double);
+  TypeMap["angle-y"] = &typeid(double);
+  TypeMap["angle-z"] = &typeid(double);
   TypeMap["bin-output-file"] = &typeid(std::string);
   TypeMap["bin-end"] = &typeid(double);
 …
   TypeMap["distances"] = &typeid(VectorValue);
   TypeMap["DoRotate"] = &typeid(bool);
   TypeMap["element"] = &typeid(element);
   TypeMap["elements"] = &typeid(std::vector<element *>);
+  TypeMap["element"] = &typeid(const element);
+  TypeMap["elements"] = &typeid(std::vector<const element *>);
   TypeMap["end-step"] = &typeid(int);
   TypeMap["id-mapping"] = &typeid(bool);
 …
   TypeEnumMap[&typeid(atom)] = Atom;
   TypeEnumMap[&typeid(std::vector<atom *>)] = ListOfAtoms;
   TypeEnumMap[&typeid(element)] = Element;
   TypeEnumMap[&typeid(std::vector<element *>)] = ListOfElements;
+  TypeEnumMap[&typeid(const element)] = Element;
+  TypeEnumMap[&typeid(std::vector<const element *>)] = ListOfElements;
   // default values for any action that needs one (always string!)
 …
   MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-all-atoms") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-all-molecules") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-atom-by-element") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-atom-by-id") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-atoms-inside-cuboid") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-atoms-inside-sphere") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-molecule-by-id") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-molecule-by-formula") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-molecule-of-atom") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-molecules-atoms") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "unselect-all-atoms") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "unselect-all-molecules") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "unselect-atom-by-element") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "unselect-atom-by-id") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "unselect-atoms-inside-cuboid") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "unselect-atoms-inside-sphere") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "unselect-molecule-by-formula") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "unselect-molecule-by-id") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "unselect-molecule-of-atom") );
 …
   MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "input") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "output") );
-  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "remove-sphere") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "repeat-box") );
   MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "scale-box") );
 …
   generic.insert("redo");
   generic.insert("remove-atom");
-  generic.insert("remove-sphere");
   generic.insert("repeat-box");
   generic.insert("rotate-origin");
 …
   generic.insert("select-all-atoms");
   generic.insert("select-all-molecules");
+  generic.insert("select-atom-by-element");
   generic.insert("select-atom-by-id");
+  generic.insert("select-atoms-inside-cuboid");
+  generic.insert("select-atoms-inside-sphere");
   generic.insert("select-molecule-by-id");
+  generic.insert("select-molecule-by-formula");
   generic.insert("select-molecule-of-atom");
   generic.insert("select-molecules-atoms");
 …
   generic.insert("unselect-all-atoms");
   generic.insert("unselect-all-molecules");
+  generic.insert("unselect-atom-by-element");
   generic.insert("unselect-atom-by-id");
+  generic.insert("unselect-atoms-inside-cuboid");
+  generic.insert("unselect-atoms-inside-sphere");
+  generic.insert("unselect-molecule-by-formula");
   generic.insert("unselect-molecule-by-id");
   generic.insert("unselect-molecule-of-atom");
 …
     // hidden arguments
+  hidden.insert("angle-x");
+  hidden.insert("angle-y");
+  hidden.insert("angle-z");
   hidden.insert("bin-end");
   hidden.insert("bin-output-file");
 …
+}
+bool MapOfActions::isCurrentValuePresent(const char *name) const
+{
+  return (CurrentValue.find(name) != CurrentValue.end());
+}
 void MapOfActions::queryCurrentValue(const char * name, class atom * &_T)
+{
 …
+}
 void MapOfActions::queryCurrentValue(const char * name, class element * &_T)  {
+void MapOfActions::queryCurrentValue(const char * name, const element * &_T)  {
   int Z = -1;
   if (typeid( element ) == *TypeMap[name]) {
+  if (typeid(const element ) == *TypeMap[name]) {
     if (CurrentValue.find(name) == CurrentValue.end())
       throw MissingValueException(__FILE__, __LINE__);
 …
+}
 void MapOfActions::queryCurrentValue(const char * name, std::vector<element *>&_T)
+void MapOfActions::queryCurrentValue(const char * name, std::vector<const element *>&_T)
+{
   int Z = -1;
   element *elemental = NULL;
   if (typeid( std::vector<element *> ) == *TypeMap[name]) {
+  const element *elemental = NULL;
+  if (typeid( std::vector<const element *> ) == *TypeMap[name]) {
     if (CurrentValue.find(name) == CurrentValue.end())
       throw MissingValueException(__FILE__, __LINE__);
 …
+}
 void MapOfActions::setCurrentValue(const char * name, class element * &_T)
+{
   if (typeid( element ) == *TypeMap[name]) {
+void MapOfActions::setCurrentValue(const char * name, const element * &_T)
+{
+  if (typeid(const element ) == *TypeMap[name]) {
     std::ostringstream stream;
     stream << _T->Z;
+    stream << _T->getAtomicNumber();
     CurrentValue[name] = stream.str();
   } else
 …
+}
 void MapOfActions::setCurrentValue(const char * name, std::vector<element *>&_T)
+{
   if (typeid( std::vector<element *> ) == *TypeMap[name]) {
+void MapOfActions::setCurrentValue(const char * name, std::vector<const element *>&_T)
+{
+  if (typeid( std::vector<const element *> ) == *TypeMap[name]) {
     std::ostringstream stream;
     for (std::vector<element *>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
       stream << (*iter)->Z << " ";
+    for (std::vector<const element *>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
+      stream << (*iter)->getAtomicNumber() << " ";
+    }
     CurrentValue[name] = stream.str();
 …
   new SelectionClearAllMoleculesAction();
   new SelectionAllAtomsAction();
+  new SelectionAllAtomsInsideCuboidAction();
+  new SelectionAllAtomsInsideSphereAction();
   new SelectionAllAtomsOfMoleculeAction();
   new SelectionAllMoleculesAction();
+  new SelectionAtomByElementAction();
   new SelectionAtomByIdAction();
   new SelectionMoleculeByIdAction();
+  new SelectionMoleculeByFormulaAction();
   new SelectionMoleculeOfAtomAction();
   new SelectionNotAllAtomsAction();
+  new SelectionNotAllAtomsInsideCuboidAction();
+  new SelectionNotAllAtomsInsideSphereAction();
   new SelectionNotAllAtomsOfMoleculeAction();
   new SelectionNotAllMoleculesAction();
+  new SelectionNotAtomByElementAction();
   new SelectionNotAtomByIdAction();
+  new SelectionNotMoleculeByFormulaAction();
   new SelectionNotMoleculeByIdAction();
   new SelectionNotMoleculeOfAtomAction();
 …
   new WorldInputAction();
   new WorldOutputAction();
-  new WorldRemoveSphereOfAtomsAction();
   new WorldRepeatBoxAction();
   new WorldScaleBoxAction();

src/Actions/MapOfActions.hpp

-              r8006ee
+              r994713
   void populateActions();
+  bool isCurrentValuePresent(const char *name) const;
   void queryCurrentValue(const char * name, class atom * &_T);
   void queryCurrentValue(const char * name, class element * &_T);
+  void queryCurrentValue(const char * name, const element * &_T);
   void queryCurrentValue(const char * name, class molecule * &_T);
   void queryCurrentValue(const char * name, class Box &_T);
   void queryCurrentValue(const char * name, class Vector &_T);
   void queryCurrentValue(const char * name, std::vector<atom *>&_T);
   void queryCurrentValue(const char * name, std::vector<element *>&_T);
+  void queryCurrentValue(const char * name, std::vector<const element *>&_T);
   void queryCurrentValue(const char * name, std::vector<molecule *>&_T);
   template<typename T> void queryCurrentValue(const char * name, T &_T)
 …
   void setCurrentValue(const char * name, class atom * &_T);
   void setCurrentValue(const char * name, class element * &_T);
+  void setCurrentValue(const char * name, const element * &_T);
   void setCurrentValue(const char * name, class molecule * &_T);
   void setCurrentValue(const char * name, class Box &_T);
   void setCurrentValue(const char * name, class Vector &_T);
   void setCurrentValue(const char * name, std::vector<atom *>&_T);
   void setCurrentValue(const char * name, std::vector<element *>&_T);
+  void setCurrentValue(const char * name, std::vector<const element *>&_T);
   void setCurrentValue(const char * name, std::vector<molecule *>&_T);
   template<class T> void setCurrentValue(const char * name, T &_T)

src/Actions/MethodAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MethodAction.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/MoleculeAction/BondFileAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * BondFileAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/MoleculeAction/ChangeNameAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ChangeNameAction.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/MoleculeAction/FillWithMoleculeAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * FillWithMoleculeAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/MoleculeAction/LinearInterpolationofTrajectoriesAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * LinearInterpolationofTrajectoriesAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/MoleculeAction/RotateAroundSelfByAngleAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * RotateAroundSelfByAngleAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/MoleculeAction/RotateToPrincipalAxisSystemAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * RotateToPrincipalAxisSystemAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
       Vector x = (*iter)->getPosition();
       x -= *CenterOfGravity;
       const double mass = (*iter)->getType()->mass;
+      const double mass = (*iter)->getType()->getMass();
       InertiaTensor.at(0,0) += mass*(x[1]*x[1] + x[2]*x[2]);
       InertiaTensor.at(0,1) += mass*(-x[0]*x[1]);
 …
       Vector x = (*iter)->getPosition();
       x -= *CenterOfGravity;
       const double mass = (*iter)->getType()->mass;
+      const double mass = (*iter)->getType()->getMass();
       InertiaTensor.at(0,0) += mass*(x[1]*x[1] + x[2]*x[2]);
       InertiaTensor.at(0,1) += mass*(-x[0]*x[1]);

src/Actions/MoleculeAction/SaveAdjacencyAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SaveAdjacencyAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/MoleculeAction/SaveBondsAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SaveBondsAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/MoleculeAction/SaveTemperatureAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SaveTemperatureAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/MoleculeAction/SuspendInWaterAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SuspendInWaterAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/MoleculeAction/VerletIntegrationAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * VerletIntegrationAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/ParserAction/LoadXyzAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * LoadXyzAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
   input.open(filename.c_str());
   if (!input.fail()) {
-    // TODO: Remove the insertion into molecule when saving does not depend on them anymore. Also, remove molecule.hpp include
-    set <atom*> UniqueList;
+    {
-      vector<atom *> ListBefore = World::getInstance().getAllAtoms();
-      for (vector<atom *>::iterator runner = ListBefore.begin();runner != ListBefore.end(); ++runner)
-        UniqueList.insert(*runner);
+    }
     XyzParser parser; // briefly instantiate a parser which is removed at end of focus
     parser.load(&input);
+    {
-      vector<atom *> ListAfter = World::getInstance().getAllAtoms();
-      pair< set<atom *>::iterator, bool > Inserter;
-      if (UniqueList.size() != ListAfter.size()) { // only create if new atoms have been parsed
-        MoleculeListClass *molecules = World::getInstance().getMolecules();
-        molecule *mol = World::getInstance().createMolecule();
-        molecules->insert(mol);
-        for (vector<atom *>::iterator runner = ListAfter.begin(); runner != ListAfter.end(); ++runner) {
-          Inserter = UniqueList.insert(*runner);
-          if (Inserter.second) { // if not present, then new (just parsed) atom, add ...
-            cout << "Adding new atom " << **runner << " to new mol." << endl;
-            mol->AddAtom(*runner);
+          }
+        }
-        mol->doCountAtoms();
-      } else {
-        cout << "No atoms parsed?" << endl;
+      }
+    }
   } else {
     DoeLog(1) && (eLog() << Verbose(1) << "Could not open file " << filename << "." << endl);

src/Actions/ParserAction/SaveXyzAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SaveXyzAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/Process.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Process.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/AllAtomsAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * AllAtomsAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/AllAtomsOfMoleculeAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * AllAtomsOfMoleculeAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/AllMoleculesAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * AllMoleculesAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/AtomByIdAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * AtomByIdAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/ClearAllAtomsAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ClearAllAtomsAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/ClearAllMoleculesAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ClearAllMoleculesAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/MoleculeByIdAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MoleculeByIdAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/MoleculeOfAtomAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MoleculeOfAtomAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/NotAllAtomsAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * NotAllAtomsAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/NotAllAtomsOfMoleculeAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * NotAllAtomsOfMoleculeAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/NotAllMoleculesAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * NotAllMoleculesAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/NotAtomByIdAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * NotAtomByIdAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/NotMoleculeByIdAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * NotMoleculeByIdAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/SelectionAction/NotMoleculeOfAtomAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * NotMoleculeOfAtomAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/TesselationAction/ConvexEnvelopeAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ConvexEnvelopeAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/TesselationAction/NonConvexEnvelopeAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * NonConvexEnvelopeAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/ValueStorage.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ValueStorage.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "ValueStorage.hpp"
 #include "Patterns/Singleton_impl.hpp"
+ValueStorage::ValueStorage() {};
+ValueStorage::ValueStorage() :
+  MapOfActions_instance(MapOfActions::getInstance())
+{};
 ValueStorage::~ValueStorage() {};

src/Actions/ValueStorage.hpp

-              r8006ee
+              r994713
 #ifndef VALUESTORAGE_HPP_
 #define VALUESTORAGE_HPP_
 #include "Actions/MapOfActions.hpp"
 …
 public:
+  template <typename T> void queryCurrentValue(const char *name, T &_T) {
+    MapOfActions::getInstance().queryCurrentValue(name, _T);
+  }
+  template <typename T> void setCurrentValue(const char *name, T &_T) {
+    MapOfActions::getInstance().setCurrentValue(name, _T);
+  /** Gets a value from the storage
+   * If the value is not present, an ASSERT is thrown unless optional is set to true.
+   * \param _T key of value
+   * \param optional whether this value is optional, i.e. may actually not be in the storage (i.e. may return false in this case).
+   * \return true - value present, false - value not present (only given when optional set to true)
+   */
+  template <typename T> bool queryCurrentValue(const char *name, T &_T, const bool optional = false) {
+    if (optional) {
+      if (!MapOfActions_instance.isCurrentValuePresent(name))
+        return false;
+    }
+    MapOfActions_instance.queryCurrentValue(name, _T);
+    return true;
+  }
+  /** Sets a value in the storage.
+   * \param name key of value
+   * \param _T value
+   */
+  template <typename T> void setCurrentValue(const char *name, T &_T) {
+    MapOfActions_instance.setCurrentValue(name, _T);
+  }
+  /** Obtain a descriptive text for a given key.
+   * \param actionname key
+   * \return text describing the key's contents
+   */
   std::string getDescription(std::string actionname);
 …
   ValueStorage();
   ~ValueStorage();
+  MapOfActions &MapOfActions_instance;
 };

src/Actions/WorldAction/AddEmptyBoundaryAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * AddEmptyBoundaryAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/WorldAction/BoundInBoxAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * BoundInBoxAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/WorldAction/CenterInBoxAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * CenterInBoxAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/WorldAction/CenterOnEdgeAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * CenterOnEdgeAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/WorldAction/ChangeBoxAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ChangeBoxAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/WorldAction/InputAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * InputAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/WorldAction/OutputAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * OutputAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/WorldAction/RepeatBoxAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * RepeatBoxAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/WorldAction/ScaleBoxAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ScaleBoxAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/WorldAction/SetDefaultNameAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SetDefaultNameAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
   defaultname = World::getInstance().getDefaultName();
+  WorldSetDefaultNameState *UndoState = new WorldSetDefaultNameState(defaultname);
   ValueStorage::getInstance().queryCurrentValue(NAME, defaultname);
   World::getInstance().setDefaultName(defaultname);
   DoLog(0) && (Log() << Verbose(0) << "Default name of new molecules set to " << World::getInstance().getDefaultName() << "." << endl);
   return Action::success;
+  return Action::state_ptr(UndoState);
+}
 …
   string newName = World::getInstance().getDefaultName();
   World::getInstance().setDefaultName(state->lastName);
+  DoLog(0) && (Log() << Verbose(0) << "Default name of new molecules set to " << World::getInstance().getDefaultName() << "." << endl);
   return Action::state_ptr(new WorldSetDefaultNameState(newName));

src/Actions/WorldAction/SetGaussianBasisAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SetGaussianBasisAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Actions/WorldAction/SetOutputFormatsAction.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SetOutputFormatsAction.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/BoundaryLineSet.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * BoundaryLineSet.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "BoundaryLineSet.hpp"

src/BoundaryMaps.hpp

-              r8006ee
+              r994713
 typedef std::map <int, int> IndexToIndex;
+// ============= TesselPoint maps ======================== //
+typedef std::pair < double, class TesselPoint * > TesselPointDistancePair;
+typedef std::multimap < double, class TesselPoint * > TesselPointDistanceMap;
+typedef std::pair < TesselPointDistanceMap::iterator, bool > TesselPointDistanceTestPair;
+typedef std::list <TesselPoint *> TesselPointList;
+typedef std::set <TesselPoint *> TesselPointSet;
+typedef std::list<std::list <TesselPoint *> *> ListOfTesselPointList;
+// ============= BoundaryPointSet maps ======================== //
 typedef std::map < int, class BoundaryPointSet * > PointMap;
 typedef std::set < class BoundaryPointSet * > PointSet;
 …
 typedef std::pair < PointMap::iterator, bool > PointTestPair;
 typedef std::list <class CandidateForTesselation *> CandidateList;
 typedef std::map <class BoundaryLineSet *, class CandidateForTesselation *> CandidateMap;
+typedef std::multimap <double, class BoundaryPointSet * > DistanceToPointMap;
+typedef std::pair <double, class BoundaryPointSet * > DistanceToPointPair;
+// ============= BoundaryLineSet maps ======================== //
 typedef std::multimap < int, class BoundaryLineSet * > LineMap;
 typedef std::set < class BoundaryLineSet * > LineSet;
 …
 typedef std::pair < LineMap::iterator, bool > LineTestPair;
+// ============= BoundaryTriangleSet maps ======================== //
 typedef std::map < int, class BoundaryTriangleSet * > TriangleMap;
 typedef std::set < class BoundaryTriangleSet * > TriangleSet;
 …
 typedef std::pair < TriangleMap::iterator, bool > TriangleTestPair;
+// ============= BoundaryPolygonSet maps ======================== //
 typedef std::map < int, class BoundaryPolygonSet * > PolygonMap;
 typedef std::set < class BoundaryPolygonSet * > PolygonSet;
 typedef std::list < class BoundaryPolygonSet * > PolygonList;
+typedef std::multimap <double, class BoundaryPointSet * > DistanceToPointMap;
+typedef std::pair <double, class BoundaryPointSet * > DistanceToPointPair;
+// ============= CandidateForTesselation maps ======================== //
+typedef std::list <class CandidateForTesselation *> CandidateList;
+typedef std::map <class BoundaryLineSet *, class CandidateForTesselation *> CandidateMap;
+// ============= Various maps ======================== //
+typedef std::map <double, TesselPointDistancePair > Boundaries;
+typedef std::pair<double, TesselPointDistancePair > BoundariesPair;
+typedef std::pair< Boundaries::iterator, bool> BoundariesTestPair;
 typedef std::multimap <double, std::pair < PointMap::iterator, PointMap::iterator> > DistanceMultiMap;
 typedef std::pair <double, std::pair < PointMap::iterator, PointMap::iterator> > DistanceMultiMapPair;
-typedef std::list <TesselPoint *> TesselPointList;
-typedef std::set <TesselPoint *> TesselPointSet;
-typedef std::list<std::list <TesselPoint *> *> ListOfTesselPointList;
 enum centers {Opt, OtherOpt};

src/BoundaryPointSet.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * BoundaryPointSet.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "BoundaryPointSet.hpp"

src/BoundaryPolygonSet.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * BoundaryPolygonSet.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "BoundaryPolygonSet.hpp"

src/BoundaryTriangleSet.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * BoundaryTriangleSet.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "BoundaryTriangleSet.hpp"

src/Box.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Box.cpp
 …
  */
+//#include "Helpers/MemDebug.hpp"
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "Box.hpp"

src/CandidateForTesselation.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * CandidateForTesselation.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "CandidateForTesselation.hpp"

src/CommandLineParser.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * CommandLineParser.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/ConfigFileBuffer.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ConfigFileBuffer.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "ConfigFileBuffer.hpp"

src/Descriptors/AtomDescriptor.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * AtomDescriptor.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Descriptors/AtomIdDescriptor.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * AtomIdDescriptor.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Descriptors/AtomSelectionDescriptor.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * AtomSelectionDescriptor.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "Descriptors/AtomSelectionDescriptor.hpp"

src/Descriptors/AtomTypeDescriptor.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * AtomTypeDescriptor_impl.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Descriptors/MoleculeDescriptor.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MoleculeDescriptor.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Descriptors/MoleculeFormulaDescriptor.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MoleculeFormulaDescriptor.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "MoleculeFormulaDescriptor.hpp"

src/Descriptors/MoleculeIdDescriptor.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MoleculeIdDescriptor.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Descriptors/MoleculeNameDescriptor.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MoleculeNameDescriptor.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "MoleculeNameDescriptor.hpp"

src/Descriptors/MoleculePtrDescriptor.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MoleculePtrDescriptor.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Descriptors/MoleculeSelectionDescriptor.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MoleculeSelectionDescriptor.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "Descriptors/MoleculeSelectionDescriptor.hpp"

src/Exceptions/CustomException.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * CustomException.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Exceptions/IllegalTypeException.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * IllegalTypeException.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "IllegalTypeException.hpp"

src/Exceptions/LinearDependenceException.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * LinearDependenceException.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Exceptions/MathException.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MathException.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Exceptions/MissingValueException.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MissingValueException.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "MissingValueException.hpp"

src/Exceptions/NotInvertibleException.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * NotInvertibleException.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "NotInvertibleException.hpp"

src/Exceptions/ParseError.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ParseError.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "ParseError.hpp"

src/Exceptions/SkewException.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SkewException.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Exceptions/ZeroVectorException.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ZeroVectorException.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Formula.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Formula.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "Formula.hpp"
 …
   for(const_iterator iter=end();iter!=begin();){
     --iter;
     sstr << (*iter).first->symbol;
+    sstr << (*iter).first->getSymbol();
     if((*iter).second>1)
       sstr << (*iter).second;
 …
 bool Formula::hasElement(const string &shorthand) const{
   element * element = World::getInstance().getPeriode()->FindElement(shorthand);
+  const element * element = World::getInstance().getPeriode()->FindElement(shorthand);
   return hasElement(element);
+}
 …
 void Formula::operator+=(const string &shorthand){
   element * element = World::getInstance().getPeriode()->FindElement(shorthand);
+  const element * element = World::getInstance().getPeriode()->FindElement(shorthand);
   operator+=(element);
+}
 …
 void Formula::operator-=(const string &shorthand){
   element * element = World::getInstance().getPeriode()->FindElement(shorthand);
+  const element * element = World::getInstance().getPeriode()->FindElement(shorthand);
   operator-=(element);
+}
 …
 void Formula::addElements(const string &shorthand,unsigned int count){
   element * element = World::getInstance().getPeriode()->FindElement(shorthand);
+  const element * element = World::getInstance().getPeriode()->FindElement(shorthand);
   addElements(element,count);
+}
 …
 const unsigned int Formula::operator[](string shorthand) const{
   element * element = World::getInstance().getPeriode()->FindElement(shorthand);
+  const element * element = World::getInstance().getPeriode()->FindElement(shorthand);
   return operator[](element);
+}
 …
 result_type
 Formula::_iterator<result_type>::operator*(){
   element *element = World::getInstance().getPeriode()->FindElement(pos+1);
+  const element *element = World::getInstance().getPeriode()->FindElement(pos+1);
   ASSERT(element,"Element with position of iterator not found");
   return make_pair(element,(*set)[pos]);
 …
   // no one can keep this value around, so a static is ok to avoid temporaries
   static value_type value=make_pair(reinterpret_cast<element*>(0),0); // no default constructor for std::pair
   element *element = World::getInstance().getPeriode()->FindElement(pos+1);
+  const element *element = World::getInstance().getPeriode()->FindElement(pos+1);
   ASSERT(element,"Element with position of iterator not found");
   value = make_pair(element,(*set)[pos]);

src/Helpers/Assert.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Assert.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "Helpers/Assert.hpp"

src/Helpers/Info.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Info.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Helpers/Log.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * log.cpp
 …
  *      Author: metzler
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 void setVerbosity(int verbosityLevel) {
   logger::getInstance().setVerbosity(verbosityLevel);
+}
+/**
+ * Gets verbosity for the error logger and the standard logger.
+ *
+ * \param int verbosity level
+ */
+int getVerbosity() {
+  return logger::getInstance().getVerbosity();
+}

src/Helpers/Log.hpp

r8006ee	r994713
15	15	class errorLogger & eLog();
16	16	void setVerbosity(int verbosityLevel);
	17	int getVerbosity();
17	18	bool DoLog(int verbose);
18	19	bool DoeLog(int verbose);

src/Helpers/Makefile.am

-              r8006ee
+              r994713
         echo "" >  unity.cpp; \
         list='$(HELPERSSOURCE)'; for file in $$list; do \
+          echo "#include \"$(srcdir)/$$file\"" >> unity.cpp; \
+          if [ "$$file" != "MemDebug.cpp" ]; then \
+                  echo "#include \"$(srcdir)/$$file\"" >> unity.cpp; \
+                fi; \
         done;

src/Helpers/MemDebug.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MemDebug.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 // NDEBUG implies NO_MEMDEBUG

src/Helpers/Verbose.cpp

-              r8006ee
+              r994713
+using namespace std;
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
+/** \file Verbose.cpp
+ *
+ * Function implementations for the class Verbose.
+ *
+ */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 #include "Helpers/Verbose.hpp"
 #include <iostream>
+using namespace std;
 /** Prints the tabs according to verbosity stored in the temporary constructed class.

src/Helpers/errorlogger.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * errorLogger.cpp
 …
  *      Author: metzler
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 void errorLogger::setVerbosity(int verbosityLevel) {
   verbosity = verbosityLevel;
+}
+/**
+ * Gets the verbosity.
+ *
+ * \return verbosity level
+ */
+int errorLogger::getVerbosity()
+{
+  return verbosity;
+}

src/Helpers/errorlogger.hpp

r8006ee	r994713
25	25	static bool DoOutput();
26	26	static void setVerbosity(int verbosityLevel);
	27	static int getVerbosity();
27	28
28	29	protected:

src/Helpers/helpers.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file helpers.cpp
+ *
  * Implementation of some auxiliary functions for memory dis-/allocation and so on
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Helpers/logger.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * logger.cpp
 …
  *      Author: metzler
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 /**
+ * Gets the verbosity.
+ *
+ * \return verbosity level
+ */
+int logger::getVerbosity()
+{
+  return verbosity;
+}
+/**
  * Operator for the Binary(arg) call.
  * Constructs temporary a Verbose class object, wherein the Binary is stored.

src/Helpers/logger.hpp

r8006ee	r994713
25	25	static bool DoOutput();
26	26	static void setVerbosity(int verbosityLevel);
	27	static int getVerbosity();
27	28
28	29	protected:

src/LinearAlgebra/Line.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Line.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/LinearAlgebra/Matrix.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Matrix.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "LinearAlgebra/Matrix.hpp"
 …
+}
+void Matrix::rotation(const double x, const double y, const double z)
+{
+  set(0,0, cos(y)*cos(z));
+  set(0,1, cos(z)*sin(x)*sin(y) - cos(x)*sin(z));
+  set(0,2, cos(x)*cos(z)*sin(y) + sin(x) * sin(z));
+  set(1,0, cos(y)*sin(z));
+  set(1,1, cos(x)*cos(z) + sin(x)*sin(y)*sin(z));
+  set(1,2, -cos(z)*sin(x) + cos(x)*sin(y)*sin(z));
+  set(2,0, -sin(y));
+  set(2,1, cos(y)*sin(x));
+  set(2,2, cos(x)*cos(y));
+}
 Matrix &Matrix::operator=(const Matrix &src){
   if(&src!=this){
 …
 void Matrix::transpose()
+Matrix &Matrix::transpose()
+{
   double tmp;
 …
     for (int j=i+1;j<NDIM;j++) {
       tmp = at(j,i);
+      at(j,i) = at(i,j);
       at(i,j) = tmp;
       at(j,i) = tmp;
+    }
+    }
+  return *this;
+}
 …
   gsl_eigen_symmv_free(T);
   gsl_matrix_memcpy(content->content, evec);
+  gsl_matrix_free(evec);
   Vector evalues(gsl_vector_get(eval,0), gsl_vector_get(eval,1), gsl_vector_get(eval,2));
+  gsl_vector_free(eval);
   return evalues;
+}
 …
 Vector operator*(const Matrix &mat,const Vector &vec){
+  gsl_vector *res = gsl_vector_calloc(NDIM);
+  gsl_blas_dgemv( CblasNoTrans, 1.0, mat.content->content, vec.content->content, 0.0, res);
+  VectorContent *content = new VectorContent();
+  content->content = res;
+  return Vector(content);
+  Vector res;
+  gsl_blas_dgemv( CblasNoTrans, 1.0, mat.content->content, vec.content->content, 0.0, res.content->content);
+  return res;
+}

src/LinearAlgebra/Matrix.hpp

-              r8006ee
+              r994713
    */
   void zero();
+  /**
+   * Sets all matrix corresponding to a rotation matrix,
+   * first around the x-, then the y-, finally the z-axis
+   * with given angles.
+   */
+  void rotation(const double x, const double y, const double z);
   /**
 …
    */
   Matrix transpose() const;
   void transpose();
+  Matrix &transpose();
   // operators

src/LinearAlgebra/Plane.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Plane.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/LinearAlgebra/Space.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Space.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/LinearAlgebra/Vector.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file vector.cpp
+ *
 …
+ *
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/LinearAlgebra/VectorInterface.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * VectorInterface.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "VectorInterface.hpp"

src/LinearAlgebra/gslmatrix.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * gslmatrix.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/LinearAlgebra/gslvector.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * gslvector.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/LinearAlgebra/linearsystemofequations.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * linearsystemofequations.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/LinearAlgebra/vector_ops.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * vector_ops.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Makefile.am

-              r8006ee
+              r994713
 ATOMSOURCE = \
   atom.cpp \
+  AtomicInfo.cpp \
   atom_atominfo.cpp \
   atom_bondedparticle.cpp \
 …
 ATOMHEADER = \
   atom.hpp \
+  AtomicInfo.hpp \
   atom_atominfo.hpp \
   atom_bondedparticle.hpp \
 …
   Descriptors/AtomIdDescriptor.cpp \
   Descriptors/AtomSelectionDescriptor.cpp \
+  Descriptors/AtomShapeDescriptor.cpp \
   Descriptors/AtomTypeDescriptor.cpp \
   Descriptors/MoleculeDescriptor.cpp \
 …
   Descriptors/AtomIdDescriptor.hpp \
   Descriptors/AtomSelectionDescriptor.hpp \
+  Descriptors/AtomShapeDescriptor.hpp \
   Descriptors/AtomTypeDescriptor.hpp \
   Descriptors/MoleculeDescriptor.hpp \
 …
 $(srcdir)/version.c: $(srcdir)/.git-version
         echo "const char *ESPACKVersion = \"$(PACKAGE_NAME) -- git version: "`cat $(srcdir)/.git-version`"\";" > $@
+        echo "const char *MOLECUILDERVERSION = \"$(PACKAGE_NAME) version "`cat $(srcdir)/.git-version`"\";" > $@
 unity.cpp: ${MOLECUILDERSOURCE} ${MOLECUILDERHEADER}
         echo "" >  unity.cpp; \
+        echo "#include \"$(srcdir)/Helpers/MemDebug.cpp\"" >  unity.cpp; \
         list='$(MOLECUILDERSOURCE)'; for file in $$list; do \
           echo "#include \"$(srcdir)/$$file\"" >> unity.cpp; \
+        echo "#include \"$(srcdir)/$$file\"" >> unity.cpp; \
         done; \
         subdirs='$(SUBDIRS)';for directory in $$subdirs; do\

src/Parser/ChangeTracker.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ChangeTracker.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 #include "Parser/ChangeTracker.hpp"
 #include "Patterns/Singleton_impl.hpp"

src/Parser/FormatParser.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * FormatParser.cpp
 …
  *      Author: metzler
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Parser/FormatParserStorage.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file FormatParserStorage.cpp
+ *
 …
+ *
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include <iostream>

src/Parser/MpqcParser.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MpqcParser.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "MpqcParser.hpp"

src/Parser/PcpParser.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * PcpParser.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include <iostream>
 #include <iomanip>
+//#include "Actions/FragmentationAction/SubgraphDissectionAction.hpp"
 #include "atom.hpp"
 #include "config.hpp"
 …
   // 4. dissect the molecule into connected subgraphs
   // don't do this here ...
   //MolList->DissectMoleculeIntoConnectedSubgraphs(mol,this);
+  //FragmentationSubgraphDissection();
   //delete(mol);
 …
   PlaneWaveSpecifics.MaxPsiDouble = PlaneWaveSpecifics.PsiMaxNoDown = PlaneWaveSpecifics.PsiMaxNoUp = PlaneWaveSpecifics.PsiType = 0;
   for (vector<atom *>::iterator runner = allatoms.begin(); runner != allatoms.end(); ++runner) {
     PlaneWaveSpecifics.MaxPsiDouble += (*runner)->getType()->NoValenceOrbitals;
+    PlaneWaveSpecifics.MaxPsiDouble += (*runner)->getType()->getNoValenceOrbitals();
+  }
   cout << PlaneWaveSpecifics.MaxPsiDouble << endl;
 …
   // insert all found elements into the map
   for (vector<atom *>::iterator AtomRunner = allatoms.begin();AtomRunner != allatoms.end();++AtomRunner) {
     Inserter = PresentElements.insert(pair<int, int>((*AtomRunner)->getType()->Z, 1));
+    Inserter = PresentElements.insert(pair<int, int>((*AtomRunner)->getType()->getAtomicNumber(), 1));
     if (!Inserter.second) // increase if present
       Inserter.first->second += 1;
 …
     const element * const elemental = World::getInstance().getPeriode()->FindElement(iter->first);
     ZtoIndexMap.insert( pair<int,int> (iter->first, counter) );
     *file << "Ion_Type" << counter++ << "\t" << iter->second << "\t" << elemental->Z << "\t1.0\t3\t3\t" << fixed << setprecision(11) << showpoint << elemental->mass << "\t" << elemental->name << "\t" << elemental->symbol <<endl;
+    *file << "Ion_Type" << counter++ << "\t" << iter->second << "\t" << elemental->getAtomicNumber() << "\t1.0\t3\t3\t" << fixed << setprecision(11) << showpoint << elemental->getMass() << "\t" << elemental->getName() << "\t" << elemental->getSymbol() <<endl;
+  }
+}
 …
   int nr = 0;
   for (vector<atom *>::iterator AtomRunner = allatoms.begin();AtomRunner != allatoms.end();++AtomRunner) {
     Inserter = ZtoCountMap.insert( pair<int, int>((*AtomRunner)->getType()->Z, 1) );
+    Inserter = ZtoCountMap.insert( pair<int, int>((*AtomRunner)->getType()->getAtomicNumber(), 1) );
     if (!Inserter.second)
       Inserter.first->second += 1;
     const int Z = (*AtomRunner)->getType()->Z;
+    const int Z = (*AtomRunner)->getType()->getAtomicNumber();
     *file << "Ion_Type" << ZtoIndexMap[Z] << "_" << ZtoCountMap[Z] << "\t"  << fixed << setprecision(9) << showpoint;
     *file << (*AtomRunner)->at(0) << "\t" << (*AtomRunner)->at(1) << "\t" << (*AtomRunner)->at(2);

src/Parser/TremoloParser.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * TremoloParser.cpp
 …
  *      Author: metzler
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/Parser/XyzParser.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * XyzParser.cpp
 …
  *      Author: metzler
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
   newmol = World::getInstance().createMolecule();
   newmol->ActiveFlag = true;
+  // TODO: Remove the insertion into molecule when saving does not depend on them anymore. Also, remove molecule.hpp include
   World::getInstance().getMolecules()->insert(newmol);
   for (int i = 0; i < numberOfAtoms; i++) {
 …
   vector<atom*> atoms = World::getInstance().getAllAtoms();
   for(vector<atom*>::iterator it = atoms.begin(); it != atoms.end(); it++) {
     *file << noshowpoint << (*it)->getType()->symbol << "\t" << (*it)->at(0) << "\t" << (*it)->at(1) << "\t" << (*it)->at(2) << endl;
+    *file << noshowpoint << (*it)->getType()->getSymbol() << "\t" << (*it)->at(0) << "\t" << (*it)->at(1) << "\t" << (*it)->at(2) << endl;
+  }
+}

src/Patterns/ObservedContainer_impl.hpp

-              r8006ee
+              r994713
+}
+/************ Explicit instantiation ***************/
+#define CONSTRUCT_OBSERVEDCONTAINER(name) \
+    template ObservedContainer< name >& ObservedContainer< name >::operator=(const ObservedContainer< name >&); \
+    template ObservedContainer< name >::iterator ObservedContainer< name >::begin(); \
+    template ObservedContainer< name >::const_iterator ObservedContainer< name >::begin() const; \
+    template ObservedContainer< name >::iterator ObservedContainer< name >::end(); \
+    template ObservedContainer< name >::const_iterator ObservedContainer< name >::end() const; \
+    template ObservedContainer< name >::reverse_iterator ObservedContainer< name >::rbegin(); \
+    template ObservedContainer< name >::const_reverse_iterator ObservedContainer< name >::rbegin() const; \
+    template ObservedContainer< name >::reverse_iterator ObservedContainer< name >::rend(); \
+    template ObservedContainer< name >::const_reverse_iterator ObservedContainer< name >::rend() const; \
+    template bool ObservedContainer< name >::empty() const; \
+    template size_t ObservedContainer< name >::size() const; \
+    template size_t ObservedContainer< name >::max_size() const; \
+    template ObservedContainer< name >::mapped_type &ObservedContainer< name >::operator[](const key_type&); \
+    template std::pair<ObservedContainer< name >::iterator,bool> ObservedContainer< name >::insert (const value_type&); \
+    template size_t ObservedContainer< name >::erase ( const key_type& x ); \
+    template void ObservedContainer< name >::clear(); \
+    template ObservedContainer< name >::iterator ObservedContainer< name >::find ( const key_type& x ); \
+    template ObservedContainer< name >::const_iterator ObservedContainer< name >::find ( const key_type& x ) const; \
+    template size_t ObservedContainer< name >::count ( const key_type& x ) const; \
+    template ObservedContainer< name >::internal_iterator ObservedContainer< name >::begin_internal(); \
+    template ObservedContainer< name >::reverse_internal_iterator ObservedContainer< name >::rbegin_internal(); \
+    template ObservedContainer< name >::internal_iterator ObservedContainer< name >::end_internal(); \
+    template ObservedContainer< name >::reverse_internal_iterator ObservedContainer< name >::rend_internal(); \
 #endif /* OBSERVEDCONTAINER_IMPL_HPP_ */

src/Patterns/Observer.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Observer.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 #include "Observer.hpp"
 #include <iostream>

src/PointCloud.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * PointCloud.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "PointCloud.hpp"

src/Shapes/BaseShapes.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * BaseShapes_impl.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "Shapes/BaseShapes.hpp"
 #include "Shapes/BaseShapes_impl.hpp"
+#include <cmath>
+#include "Helpers/Assert.hpp"
 #include "LinearAlgebra/Vector.hpp"
 …
   return point.NormSquared()<=1;
+}
+/**
+ * algorithm taken from http://www.cgafaq.info/wiki/Evenly_distributed_points_on_sphere
+ * \param N number of points on surface
+ */
+std::vector<Vector> Sphere_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface;
+  const double dlength = M_PI*(3.-sqrt(5.));
+  double length = 0;
+  const double dz = 2.0/N;
+  double z = 1. - dz/2.;
+  Vector point;
+  for (int ka = 0; ka<N; ka++){
+    const double r = sqrt(1.-z*z);
+    point.Zero();
+    point[0] = cos(length)*r;
+    point[1] = sin(length)*r;
+    point[2] = z;
+    PointsOnSurface.push_back(point);
+    z = z - dz;
+    length = length + dlength;
+  }
+  ASSERT(PointsOnSurface.size() == N, "Sphere_impl::getHomogeneousPointsOnSurface() did not create enough points.");
+  return PointsOnSurface;
+}
 Shape Sphere(){
 …
 bool Cuboid_impl::isInside(const Vector &point){
+  return point[0]<=1 && point[1]<=1 && point[2]<=1;
+  return (point[0]>=0 && point[0]<=1) && (point[1]>=0 && point[1]<=1) && (point[2]>=0 && point[2]<=1);
+}
+/**
+ * \param N number of points on surface
+ */
+std::vector<Vector> Cuboid_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface;
+  ASSERT(false, "Cuboid_impl::getHomogeneousPointsOnSurface() not implemented yet");
+  return PointsOnSurface;
+}
 Shape Cuboid(){
   Shape::impl_ptr impl = Shape::impl_ptr(new Sphere_impl());
+  Shape::impl_ptr impl = Shape::impl_ptr(new Cuboid_impl());
   return Shape(impl);
+}

src/Shapes/BaseShapes_impl.hpp

-              r8006ee
+              r994713
 class Sphere_impl : public Shape_impl {
   virtual bool isInside(const Vector &point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 };
 class Cuboid_impl : public Shape_impl {
   virtual bool isInside(const Vector &point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 };

src/Shapes/Shape.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Shape.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "Shape.hpp"
 #include "Shape_impl.hpp"
+#include "Helpers/Assert.hpp"
+#include "LinearAlgebra/Vector.hpp"
 Shape::Shape(const Shape& src) :
 …
 bool Shape::isInside(const Vector &point) const{
   return impl->isInside(point);
+}
+std::vector<Vector> Shape::getHomogeneousPointsOnSurface(const int N) const {
+  return impl->getHomogeneousPointsOnSurface(N);
+}
 …
+}
+std::vector<Vector> AndShape_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface_lhs = lhs->getHomogeneousPointsOnSurface(N);
+  std::vector<Vector> PointsOnSurface_rhs = rhs->getHomogeneousPointsOnSurface(N);
+  std::vector<Vector> PointsOnSurface;
+  for (std::vector<Vector>::const_iterator iter = PointsOnSurface_lhs.begin(); iter != PointsOnSurface_lhs.end(); ++iter) {
+    if (rhs->isInside(*iter))
+      PointsOnSurface.push_back(*iter);
+  }
+  for (std::vector<Vector>::const_iterator iter = PointsOnSurface_rhs.begin(); iter != PointsOnSurface_rhs.end(); ++iter) {
+    if (lhs->isInside(*iter))
+      PointsOnSurface.push_back(*iter);
+  }
+  return PointsOnSurface;
+}
 Shape operator&&(const Shape &lhs,const Shape &rhs){
   Shape::impl_ptr newImpl = Shape::impl_ptr(new AndShape_impl(getShapeImpl(lhs),getShapeImpl(rhs)));
 …
 bool OrShape_impl::isInside(const Vector &point){
   return rhs->isInside(point) || lhs->isInside(point);
+}
+std::vector<Vector> OrShape_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface_lhs = lhs->getHomogeneousPointsOnSurface(N);
+  std::vector<Vector> PointsOnSurface_rhs = rhs->getHomogeneousPointsOnSurface(N);
+  std::vector<Vector> PointsOnSurface;
+  for (std::vector<Vector>::const_iterator iter = PointsOnSurface_lhs.begin(); iter != PointsOnSurface_lhs.end(); ++iter) {
+    if (!rhs->isInside(*iter))
+      PointsOnSurface.push_back(*iter);
+  }
+  for (std::vector<Vector>::const_iterator iter = PointsOnSurface_rhs.begin(); iter != PointsOnSurface_rhs.end(); ++iter) {
+    if (!lhs->isInside(*iter))
+      PointsOnSurface.push_back(*iter);
+  }
+  return PointsOnSurface;
+}
 …
+}
+std::vector<Vector> NotShape_impl::getHomogeneousPointsOnSurface(const int N) const {
+  // surfaces are the same, only normal direction is different
+  return arg->getHomogeneousPointsOnSurface(N);
+}
 Shape operator!(const Shape &arg){
   Shape::impl_ptr newImpl = Shape::impl_ptr(new NotShape_impl(getShapeImpl(arg)));

src/Shapes/Shape.hpp

-              r8006ee
+              r994713
 #include <boost/shared_ptr.hpp>
+#include <vector>
 class Vector;
 …
   bool isInside(const Vector &point) const;
+  std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
   Shape &operator=(const Shape& rhs);

src/Shapes/ShapeOps.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ShapeOps.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "Shapes/ShapeOps.hpp"
 …
+}
+std::vector<Vector> Resize_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface = arg->getHomogeneousPointsOnSurface(N);
+  for(std::vector<Vector>::iterator iter = PointsOnSurface.begin(); iter != PointsOnSurface.end(); ++iter) {
+    *iter *= size;
+  }
+  return PointsOnSurface;
+}
 Shape resize(const Shape &arg,double size){
   Shape::impl_ptr impl = Shape::impl_ptr(new Resize_impl(getShapeImpl(arg),size));
 …
 bool Translate_impl::isInside(const Vector& point){
   return arg->isInside(point-offset);
+}
+std::vector<Vector> Translate_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface = arg->getHomogeneousPointsOnSurface(N);
+  for(std::vector<Vector>::iterator iter = PointsOnSurface.begin(); iter != PointsOnSurface.end(); ++iter) {
+    *iter += offset;
+  }
+  return PointsOnSurface;
+}
 …
+}
+std::vector<Vector> Stretch_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface = arg->getHomogeneousPointsOnSurface(N);
+  for(std::vector<Vector>::iterator iter = PointsOnSurface.begin(); iter != PointsOnSurface.end(); ++iter) {
+    (*iter).ScaleAll(reciFactors);
+  }
+  return PointsOnSurface;
+}
 Shape stretch(const Shape &arg, const Vector &factors){
   Shape::impl_ptr impl = Shape::impl_ptr(new Stretch_impl(getShapeImpl(arg),factors));
 …
+}
+std::vector<Vector> Transform_impl::getHomogeneousPointsOnSurface(const int N) const {
+  std::vector<Vector> PointsOnSurface = arg->getHomogeneousPointsOnSurface(N);
+  for(std::vector<Vector>::iterator iter = PointsOnSurface.begin(); iter != PointsOnSurface.end(); ++iter) {
+    *iter = transformation * (*iter);
+  }
+  return PointsOnSurface;
+}
 Shape transform(const Shape &arg, const Matrix &transformation){
   Shape::impl_ptr impl = Shape::impl_ptr(new Transform_impl(getShapeImpl(arg),transformation));

src/Shapes/ShapeOps_impl.hpp

-              r8006ee
+              r994713
   virtual ~Resize_impl();
   virtual bool isInside(const Vector& point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr arg;
 …
   virtual ~Translate_impl();
   virtual bool isInside(const Vector& point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr arg;
 …
   virtual ~Stretch_impl();
   virtual bool isInside(const Vector& point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr arg;
 …
   virtual ~Transform_impl();
   virtual bool isInside(const Vector& point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr arg;

src/Shapes/Shape_impl.hpp

-              r8006ee
+              r994713
 #define SHAPE_IMPL_HPP_
+#include <vector>
 #include "Shapes/Shape.hpp"
+class Vector;
 class Shape_impl {
 …
   virtual ~Shape_impl(){};
   virtual bool isInside(const Vector &point)=0;
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const=0;
 };
 …
     return true;
+  }
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const {
+    std::vector<Vector> PointsOnSurface;
+    return PointsOnSurface;
+  }
 };
 …
   virtual bool isInside(const Vector &point){
     return false;
+  }
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const {
+    std::vector<Vector> PointsOnSurface;
+    return PointsOnSurface;
+  }
 };
 …
   virtual ~AndShape_impl();
   virtual bool isInside(const Vector &point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr lhs;
 …
   virtual ~OrShape_impl();
   virtual bool isInside(const Vector &point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr lhs;
 …
   virtual ~NotShape_impl();
   virtual bool isInside(const Vector &point);
+  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const int N) const;
 private:
   Shape::impl_ptr arg;

src/TesselPoint.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * TesselPoint.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "TesselPoint.hpp"

src/ThermoStatContainer.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ThermoStatContainer.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include <cstring>

src/UIElements/CommandLineUI/CommandLineDialog.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * CommandLineDialog.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/CommandLineUI/CommandLineStatusIndicator.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * CommandLineStatusIndicator.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/CommandLineUI/CommandLineUIFactory.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * CommandLineUIFactory.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/CommandLineUI/CommandLineWindow.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * CommandLineWindow.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/Dialog.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Dialog.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/Dialog.hpp

-              r8006ee
+              r994713
     virtual void setResult();
   protected:
     element * tmp;
+    const element * tmp;
   };
 …
     virtual void setResult();
   protected:
     element *temp;
     std::vector<element *> tmp;
+    const element *temp;
+    std::vector<const element *> tmp;
   };

src/UIElements/MainWindow.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Window.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/Menu/ActionMenuItem.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ActionMenuItem.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/Menu/DisplayMenuItem.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * DisplayMenuItem.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/Menu/Menu.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * Menu.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/Menu/MenuItem.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MenuItem.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/Menu/QT4/QTMenu.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * QTMenu.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Menu/QT4/QTMenu.hpp"
 #include <Qt/qaction.h>
+#include "Helpers/MemDebug.hpp"
 #include "Menu/MenuItem.hpp"

src/UIElements/Menu/SeperatorItem.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SeperatorItem.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/Menu/SubMenuItem.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SubMenuItem.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/Menu/TextMenu.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * TextMenu.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/QT4/QTDialog.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * QTDialog.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "UIElements/QT4/QTDialog.hpp"
 …
+  {
     stringstream sstr;
     sstr << (*iter).first << "\t" << (*iter).second->name;
+    sstr << (*iter).first << "\t" << (*iter).second->getName();
     inputBox->addItem(QString(sstr.str().c_str()),QVariant((*iter).first));
+  }
 …
+  {
     stringstream sstr;
     sstr << (*iter).first << "\t" << (*iter).second->name;
+    sstr << (*iter).first << "\t" << (*iter).second->getName();
     inputBox->addItem(QString(sstr.str().c_str()),QVariant((*iter).first));
+  }
 …
+}
 ElementQTQueryPipe::ElementQTQueryPipe(element **_content, QTDialog *_dialog, QComboBox *_theBox) :
+ElementQTQueryPipe::ElementQTQueryPipe(const element **_content, QTDialog *_dialog, QComboBox *_theBox) :
   content(_content),
   dialog(_dialog),
 …
+}
 ElementsQTQueryPipe::ElementsQTQueryPipe(std::vector<element *>*_content, QTDialog *_dialog, QComboBox *_theBox) :
+ElementsQTQueryPipe::ElementsQTQueryPipe(std::vector<const element *>*_content, QTDialog *_dialog, QComboBox *_theBox) :
   content(_content),
   dialog(_dialog),
 …
   QVariant data = theBox->itemData(newIndex);
   int idx = data.toInt();
   element *elemental = World::getInstance().getPeriode()->FindElement(idx);
+  const element *elemental = World::getInstance().getPeriode()->FindElement(idx);
   if(elemental)
     (*content).push_back(elemental);

src/UIElements/QT4/QTDialog.hpp

-              r8006ee
+              r994713
   Q_OBJECT
 public:
   ElementQTQueryPipe(element **_content, QTDialog *_dialog, QComboBox *_theBox);
+  ElementQTQueryPipe(const element **_content, QTDialog *_dialog, QComboBox *_theBox);
   virtual ~ElementQTQueryPipe();
 …
 private:
   element **content;
+  const element **content;
   QTDialog *dialog;
   QComboBox *theBox;
 …
   Q_OBJECT
 public:
   ElementsQTQueryPipe(std::vector<element *>*_content, QTDialog *_dialog, QComboBox *_theBox);
+  ElementsQTQueryPipe(std::vector<const element *>*_content, QTDialog *_dialog, QComboBox *_theBox);
   virtual ~ElementsQTQueryPipe();
 …
 private:
   std::vector<element *>*content;
+  std::vector<const element *>*content;
   QTDialog *dialog;
   QComboBox *theBox;

src/UIElements/QT4/QTMainWindow.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * QTMainWindow.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "QTMainWindow.hpp"
 …
 #include<boost/bind.hpp>
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
 #include "molecule.hpp"
 …
 #include "Views/QT4/QTMoleculeView.hpp"
 #include "Views/QT4/QTStatusBar.hpp"
-#include "Helpers/MemDebug.hpp"
 using namespace std;

src/UIElements/QT4/QTUIFactory.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * QTUIFactory.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include <iostream>
 #include <cassert>
+using namespace std;
+#include <qapplication.h>
-#include <qapplication.h>
 #include "UIElements/QT4/QTUIFactory.hpp"
 #include "UIElements/QT4/QTMainWindow.hpp"
 #include "UIElements/QT4/QTDialog.hpp"
+#include "Helpers/MemDebug.hpp"
 #include "version.h"
 #include "defs.hpp"
+#include "Helpers/MemDebug.hpp"
+using namespace std;
 QTUIFactory::QTUIFactory() :
 …
   argv = new char*[1];
   argv[0] = new char[256];
   strcpy(argv[0],ESPACKVersion);
+  strcpy(argv[0],MOLECUILDERVERSION);
   app = new QApplication(argc,argv);
+}

src/UIElements/TextUI/TextDialog.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * TextDialog.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
   bool badInput=false;
   bool aborted = false;
   element * temp = NULL;
+  const element * temp = NULL;
   do{
     badInput = false;

src/UIElements/TextUI/TextStatusIndicator.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * TextStatusIndicator.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/TextUI/TextUIFactory.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * TextUIFactory.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "UIElements/TextUI/TextUIFactory.hpp"

src/UIElements/TextUI/TextWindow.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * TextWindow.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
   new SeperatorItem(main_menu);
   Action* undoAction = ActionRegistry::getInstance().getActionByName("Undo");
+  Action* undoAction = ActionRegistry::getInstance().getActionByName("undo");
   new ActionMenuItem('u',"Undo last operation",main_menu,undoAction);
   Action* redoAction = ActionRegistry::getInstance().getActionByName("Redo");
+  Action* redoAction = ActionRegistry::getInstance().getActionByName("redo");
   new ActionMenuItem('r',"Redo last operation",main_menu,redoAction);

src/UIElements/UIFactory.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * UIFactory.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/Views/MethodStringView.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MethodStringView.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/Views/QT4/GLMoleculeView.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * GLMoleculeView.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "GLMoleculeView.hpp"
+#include "Helpers/MemDebug.hpp"
 GLMoleculeView::GLMoleculeView(QWidget *parent) :

src/UIElements/Views/QT4/QTMoleculeView.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * QTMoleculeView.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Views/QT4/QTMoleculeView.hpp"
 #include <iostream>
+#include "Helpers/MemDebug.hpp"
 #include "molecule.hpp"
 using namespace std;

src/UIElements/Views/QT4/QTStatusBar.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * QTStatusBar.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include <sstream>
 …
 #include "QTStatusBar.hpp"
+#include "Helpers/MemDebug.hpp"
 #include "World.hpp"
 #include "Helpers/helpers.hpp"
 …
   QStatusBar(_parent),
   Observer("QTStatusBar"),
-  parent(_parent),
   atomCount(World::getInstance().numAtoms()),
+  moleculeCount(World::getInstance().numMolecules())
+  moleculeCount(World::getInstance().numMolecules()),
+  parent(_parent)
+{
   World::getInstance().signOn(this);

src/UIElements/Views/QT4/QTWorldView.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * QTWorldView.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Views/QT4/QTWorldView.hpp"
 #include <iostream>
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
+#include "Formula.hpp"
 #include "molecule.hpp"
 …
 // these attributes are skiped so far
 const int QTWorldView::COLUMNCOUNT = COLUMNTYPES_MAX;
 const char *QTWorldView::COLUMNNAMES[QTWorldView::COLUMNCOUNT]={"Name","Atoms"/*,"Formula"*/,"Center"/*,"Size"*/};
+const char *QTWorldView::COLUMNNAMES[QTWorldView::COLUMNCOUNT]={"Name","Atoms","Formula"/*,"Size"*/};
 QTWorldView::QTWorldView(QWidget * _parent) :
 …
     const int index = (*iter)->IndexNr;
     QTableWidgetItem *indexWidget = new QTableWidgetItem();
+    // there probably is an easier method to convert ints to QStrings... but i didn't find it
+    stringstream idxsstr;
+    idxsstr << index;
+    indexWidget->setText(QString(idxsstr.str().c_str()));
+    indexWidget->setText(QString::number(index));
     indexWidget->setData(Qt::UserRole,QVariant(index));
     setVerticalHeaderItem(i,indexWidget);
 …
     const int atomCount = (*iter)->getAtomCount();
     QTableWidgetItem *countWidget= new QTableWidgetItem();
+    stringstream countsstr;
+    countsstr << atomCount;
+    countWidget->setText(QString(countsstr.str().c_str()));
+    countWidget->setText(QString::number(atomCount));
     countWidget->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
     setItem(i,ATOMS,countWidget);
+    const Vector center = (*iter)->Center;
+    QTableWidgetItem *centerWidget = new QTableWidgetItem();
+    stringstream centersstr;
+    centersstr << center;
+    centerWidget->setText(QString(centersstr.str().c_str()));
+    setItem(i,CENTER,centerWidget);
+    centerWidget->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
+    const Formula formula = (*iter)->getFormula();
+    QTableWidgetItem *formulaWidget= new QTableWidgetItem();
+    formulaWidget->setText(QString(formula.toString().c_str()));
+    formulaWidget->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
+    setItem(i,ATOMS,formulaWidget);
     molSelection[i]=nameWidget->isSelected();

src/UIElements/Views/QT4/QTWorldView.hpp

r8006ee	r994713
28	28
29	29	static const int COLUMNCOUNT;
30		enum {NAME,ATOMS,~~CENTER~~,COLUMNTYPES_MAX} COLUMNTYPES;
	30	enum {NAME,ATOMS,FORMULA,COLUMNTYPES_MAX} COLUMNTYPES;
31	31	static const char *COLUMNNAMES[];
32	32

src/UIElements/Views/StreamStringView.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * StreamStringView.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/Views/StringView.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * StringView.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/UIElements/Views/View.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * View.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/World.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * World.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 void World::destroyMolecule(molecule* mol){
   OBSERVE;
+  ASSERT(mol,"Molecule that was meant to be destroyed did not exist");
   destroyMolecule(mol->getId());
+}
 …
       atoms.erase(oldId);
       atoms.insert(pair<atomId_t,atom*>(newId,target));
+      return true;
+    }
+    else{
+      return false;
+    }
+  }
+}
+bool World::changeMoleculeId(moleculeId_t oldId, moleculeId_t newId, molecule* target){
+  OBSERVE;
+  // in case this call did not originate from inside the atom, we redirect it,
+  // to also let it know that it has changed
+  if(!target){
+    target = molecules[oldId];
+    ASSERT(target,"Molecule with that ID not found");
+    return target->changeId(newId);
+  }
+  else{
+    if(reserveMoleculeId(newId)){
+      molecules.erase(oldId);
+      molecules.insert(pair<moleculeId_t,molecule*>(newId,target));
       return true;
+    }
 …
     selectedMolecules(this),
     currMoleculeId(0),
+    lastMoleculePoolSize(0),
+    numMoleculeDefragSkips(0),
     molecules_deprecated(new MoleculeListClass(this))
+{
 …
 CONSTRUCT_SINGLETON(World)
+CONSTRUCT_OBSERVEDCONTAINER(World::AtomSTLSet)
+CONSTRUCT_OBSERVEDCONTAINER(World::MoleculeSTLSet)
 /******************************* deprecated Legacy Stuff ***********************/

src/World.hpp

-              r8006ee
+              r994713
 template<typename> friend class AtomsCalculation;
 public:
+  // some typedefs for the CONSTRUCT_... macros (no "," allows in a single parameter name)
+  typedef std::map<atomId_t,atom*> AtomSTLSet;
+  typedef std::map<moleculeId_t,molecule*> MoleculeSTLSet;
   // Types for Atom and Molecule structures
   typedef ObservedContainer<std::map<atomId_t,atom*> > AtomSet;
   typedef ObservedContainer<std::map<moleculeId_t,molecule*> > MoleculeSet;
+  typedef ObservedContainer< AtomSTLSet > AtomSet;
+  typedef ObservedContainer< MoleculeSTLSet > MoleculeSet;
   typedef ATOMSET(std::vector) AtomComposite;
 …
    */
   bool changeAtomId(atomId_t oldId, atomId_t newId, atom* target=0);
+  /**
+   * used when changing an molecule Id.
+   * Unless you are calling this method from inside an moleucle don't fiddle with the third parameter.
+   *
+   * Return value indicates wether the change could be done or not.
+   */
+  bool changeMoleculeId(moleculeId_t oldId, moleculeId_t newId, molecule* target=0);
   /**

src/analysis_bonds.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * analysis_bonds.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
         molecule::iterator Runner = (*MolRunner)->begin();
         for(;Runner!=(*MolRunner)->end();++Runner){
           if (((*Walker)->getType()->Z  == 8) && ((*Runner)->getType()->Z  == 8)) {
+          if (((*Walker)->getType()->getAtomicNumber()  == 8) && ((*Runner)->getType()->getAtomicNumber()  == 8)) {
             // check distance
             const double distance = (*Runner)->DistanceSquared(*(*Walker));
 …
                 atom * const OtherAtom = (*BondRunner)->GetOtherAtom(*Runner);
                 // if hydrogen, check angle to be greater(!) than 30 degrees
                 if (OtherAtom->getType()->Z == 1) {
+                if (OtherAtom->getType()->getAtomicNumber() == 1) {
                   const double angle = CalculateAngle(OtherAtom->getPosition(), (*Runner)->getPosition(), (*Walker)->getPosition());
                   OtherHydrogenFlag = OtherHydrogenFlag && (angle > M_PI*(30./180.) + MYEPSILON);
 …
                 for (BondList::const_iterator BondRunner = (*Walker)->ListOfBonds.begin(); BondRunner != (*Walker)->ListOfBonds.end(); BondRunner++) {
                   atom * const OtherAtom = (*BondRunner)->GetOtherAtom(*Walker);
                   if (OtherAtom->getType()->Z == 1) {
+                  if (OtherAtom->getType()->getAtomicNumber() == 1) {
                     // check angle
                     if (CheckHydrogenBridgeBondAngle(*Walker, OtherAtom, *Runner)) {
 …
           if (((OtherAtom->getType() == first) || (OtherAtom->getType() == second)) && (theAtom->nr < OtherAtom->nr)) {
             count++;
             DoLog(1) && (Log() << Verbose(1) << first->name << "-" << second->name << " bond found between " << *Walker << " and " << *OtherAtom << "." << endl);
+            DoLog(1) && (Log() << Verbose(1) << *first << "-" << *second << " bond found between " << *Walker << " and " << *OtherAtom << "." << endl);
+          }
+        }
 …
         if (result) { // check results
           count++;
           DoLog(1) && (Log() << Verbose(1) << first->name << "-" << second->name << "-" << third->name << " bond found at " << *Walker << "." << endl);
+          DoLog(1) && (Log() << Verbose(1) << *first << "-" << *second << "-" << *third << " bond found at " << *Walker << "." << endl);
+        }
+      }

src/analysis_correlation.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * analysis.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
  * \return Map of doubles with values the pair of the two atoms.
  */
 PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements)
+PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<const element *> &elements)
+{
   Info FunctionInfo(__func__);
 …
   // create all possible pairs of elements
   set <pair<element *, element *> > PairsOfElements;
+  set <pair<const element *,const element *> > PairsOfElements;
   if (elements.size() >= 2) {
     for (vector<element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
       for (vector<element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
+    for (vector<const element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
+      for (vector<const element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
         if (type1 != type2) {
           PairsOfElements.insert( pair<element *, element*>(*type1,*type2) );
           DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << (*type1)->symbol << " and " << (*type2)->symbol << "." << endl);
+          PairsOfElements.insert( make_pair(*type1,*type2) );
+          DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << *(*type1) << " and " << *(*type2) << "." << endl);
+        }
   } else if (elements.size() == 1) { // one to all are valid
     element *elemental = *elements.begin();
     PairsOfElements.insert( pair<element *, element*>(elemental,(element *)NULL) );
     PairsOfElements.insert( pair<element *, element*>((element *)NULL,elemental) );
+    const element *elemental = *elements.begin();
+    PairsOfElements.insert( pair<const element *,const element*>(elemental,0) );
+    PairsOfElements.insert( pair<const element *,const element*>(0,elemental) );
   } else { // all elements valid
     PairsOfElements.insert( pair<element *, element*>((element *)NULL, (element *)NULL) );
 …
           DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
           if ((*iter)->getId() < (*runner)->getId()){
             for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
+            for (set <pair<const element *, const element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
               if ((PairRunner->first == (**iter).getType()) && (PairRunner->second == (**runner).getType())) {
                 distance = domain.periodicDistance((*iter)->getPosition(),(*runner)->getPosition());
 …
  * \return Map of doubles with values the pair of the two atoms.
  */
 PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const int ranges[NDIM] )
+PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
   // create all possible pairs of elements
   set <pair<element *, element *> > PairsOfElements;
+  set <pair<const element *,const element *> > PairsOfElements;
   if (elements.size() >= 2) {
     for (vector<element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
       for (vector<element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
+    for (vector<const element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
+      for (vector<const element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
         if (type1 != type2) {
           PairsOfElements.insert( pair<element *, element*>(*type1,*type2) );
           DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << (*type1)->symbol << " and " << (*type2)->symbol << "." << endl);
+          PairsOfElements.insert( make_pair(*type1,*type2) );
+          DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << *(*type1) << " and " << *(*type2) << "." << endl);
+        }
   } else if (elements.size() == 1) { // one to all are valid
     element *elemental = *elements.begin();
     PairsOfElements.insert( pair<element *, element*>(elemental,(element *)NULL) );
     PairsOfElements.insert( pair<element *, element*>((element *)NULL,elemental) );
+    const element *elemental = *elements.begin();
+    PairsOfElements.insert( pair<const element *,const element*>(elemental,0) );
+    PairsOfElements.insert( pair<const element *,const element*>(0,elemental) );
   } else { // all elements valid
     PairsOfElements.insert( pair<element *, element*>((element *)NULL, (element *)NULL) );
 …
                   DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
                   if ((*iter)->getId() < (*runner)->getId()){
                     for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
+                    for (set <pair<const element *,const element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
                       if ((PairRunner->first == (**iter).getType()) && (PairRunner->second == (**runner).getType())) {
                         periodicOtherX = FullInverseMatrix * ((*runner)->getPosition()); // x now in [0,1)^3
 …
  * \return Map of dobules with values as pairs of atom and the vector
  */
 CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point )
+CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Vector *point )
+{
   Info FunctionInfo(__func__);
 …
     for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
       DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
       for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+      for (vector<const element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
         if ((*type == NULL) || ((*iter)->getType() == *type)) {
           distance = domain.periodicDistance((*iter)->getPosition(),*point);
 …
  * \return Map of dobules with values as pairs of atom and the vector
  */
 CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] )
+CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Vector *point, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
     for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
       DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
       for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+      for (vector<const element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
         if ((*type == NULL) || ((*iter)->getType() == *type)) {
           periodicX = FullInverseMatrix * ((*iter)->getPosition()); // x now in [0,1)^3
 …
  * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
  */
 CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC )
+CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Tesselation * const Surface, const LinkedCell *LC )
+{
   Info FunctionInfo(__func__);
 …
     for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
       DoLog(3) && (Log() << Verbose(3) << "\tCurrent atom is " << *(*iter) << "." << endl);
       for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+      for (vector<const element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
         if ((*type == NULL) || ((*iter)->getType() == *type)) {
           TriangleIntersectionList Intersections((*iter)->getPosition(),Surface,LC);
 …
  * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
  */
 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
+CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
     for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
       DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
       for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+      for (vector<const element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
         if ((*type == NULL) || ((*iter)->getType() == *type)) {
           periodicX = FullInverseMatrix * ((*iter)->getPosition()); // x now in [0,1)^3

src/analysis_correlation.hpp

-              r8006ee
+              r994713
 #endif
+#include <cmath>
 #include <fstream>
 …
 /********************************************** declarations *******************************/
 PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements);
 CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point );
 CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC );
 PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const int ranges[NDIM] );
 CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] );
 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] );
+PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<const element *> &elements);
+CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Vector *point );
+CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Tesselation * const Surface, const LinkedCell *LC );
+PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const int ranges[NDIM] );
+CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Vector *point, const int ranges[NDIM] );
+CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] );
 int GetBin ( const double value, const double BinWidth, const double BinStart );
 void OutputCorrelation( ofstream * const file, const BinPairMap * const map );

src/analyzer.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file analyzer.cpp
+ *
 …
 //============================ INCLUDES ===========================
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 #include "periodentafel.hpp"
 #include "Helpers/Verbose.hpp"
-// include config.h
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
 //============================== MAIN =============================

src/atom.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file atom.cpp
+ *
 …
+ *
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 bool atom::OutputArrayIndexed(ostream * const out,const enumeration<const element*> &elementLookup, int *AtomNo, const char *comment) const
+{
   AtomNo[getType()->Z]++;  // increment number
+  AtomNo[getType()->getAtomicNumber()]++;  // increment number
   if (out != NULL) {
     const element *elemental = getType();
     cout << "Looking for atom with element " << *elemental << endl;
     ASSERT(elementLookup.there.find(elemental)!=elementLookup.there.end(),"Type of this atom was not in the formula upon enumeration");
     *out << "Ion_Type" << elementLookup.there.find(elemental)->second << "_" << AtomNo[elemental->Z] << "\t"  << fixed << setprecision(9) << showpoint;
+    *out << "Ion_Type" << elementLookup.there.find(elemental)->second << "_" << AtomNo[elemental->getAtomicNumber()] << "\t"  << fixed << setprecision(9) << showpoint;
     *out << at(0) << "\t" << at(1) << "\t" << at(2);
     *out << "\t" << FixedIon;
 …
+{
   if (out != NULL) {
     *out << getType()->symbol << "\t" << at(0) << "\t" << at(1) << "\t" << at(2) << "\t" << endl;
+    *out << getType()->getSymbol() << "\t" << at(0) << "\t" << at(1) << "\t" << at(2) << "\t" << endl;
     return true;
   } else
 …
 bool atom::OutputTrajectory(ofstream * const out, const int *ElementNo, int *AtomNo, const int step) const
+{
   AtomNo[getType()->Z]++;
   if (out != NULL) {
     *out << "Ion_Type" << ElementNo[getType()->Z] << "_" << AtomNo[getType()->Z] << "\t"  << fixed << setprecision(9) << showpoint;
+  AtomNo[getType()->getAtomicNumber()]++;
+  if (out != NULL) {
+    *out << "Ion_Type" << ElementNo[getType()->getAtomicNumber()] << "_" << AtomNo[getType()->getAtomicNumber()] << "\t"  << fixed << setprecision(9) << showpoint;
     *out << Trajectory.R.at(step)[0] << "\t" << Trajectory.R.at(step)[1] << "\t" << Trajectory.R.at(step)[2];
     *out << "\t" << FixedIon;
 …
+{
   if (out != NULL) {
     *out << getType()->symbol << "\t";
+    *out << getType()->getSymbol() << "\t";
     *out << Trajectory.R.at(step)[0] << "\t";
     *out << Trajectory.R.at(step)[1] << "\t";
 …
   Vector recentered(getPosition());
   recentered -= *center;
   *out << "\t\t" << getType()->symbol << " [ " << recentered[0] << "\t" << recentered[1] << "\t" << recentered[2] << " ]" << endl;
+  *out << "\t\t" << getType()->getSymbol() << " [ " << recentered[0] << "\t" << recentered[1] << "\t" << recentered[2] << " ]" << endl;
   if (AtomNo != NULL)
     *AtomNo++;
 …
+}
+/** Makes the atom be contained in the new molecule \a *_mol.
+ * Uses atom::removeFromMolecule() to delist from old molecule.
+ * \param *_mol pointer to new molecule
+ */
 void atom::setMolecule(molecule *_mol){
   // take this atom from the old molecule
 …
+}
+molecule* atom::getMolecule(){
+/** Returns pointer to the molecule which atom belongs to.
+ * \return containing molecule
+ */
+molecule* atom::getMolecule() const {
   return mol;
+}
+/** Erases the atom in atom::mol's list of atoms and sets it to zero.
+ */
 void atom::removeFromMolecule(){
   if(mol){

src/atom.hpp

r8006ee	r994713
92	92
93	93	void setMolecule(molecule*);
94		molecule* getMolecule();
	94	molecule* getMolecule() const;
95	95	void removeFromMolecule();
96	96

src/atom_atominfo.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * atom_atominfo.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/atom_bondedparticle.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * atom_bondedparticle.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
   NoBonds = CountBonds();
   //Log() << Verbose(3) << "Walker " << *this << ": " << (int)this->type->NoValenceOrbitals << " > " << NoBonds << "?" << endl;
   if ((int)(getType()->NoValenceOrbitals) > NoBonds) { // we have a mismatch, check all bonding partners for mismatch
+  if ((int)(getType()->getNoValenceOrbitals()) > NoBonds) { // we have a mismatch, check all bonding partners for mismatch
     for (BondList::const_iterator Runner = ListOfBonds.begin(); Runner != ListOfBonds.end(); (++Runner)) {
       OtherWalker = (*Runner)->GetOtherAtom(this);
       OtherNoBonds = OtherWalker->CountBonds();
       //Log() << Verbose(3) << "OtherWalker " << *OtherWalker << ": " << (int)OtherWalker->type->NoValenceOrbitals << " > " << OtherNoBonds << "?" << endl;
       if ((int)(OtherWalker->getType()->NoValenceOrbitals) > OtherNoBonds) { // check if possible candidate
+      if ((int)(OtherWalker->getType()->getNoValenceOrbitals()) > OtherNoBonds) { // check if possible candidate
         if ((CandidateBond == NULL) || (ListOfBonds.size() > OtherWalker->ListOfBonds.size())) { // pick the one with fewer number of bonds first
           CandidateBond = (*Runner);

src/atom_bondedparticleinfo.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * atom_bondedparticleinfo.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/atom_graphnode.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * atom_graphnode.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/atom_graphnodeinfo.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * atom_graphnodeinfo.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/atom_particleinfo.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * atom_particleinfo.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/atom_trajectoryparticle.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * atom_trajectoryparticle.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
+{
   for (int i=NDIM;i--;)
     *temperature += getType()->mass * Trajectory.U.at(step)[i]* Trajectory.U.at(step)[i];
+    *temperature += getType()->getMass() * Trajectory.U.at(step)[i]* Trajectory.U.at(step)[i];
 };
 …
   for(int d=0;d<NDIM;d++) {
     Trajectory.U.at(Step)[d] -= CoGVelocity->at(d);
     *ActualTemp += 0.5 * getType()->mass * Trajectory.U.at(Step)[d] * Trajectory.U.at(Step)[d];
+    *ActualTemp += 0.5 * getType()->getMass() * Trajectory.U.at(Step)[d] * Trajectory.U.at(Step)[d];
+  }
 };
 …
     Trajectory.R.at(NextStep)[d] = Trajectory.R.at(NextStep-1)[d];
     Trajectory.R.at(NextStep)[d] += configuration->Deltat*(Trajectory.U.at(NextStep-1)[d]);     // s(t) = s(0) + v * deltat + 1/2 a * deltat^2
     Trajectory.R.at(NextStep)[d] += 0.5*configuration->Deltat*configuration->Deltat*(Trajectory.F.at(NextStep)[d]/getType()->mass);     // F = m * a and s =
+    Trajectory.R.at(NextStep)[d] += 0.5*configuration->Deltat*configuration->Deltat*(Trajectory.F.at(NextStep)[d]/getType()->getMass());     // F = m * a and s =
+  }
   // Update U
   for (int d=0; d<NDIM; d++) {
     Trajectory.U.at(NextStep)[d] = Trajectory.U.at(NextStep-1)[d];
     Trajectory.U.at(NextStep)[d] += configuration->Deltat * (Trajectory.F.at(NextStep)[d]+Trajectory.F.at(NextStep-1)[d]/getType()->mass); // v = F/m * t
+    Trajectory.U.at(NextStep)[d] += configuration->Deltat * (Trajectory.F.at(NextStep)[d]+Trajectory.F.at(NextStep-1)[d]/getType()->getMass()); // v = F/m * t
+  }
   // Update R (and F)
 …
 void TrajectoryParticle::SumUpKineticEnergy( int Step, double *TotalMass, Vector *TotalVelocity ) const
+{
   *TotalMass += getType()->mass;  // sum up total mass
+  *TotalMass += getType()->getMass();  // sum up total mass
   for(int d=0;d<NDIM;d++) {
     TotalVelocity->at(d) += Trajectory.U.at(Step)[d]*getType()->mass;
+    TotalVelocity->at(d) += Trajectory.U.at(Step)[d]*getType()->getMass();
+  }
 };
 …
     for (int d=0; d<NDIM; d++) {
       U[d] *= ScaleTempFactor;
       *ekin += 0.5*getType()->mass * U[d]*U[d];
+      *ekin += 0.5*getType()->getMass() * U[d]*U[d];
+    }
 };
 …
     for (int d=0; d<NDIM; d++) {
       *G += U[d] * F[d];
       *E += U[d]*U[d]*getType()->mass;
+      *E += U[d]*U[d]*getType()->getMass();
+    }
 };
 …
   if (FixedIon == 0) // even FixedIon moves, only not by other's forces
     for (int d=0; d<NDIM; d++) {
       U[d] += configuration->Deltat/getType()->mass * ( (G_over_E) * (U[d]*getType()->mass) );
       *ekin += getType()->mass * U[d]*U[d];
+      U[d] += configuration->Deltat/getType()->getMass() * ( (G_over_E) * (U[d]*getType()->getMass()) );
+      *ekin += getType()->getMass() * U[d]*U[d];
+    }
 };
 …
 void TrajectoryParticle::Thermostat_Langevin(int Step, gsl_rng * r, double *ekin, config *configuration)
+{
   double sigma  = sqrt(configuration->Thermostats->TargetTemp/getType()->mass); // sigma = (k_b T)/m (Hartree/atomicmass = atomiclength/atomictime)
+  double sigma  = sqrt(configuration->Thermostats->TargetTemp/getType()->getMass()); // sigma = (k_b T)/m (Hartree/atomicmass = atomiclength/atomictime)
   Vector &U = Trajectory.U.at(Step);
   if (FixedIon == 0) { // even FixedIon moves, only not by other's forces
 …
+    }
     for (int d=0; d<NDIM; d++)
       *ekin += 0.5*getType()->mass * U[d]*U[d];
+      *ekin += 0.5*getType()->getMass() * U[d]*U[d];
+  }
 };
 …
     for (int d=0; d<NDIM; d++) {
       U[d] *= sqrt(1+(configuration->Deltat/configuration->Thermostats->TempFrequency)*(ScaleTempFactor-1));
       *ekin += 0.5*getType()->mass * U[d]*U[d];
+      *ekin += 0.5*getType()->getMass() * U[d]*U[d];
+    }
+  }
 …
   if (FixedIon == 0) { // even FixedIon moves, only not by other's forces
     for (int d=0; d<NDIM; d++) {
       *delta_alpha += U[d]*U[d]*getType()->mass;
+      *delta_alpha += U[d]*U[d]*getType()->getMass();
+    }
+  }
 …
   if (FixedIon == 0) { // even FixedIon moves, only not by other's forces
     for (int d=0; d<NDIM; d++) {
         U[d] += configuration->Deltat/getType()->mass * (configuration->Thermostats->alpha * (U[d] * getType()->mass));
         *ekin += (0.5*getType()->mass) * U[d]*U[d];
+        U[d] += configuration->Deltat/getType()->getMass() * (configuration->Thermostats->alpha * (U[d] * getType()->getMass()));
+        *ekin += (0.5*getType()->getMass()) * U[d]*U[d];
+      }
+  }

src/atom_trajectoryparticle.hpp

r8006ee	r994713
20	20	#include <fstream>
21	21
22		~~#include <gsl/gsl_inline.h>~~
23	22	#include <gsl/gsl_randist.h>
24	23

src/atom_trajectoryparticleinfo.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * atom_trajectoryparticleinfo.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/bond.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file bond.cpp
+ *
 …
+ *
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
+{
   if ((left != NULL) && (right != NULL)) {
     if ((left->getType() != NULL) && (left->getType()->Z == 1))
+    if ((left->getType() != NULL) && (left->getType()->getAtomicNumber() == 1))
       HydrogenBond++;
     if ((right->getType() != NULL) && (right->getType()->Z == 1))
+    if ((right->getType() != NULL) && (right->getType()->getAtomicNumber() == 1))
       HydrogenBond++;
+  }

src/bondgraph.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * bondgraph.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
     if ((*iter)->getType()->CovalentRadius > max_distance)
       max_distance = (*iter)->getType()->CovalentRadius;
+    if ((*iter)->getType()->getCovalentRadius() > max_distance)
+      max_distance = (*iter)->getType()->getCovalentRadius();
+  }
   max_distance *= 2.;
 …
 void BondGraph::CovalentMinMaxDistance(BondedParticle * const Walker, BondedParticle * const OtherWalker, double &MinDistance, double &MaxDistance, bool IsAngstroem)
+{
   MinDistance = OtherWalker->getType()->CovalentRadius + Walker->getType()->CovalentRadius;
+  MinDistance = OtherWalker->getType()->getCovalentRadius() + Walker->getType()->getCovalentRadius();
   MinDistance *= (IsAngstroem) ? 1. : 1. / AtomicLengthToAngstroem;
   MaxDistance = MinDistance + BondThreshold;
 …
     CovalentMinMaxDistance(Walker, OtherWalker, MinDistance, MaxDistance, IsAngstroem);
   } else {
     MinDistance = GetBondLength(Walker->getType()->Z-1, OtherWalker->getType()->Z-1);
+    MinDistance = GetBondLength(Walker->getType()->getAtomicNumber()-1, OtherWalker->getType()->getAtomicNumber()-1);
     MinDistance *= (IsAngstroem) ? 1. : 1. / AtomicLengthToAngstroem;
     MaxDistance = MinDistance + BondThreshold;

src/boundary.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file boundary.cpp
+ *
  * Implementations and super-function for envelopes
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
+      }
     DoLog(1) && (Log() << Verbose(1) << "Inserting " << **iter << ": (r, alpha) = (" << radius << "," << angle << "): " << ProjectedVector << endl);
       BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle, DistancePair (radius, (*iter))));
+      BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle, TesselPointDistancePair (radius, (*iter))));
       if (!BoundaryTestPair.second) { // same point exists, check first r, then distance of original vectors to center of gravity
         DoLog(2) && (Log() << Verbose(2) << "Encountered two vectors whose projection onto axis " << axis << " is equal: " << endl);
 …
   // sum up the atomic masses
   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
       totalmass += (*iter)->getType()->mass;
+      totalmass += (*iter)->getType()->getMass();
+  }
   DoLog(0) && (Log() << Verbose(0) << "RESULT: The summed mass is " << setprecision(10) << totalmass << " atomicmassunit." << endl);
 …
   // Center filler at origin
   filler->CenterEdge(&Inserter);
-  filler->Center.Zero();
   const int FillerCount = filler->getAtomCount();
   DoLog(2) && (Log() << Verbose(2) << "INFO: Filler molecule has the following bonds:" << endl);

src/boundary.hpp

-              r8006ee
+              r994713
 #ifndef BOUNDARY_HPP_
 #define BOUNDARY_HPP_
-using namespace std;
 /*********************************************** includes ***********************************/
 …
 #include "defs.hpp"
+#include "BoundaryMaps.hpp"
 /****************************************** forward declarations *****************************/
-class atom;
 class BoundaryPointSet;
 class BoundaryLineSet;
 …
 class MoleculeListClass;
 class Tesselation;
+class TesselPoint;
 class Vector;
 …
 enum { SingleStepWidth=10 };
-typedef std::pair < double, class atom* > DistancePair;
-typedef std::multimap < double, class atom* > DistanceMap;
-typedef std::pair < DistanceMap::iterator, bool> DistanceTestPair;
-typedef std::map <double, DistancePair > Boundaries;
-typedef std::pair<double, DistancePair > BoundariesPair;
-typedef std::pair< Boundaries::iterator, bool> BoundariesTestPair;
 /********************************************** declarations *******************************/
 …
 void FindConvexBorder(const molecule* const mol, Boundaries *BoundaryPts, Tesselation *&TesselStruct, const LinkedCell *LCList, const char *filename);
 Vector* FindEmbeddingHole(MoleculeListClass *mols, molecule *srcmol);
-void FindNextSuitablePoint(class BoundaryTriangleSet *BaseTriangle, class BoundaryLineSet *BaseLine, atom*& OptCandidate, Vector *OptCandidateCenter, double *ShortestAngle, const double RADIUS, LinkedCell *LC);
 bool FindNonConvexBorder(const molecule* const mol, Tesselation *&TesselStruct, const LinkedCell *&LC, const double RADIUS, const char *tempbasename);
 Boundaries *GetBoundaryPoints(const molecule *mol, Tesselation *&TesselStruct);

src/builder.cpp

-              r8006ee
+              r994713
+/** \file builder.cpp
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
+ /** \file builder.cpp
+ *
  *  date: Jan 1, 2007
  *  author: heber
+ *
+ */
+/*! \page Copyright notice
+ *
+ *  MoleCuilder - to create and alter molecular systems
+ *  Copyright (C) 2010  University Bonn. All rights reserved.
+ *
  */
 …
+ *
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
   std::string BondGraphFileName("\n");
+  // print version check whether arguments are present at all
+  cout << ESPACKVersion << endl;
+  // print version check and copyright notice
+  cout << MOLECUILDERVERSION << endl;
+  cout << "MoleCuilder comes with ABSOLUTELY NO WARRANTY; for details type" << endl;
+  cout << "`molecuilder --help-warranty'." << endl;
+  cout << "`MoleCuilder - to create and alter molecular systems." << endl;
+  cout << "Copyright (C) 2010  University Bonn. All rights reserved." << endl;
   setVerbosity(0);
 …
       #else
         DoLog(0) && (Log() << Verbose(0) << "Setting UI to Text." << endl);
         cout << ESPACKVersion << endl;
+        cout << MOLECUILDERVERSION << endl;
         UIFactory::registerFactory(new TextUIFactory::description());
         UIFactory::makeUserInterface("Text");

src/config.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file config.cpp
+ *
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 #include <cstring>
+//#include "Actions/FragmentationAction/SubgraphDissectionAction.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
 …
       ParseForParameter(verbose,FileBuffer, name, 0, 2, 1, int_type, &Z, 1, critical);
       elementhash[i] = periode->FindElement(Z);
       DoLog(1) && (Log() << Verbose(1) << i << ". Z = " << elementhash[i]->Z << " with " << No[i] << " ions." << endl);
+      DoLog(1) && (Log() << Verbose(1) << i << ". Z = " << elementhash[i]->getAtomicNumber() << " with " << No[i] << " ions." << endl);
       NoAtoms += No[i];
+    }
 …
   // 4. dissect the molecule into connected subgraphs
   // don't do this here ...
   //MolList->DissectMoleculeIntoConnectedSubgraphs(mol,this);
+  //FragmentationSubgraphDissection();
   //delete(mol);
 …
     AtomNo = 0;
     for (molecule::const_iterator iter = (*MolRunner)->begin(); iter != (*MolRunner)->end(); ++iter) {
       sprintf(name, "%2s%2d",(*iter)->getType()->symbol, elementNo[(*iter)->getType()->Z]);
       elementNo[(*iter)->getType()->Z] = (elementNo[(*iter)->getType()->Z]+1) % 100;   // confine to two digits
+      sprintf(name, "%2s%2d",(*iter)->getType()->getSymbol().c_str(), elementNo[(*iter)->getType()->getAtomicNumber()]);
+      elementNo[(*iter)->getType()->getAtomicNumber()] = (elementNo[(*iter)->getType()->getAtomicNumber()]+1) % 100;   // confine to two digits
       fprintf(f,
              "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
 …
              (*iter)->at(1),                 /* position Y in Angstroem */
              (*iter)->at(2),                 /* position Z in Angstroem */
              (double)(*iter)->getType()->Valence,         /* occupancy */
              (double)(*iter)->getType()->NoValenceOrbitals,          /* temperature factor */
+             (double)(*iter)->getType()->getValence(),         /* occupancy */
+             (double)(*iter)->getType()->getNoValenceOrbitals(),          /* temperature factor */
              "0",            /* segment identifier */
              (*iter)->getType()->symbol,    /* element symbol */
+             (*iter)->getType()->getSymbol().c_str(),    /* element symbol */
              "0");           /* charge */
       AtomNo++;
 …
   AtomNo = 0;
   for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
     sprintf(name, "%2s%2d",(*iter)->getType()->symbol, elementNo[(*iter)->getType()->Z]);
     elementNo[(*iter)->getType()->Z] = (elementNo[(*iter)->getType()->Z]+1) % 100;   // confine to two digits
+    sprintf(name, "%2s%2d",(*iter)->getType()->getSymbol().c_str(), elementNo[(*iter)->getType()->getAtomicNumber()]);
+    elementNo[(*iter)->getType()->getAtomicNumber()] = (elementNo[(*iter)->getType()->getAtomicNumber()]+1) % 100;   // confine to two digits
     fprintf(f,
            "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
 …
            (*iter)->at(1),                 /* position Y in Angstroem */
            (*iter)->at(2),                 /* position Z in Angstroem */
            (double)(*iter)->getType()->Valence,         /* occupancy */
            (double)(*iter)->getType()->NoValenceOrbitals,          /* temperature factor */
+           (double)(*iter)->getType()->getValence(),         /* occupancy */
+           (double)(*iter)->getType()->getNoValenceOrbitals(),          /* temperature factor */
            "0",            /* segment identifier */
            (*iter)->getType()->symbol,    /* element symbol */
+           (*iter)->getType()->getSymbol().c_str(),    /* element symbol */
            "0");           /* charge */
     AtomNo++;
 …
     *output << 0 << "\t";
     *output << (*iter)->at(0) << "\t" << (*iter)->at(1) << "\t" << (*iter)->at(2) << "\t";
     *output << static_cast<double>((*iter)->getType()->Valence) << "\t";
     *output << (*iter)->getType()->symbol << "\t";
+    *output << static_cast<double>((*iter)->getType()->getValence()) << "\t";
+    *output << (*iter)->getType()->getSymbol() << "\t";
     for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
       *output << (*runner)->GetOtherAtom(*iter)->nr << "\t";
 …
         *output << MolCounter+1 << "\t";
         *output << (*iter)->at(0) << "\t" << (*iter)->at(1) << "\t" << (*iter)->at(2) << "\t";
         *output << (double)(*iter)->getType()->Valence << "\t";
         *output << (*iter)->getType()->symbol << "\t";
+        *output << (double)(*iter)->getType()->getValence() << "\t";
+        *output << (*iter)->getType()->getSymbol() << "\t";
         for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
           *output << LocalNotoGlobalNoMap[ (*runner)->GetOtherAtom((*iter))->getId() ] << "\t";
 …
     for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
       src[N++] = (*ListRunner)->IndexNr;
-      (*ListRunner)->Translate(&(*ListRunner)->Center);
+    }
     mol = World::getInstance().createMolecule();
     mol->SetNameFromFilename(ConfigFileName);
-    molecules->SimpleMultiMerge(mol, src, N);
     //mol->CalculateOrbitals(*this);
     delete[](src);

src/datacreator.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file datacreator.cpp
+ *
 …
 //============================ INCLUDES ===========================
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/defs.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * defs.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include "Helpers/MemDebug.hpp"
 #include "defs.hpp"

src/element.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file element.cpp
+ *
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 #include <fstream>
+#include "Helpers/Assert.hpp"
 #include "element.hpp"
 …
   VanDerWaalsRadius(0),
         Z(-1),
-        previous(NULL),
-        next(NULL),
-        sort(NULL),
         Valence(0),
         NoValenceOrbitals(0)
 …
 };
+element::element(const element &src) :
+  mass(src.mass),
+  CovalentRadius(src.CovalentRadius),
+  VanDerWaalsRadius(src.VanDerWaalsRadius),
+  Z(src.Z),
+  Valence(src.Valence),
+  NoValenceOrbitals(src.NoValenceOrbitals),
+  name(src.name),
+  symbol(src.symbol)
+{
+  period = src.period;
+  group = src.group;
+  block = src.block;
+}
 /** Destructor of class element.
  */
 element::~element() {};
+element &element::operator=(const element &src){
+  if(this!=&src){
+    mass=src.mass;
+    CovalentRadius=src.CovalentRadius;
+    VanDerWaalsRadius=src.VanDerWaalsRadius;
+    Z=src.Z;
+    Valence=src.Valence;
+    NoValenceOrbitals=src.NoValenceOrbitals;
+    name=src.name;
+    symbol=src.symbol;
+    period = src.period;
+    group = src.group;
+    block = src.block;
+  }
+  return *this;
+}
 /** Prints element data to \a *out.
 …
+}
+string element::getSymbol() const{
+  return string(symbol);
+double element::getMass() const
+{
+  return mass;
+}
+std::string element::getName() const{
+  return string(name);
+double element::getCovalentRadius() const
+{
+  return CovalentRadius;
+}
+double element::getVanDerWaalsRadius() const
+{
+  return VanDerWaalsRadius;
+}
+int element::getAtomicNumber() const
+{
+  return Z;
+}
+double element::getValence() const
+{
+  return Valence;
+}
+int element::getNoValenceOrbitals() const
+{
+  return NoValenceOrbitals;
+}
+double element::getHBondDistance(const int i) const
+{
+  ASSERT((i>=0) && (i<3), "Access to element::HBondDistance out of bounds.");
+  return HBondDistance[i];
+}
+double element::getHBondAngle(const int i) const
+{
+  ASSERT((i>=0) && (i<3), "Access to element::HBondAngle out of bounds.");
+  return HBondAngle[i];
+}
+string &element::getSymbol(){
+  return symbol;
+}
+const string &element::getSymbol() const{
+  return symbol;
+}
+void element::setSymbol(const std::string &temp)
+{
+  symbol = temp;
+}
+std::string &element::getName(){
+  return name;
+}
+const std::string &element::getName() const{
+  return name;
+}
+void element::setName(const std::string &temp)
+{
+  name = temp;
+}

src/element.hpp

-              r8006ee
+              r994713
 #include "types.hpp"
+class periodentafel;
 /********************************************** declarations *******************************/
 …
  */
 class element {
+  friend class periodentafel;
   public:
+    element();
+    element(const element&);
+    ~element();
+    element &operator=(const element&);
+    // accessor functions
+    atomicNumber_t getNumber() const;
+    double getMass() const;
+    double getCovalentRadius() const;
+    double getVanDerWaalsRadius() const;
+    int getAtomicNumber() const;
+    double getValence() const;
+    int getNoValenceOrbitals() const;
+    double getHBondDistance(const int i) const;
+    double getHBondAngle(const int i) const;
+    std::string &getSymbol();
+    const std::string &getSymbol() const;
+    void setSymbol(const std::string &temp);
+    std::string &getName();
+    const std::string &getName() const;
+    void setName(const std::string &temp);
+    //> print element entries to screen
+    bool Output(std::ostream * const out) const;
+    bool Checkout(std::ostream * const out, const int No, const int NoOfAtoms) const;
+  private:
     double mass;    //!< mass in g/mol
     double CovalentRadius;  //!< covalent radius
     double VanDerWaalsRadius;  //!< can-der-Waals radius
     int Z;          //!< atomic number
+    char name[64];  //!< atom name, i.e. "Hydrogren"
+    char symbol[3]; //!< short form of the atom, i.e. "H"
+    char period[8];    //!< period: n quantum number
+    char group[8];    //!< group: l quantum number
+    char block[8];    //!< block: l quantum number
+    element *previous;  //!< previous item in list
+    element *next;  //!< next element in list
+    int *sort;      //!< sorc criteria
+    std::string period;    //!< period: n quantum number
+    std::string group;    //!< group: l quantum number
+    std::string block;    //!< block: l quantum number
     double Valence;   //!< number of valence electrons for this element
     int NoValenceOrbitals;  //!< number of valence orbitals, used for determining bond degree in molecule::CreateConnectmatrix()
 …
     double HBondAngle[NDIM];     //!< typical angle for one, two, three bonded hydrogen (in degrees)
+  element();
+  ~element();
+  // accessor functions
+  atomicNumber_t getNumber() const;
+  std::string getSymbol() const;
+  std::string getName() const;
+  //> print element entries to screen
+  bool Output(std::ostream * const out) const;
+  bool Checkout(std::ostream * const out, const int No, const int NoOfAtoms) const;
+  private:
+    std::string name;  //!< atom name, i.e. "Hydrogen"
+    std::string symbol; //!< short form of the atom, i.e. "H"
 };

src/elements_db.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * elements_db.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/ellipsoid.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ellipsoid.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/graph.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file graph.cpp
+ *
 …
+ *
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/joiner.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file joiner.cpp
+ *
 …
 //============================ INCLUDES ===========================
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/leastsquaremin.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * leastsquaremin.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/linkedcell.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file linkedcell.cpp
+ *
 …
+ *
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 LinkedCell::LinkedCell() :
   LC(NULL),
   index(-1),
   RADIUS(0.)
+  RADIUS(0.),
+  index(-1)
+{
   for(int i=0;i<NDIM;i++)
 …
  */
 LinkedCell::LinkedCell(const PointCloud * const set, const double radius) :
+  LC(NULL),
   RADIUS(radius),
-  LC(NULL),
   index(-1)
+{
 …
  */
 LinkedCell::LinkedCell(LinkedNodes *set, const double radius) :
+  LC(NULL),
   RADIUS(radius),
-  LC(NULL),
   index(-1)
+{

src/molecule.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file molecules.cpp
+ *
 …
  */
+// include config.h
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 …
+}
+bool molecule::changeId(moleculeId_t newId){
+  // first we move ourselves in the world
+  // the world lets us know if that succeeded
+  if(World::getInstance().changeMoleculeId(id,newId,this)){
+    id = newId;
+    return true;
+  }
+  else{
+    return false;
+  }
+}
 moleculeId_t molecule::getId(){
   return id;
 …
     pointer->sort = &pointer->nr;
     if (pointer->getType() != NULL) {
+      formula += pointer->getType();
+      if (pointer->getType()->Z != 1)
+      if (pointer->getType()->getAtomicNumber() != 1)
         NoNonHydrogen++;
       if(pointer->getName() == "Unknown"){
         stringstream sstr;
         sstr << pointer->getType()->symbol << pointer->nr+1;
+        sstr << pointer->getType()->getSymbol() << pointer->nr+1;
         pointer->setName(sstr.str());
+      }
 …
   if (pointer != NULL) {
     atom *walker = pointer->clone();
-    formula += walker->getType();
     walker->setName(pointer->getName());
     walker->nr = last_atom++;  // increase number within molecule
     insert(walker);
     if ((pointer->getType() != NULL) && (pointer->getType()->Z != 1))
+    if ((pointer->getType() != NULL) && (pointer->getType()->getAtomicNumber() != 1))
       NoNonHydrogen++;
     retval=walker;
 …
   // get typical bond length and store as scale factor for later
   ASSERT(TopOrigin->getType() != NULL, "AddHydrogenReplacementAtom: element of TopOrigin is not given.");
   BondRescale = TopOrigin->getType()->HBondDistance[TopBond->BondDegree-1];
+  BondRescale = TopOrigin->getType()->getHBondDistance(TopBond->BondDegree-1);
   if (BondRescale == -1) {
     DoeLog(1) && (eLog()<< Verbose(1) << "There is no typical hydrogen bond distance in replacing bond (" << TopOrigin->getName() << "<->" << TopReplacement->getName() << ") of degree " << TopBond->BondDegree << "!" << endl);
 …
       FirstOtherAtom->AtomicVelocity = TopReplacement->AtomicVelocity; // copy velocity
       FirstOtherAtom->FixedIon = TopReplacement->FixedIon;
       if (TopReplacement->getType()->Z == 1) { // neither rescale nor replace if it's already hydrogen
+      if (TopReplacement->getType()->getAtomicNumber() == 1) { // neither rescale nor replace if it's already hydrogen
         FirstOtherAtom->father = TopReplacement;
         BondRescale = bondlength;
 …
       FirstOtherAtom->father = NULL;  // we are just an added hydrogen with no father
       SecondOtherAtom->father = NULL;  //  we are just an added hydrogen with no father
       bondangle = TopOrigin->getType()->HBondAngle[1];
+      bondangle = TopOrigin->getType()->getHBondAngle(1);
       if (bondangle == -1) {
         DoeLog(1) && (eLog()<< Verbose(1) << "There is no typical hydrogen bond angle in replacing bond (" << TopOrigin->getName() << "<->" << TopReplacement->getName() << ") of degree " << TopBond->BondDegree << "!" << endl);
 …
       // create correct coordination for the three atoms
       alpha = (TopOrigin->getType()->HBondAngle[2])/180.*M_PI/2.;  // retrieve triple bond angle from database
+      alpha = (TopOrigin->getType()->getHBondAngle(2))/180.*M_PI/2.;  // retrieve triple bond angle from database
       l = BondRescale;        // desired bond length
       b = 2.*l*sin(alpha);    // base length of isosceles triangle
 …
   atom1->RegisterBond(Binder);
   atom2->RegisterBond(Binder);
   if ((atom1->getType() != NULL) && (atom1->getType()->Z != 1) && (atom2->getType() != NULL) && (atom2->getType()->Z != 1))
+  if ((atom1->getType() != NULL) && (atom1->getType()->getAtomicNumber() != 1) && (atom2->getType() != NULL) && (atom2->getType()->getAtomicNumber() != 1))
     NoNonBonds++;
 …
 };
 /** Removes atom from molecule list and deletes it.
+/** Removes atom from molecule list and removes all of its bonds.
  * \param *pointer atom to be removed
  * \return true - succeeded, false - atom not found in list
 …
   ASSERT(pointer, "Null pointer passed to molecule::RemoveAtom().");
   OBSERVE;
-  formula-=pointer->getType();
   RemoveBonds(pointer);
   erase(pointer);
 …
   if (pointer == NULL)
     return false;
-  formula-=pointer->getType();
   erase(pointer);
   return true;
 …
+{
   for (molecule::iterator iter = begin(); !empty(); iter = begin())
       erase(iter);
+    erase(*iter);
   return empty();
 };
 …
         ElementNo[i] = 0;
+      }
+      SetIndexedArrayForEachAtomTo ( ElementNo, &element::Z, &AbsoluteValue, 1);
+      for(molecule::iterator iter = begin(); iter != end(); ++iter) {
+        ElementNo[(*iter)->getType()->getAtomicNumber()] = 1;
+      }
       int current=1;
       for (int i=0;i<MAX_ELEMENTS;++i) {
 …
   for (molecule::const_iterator iter = atoms.begin(); iter != atoms.end(); ++iter) {
     (*iter)->nr = i;   // update number in molecule (for easier referencing in FragmentMolecule lateron)
     if ((*iter)->getType()->Z != 1) // count non-hydrogen atoms whilst at it
+    if ((*iter)->getType()->getAtomicNumber() != 1) // count non-hydrogen atoms whilst at it
       NoNonHydrogen++;
     stringstream sstr;
     sstr << (*iter)->getType()->symbol << (*iter)->nr+1;
+    sstr << (*iter)->getType()->getSymbol() << (*iter)->nr+1;
     (*iter)->setName(sstr.str());
     DoLog(3) && (Log() << Verbose(3) << "Naming atom nr. " << (*iter)->nr << " " << (*iter)->getName() << "." << endl);
 …
+  }
   return res;
-};
-/** Determines whether two molecules actually contain the same atoms and coordination.
- * \param *out output stream for debugging
- * \param *OtherMolecule the molecule to compare this one to
- * \param threshold upper limit of difference when comparing the coordination.
- * \return NULL - not equal, otherwise an allocated (molecule::AtomCount) permutation map of the atom numbers (which corresponds to which)
- */
-int * molecule::IsEqualToWithinThreshold(molecule *OtherMolecule, double threshold)
+{
-  int flag;
-  double *Distances = NULL, *OtherDistances = NULL;
-  Vector CenterOfGravity, OtherCenterOfGravity;
-  size_t *PermMap = NULL, *OtherPermMap = NULL;
-  int *PermutationMap = NULL;
-  bool result = true; // status of comparison
-  DoLog(3) && (Log() << Verbose(3) << "Begin of IsEqualToWithinThreshold." << endl);
-  /// first count both their atoms and elements and update lists thereby ...
-  //Log() << Verbose(0) << "Counting atoms, updating list" << endl;
-  /// ... and compare:
-  /// -# AtomCount
-  if (result) {
-    if (getAtomCount() != OtherMolecule->getAtomCount()) {
-      DoLog(4) && (Log() << Verbose(4) << "AtomCounts don't match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl);
-      result = false;
-    } else Log() << Verbose(4) << "AtomCounts match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl;
+  }
-  /// -# Formula
-  if (result) {
-    if (formula != OtherMolecule->formula) {
-      DoLog(4) && (Log() << Verbose(4) << "Formulas don't match: " << formula << " == " << OtherMolecule->formula << endl);
-      result = false;
-    } else Log() << Verbose(4) << "Formulas match: " << formula << " == " << OtherMolecule->formula << endl;
+  }
-  /// then determine and compare center of gravity for each molecule ...
-  if (result) {
-    DoLog(5) && (Log() << Verbose(5) << "Calculating Centers of Gravity" << endl);
-    DeterminePeriodicCenter(CenterOfGravity);
-    OtherMolecule->DeterminePeriodicCenter(OtherCenterOfGravity);
-    DoLog(5) && (Log() << Verbose(5) << "Center of Gravity: " << CenterOfGravity << endl);
-    DoLog(5) && (Log() << Verbose(5) << "Other Center of Gravity: " << OtherCenterOfGravity << endl);
-    if (CenterOfGravity.DistanceSquared(OtherCenterOfGravity) > threshold*threshold) {
-      DoLog(4) && (Log() << Verbose(4) << "Centers of gravity don't match." << endl);
-      result = false;
+    }
+  }
-  /// ... then make a list with the euclidian distance to this center for each atom of both molecules
-  if (result) {
-    DoLog(5) && (Log() << Verbose(5) << "Calculating distances" << endl);
-    Distances = new double[getAtomCount()];
-    OtherDistances = new double[getAtomCount()];
-    SetIndexedArrayForEachAtomTo ( Distances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
-    SetIndexedArrayForEachAtomTo ( OtherDistances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
-    for(int i=0;i<getAtomCount();i++) {
-      Distances[i] = 0.;
-      OtherDistances[i] = 0.;
+    }
-    /// ... sort each list (using heapsort (o(N log N)) from GSL)
-    DoLog(5) && (Log() << Verbose(5) << "Sorting distances" << endl);
-    PermMap = new size_t[getAtomCount()];
-    OtherPermMap = new size_t[getAtomCount()];
-    for(int i=0;i<getAtomCount();i++) {
-      PermMap[i] = 0;
-      OtherPermMap[i] = 0;
+    }
-    gsl_heapsort_index (PermMap, Distances, getAtomCount(), sizeof(double), CompareDoubles);
-    gsl_heapsort_index (OtherPermMap, OtherDistances, getAtomCount(), sizeof(double), CompareDoubles);
-    PermutationMap = new int[getAtomCount()];
-    for(int i=0;i<getAtomCount();i++)
-      PermutationMap[i] = 0;
-    DoLog(5) && (Log() << Verbose(5) << "Combining Permutation Maps" << endl);
-    for(int i=getAtomCount();i--;)
-      PermutationMap[PermMap[i]] = (int) OtherPermMap[i];
-    /// ... and compare them step by step, whether the difference is individually(!) below \a threshold for all
-    DoLog(4) && (Log() << Verbose(4) << "Comparing distances" << endl);
-    flag = 0;
-    for (int i=0;i<getAtomCount();i++) {
-      DoLog(5) && (Log() << Verbose(5) << "Distances squared: |" << Distances[PermMap[i]] << " - " << OtherDistances[OtherPermMap[i]] << "| = " << fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) << " ?<? " <<  threshold << endl);
-      if (fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) > threshold*threshold)
-        flag = 1;
+    }
-    // free memory
-    delete[](PermMap);
-    delete[](OtherPermMap);
-    delete[](Distances);
-    delete[](OtherDistances);
-    if (flag) { // if not equal
-      delete[](PermutationMap);
-      result = false;
+    }
+  }
-  /// return pointer to map if all distances were below \a threshold
-  DoLog(3) && (Log() << Verbose(3) << "End of IsEqualToWithinThreshold." << endl);
-  if (result) {
-    DoLog(3) && (Log() << Verbose(3) << "Result: Equal." << endl);
-    return PermutationMap;
-  } else {
-    DoLog(3) && (Log() << Verbose(3) << "Result: Not equal." << endl);
-    return NULL;
+  }
 };

src/molecule.hpp

-              r8006ee
+              r994713
     double BondDistance;  //!< typical bond distance used in CreateAdjacencyList() and furtheron
     bool ActiveFlag;    //!< in a MoleculeListClass used to discern active from inactive molecules
     Vector Center;      //!< Center of molecule in a global box
+    //Vector Center;      //!< Center of molecule in a global box
     int IndexNr;        //!< index of molecule in a MoleculeListClass
     char name[MAXSTRINGSIZE];         //!< arbitrary name
 …
   bool hasElement(const std::string&) const;
+  virtual bool changeId(atomId_t newId);
   iterator begin();
 …
   // Recognize doubly appearing molecules in a list of them
-  int * IsEqualToWithinThreshold(molecule *OtherMolecule, double threshold);
   int * GetFatherSonAtomicMap(molecule *OtherMolecule);
 …
   void Enumerate(ostream *out);
   void Output(ofstream *out);
-  void DissectMoleculeIntoConnectedSubgraphs(const periodentafel * const periode, config * const configuration);
   int CountAllAtoms() const;
 …
   void parseXYZIntoMolecule();
   void eraseMolecule();
-  // merging of molecules
-  bool SimpleMerge(molecule *mol, molecule *srcmol);
-  bool SimpleAdd(molecule *mol, molecule *srcmol);
-  bool SimpleMultiMerge(molecule *mol, int *src, int N);
-  bool SimpleMultiAdd(molecule *mol, int *src, int N);
-  bool ScatterMerge(molecule *mol, int *src, int N);
-  bool EmbedMerge(molecule *mol, molecule *srcmol);
   private:

src/molecule_dynamics.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * molecule_dynamics.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/molecule_fragmentation.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * molecule_fragmentation.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
       for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     #ifdef ADDHYDROGEN
         if ((*iter)->getType()->Z != 1) // skip hydrogen
+        if ((*iter)->getType()->getAtomicNumber() != 1) // skip hydrogen
     #endif
+        {
 …
     for(molecule::const_iterator iter = begin(); iter != end(); ++iter) {
   #ifdef ADDHYDROGEN
       if ((*iter)->getType()->Z != 1) // skip hydrogen
+      if ((*iter)->getType()->getAtomicNumber() != 1) // skip hydrogen
   #endif
+      {
 …
   for (KeySet::iterator runner = Leaf->begin(); runner != Leaf->end(); runner++) {
     Runner = FindAtom((*runner));
     if (Runner->getType()->Z != 1) { // skip all those added hydrogens when re-filling snake stack
+    if (Runner->getType()->getAtomicNumber() != 1) { // skip all those added hydrogens when re-filling snake stack
       if (ShortestPathList[(*runner)] > SP) {  // remove the oldest one with longest shortest path
         SP = ShortestPathList[(*runner)];
 …
     ++iter;
 #ifdef ADDHYDROGEN
     while ((iter != Leaf->end()) && ((*iter)->getType()->Z == 1)){ // skip added hydrogen
+    while ((iter != Leaf->end()) && ((*iter)->getType()->getAtomicNumber() == 1)){ // skip added hydrogen
       iter++;
+    }
 …
         if ((RestrictedKeySet.find(OtherWalker->nr) != RestrictedKeySet.end())
   #ifdef ADDHYDROGEN
          && (OtherWalker->getType()->Z != 1)
+         && (OtherWalker->getType()->getAtomicNumber() != 1)
   #endif
                                                               ) {  // skip hydrogens and restrict to fragment

src/molecule_geometry.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * molecule_geometry.cpp
 …
  */
+// include config.h
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
+#include "Helpers/MemDebug.hpp"
 #include "Helpers/helpers.hpp"
 #include "Helpers/Log.hpp"
-#include "Helpers/MemDebug.hpp"
 #include "Helpers/Verbose.hpp"
 #include "LinearAlgebra/Line.hpp"
 …
     (*max) += (*min);
     Translate(min);
-    Center.Zero();
+  }
   delete(min);
 …
   int Num = 0;
   molecule::const_iterator iter = begin();  // start at first in list
+  Vector Center;
   Center.Zero();
   if (iter != end()) {   //list not empty?
     for (; iter != end(); ++iter) {  // continue with second if present
 …
     Center.Scale(-1./(double)Num); // divide through total number (and sign for direction)
     Translate(&Center);
-    Center.Zero();
+  }
 };
 …
   if (iter != end()) {   //list not empty?
     for (; iter != end(); ++iter) {  // continue with second if present
       Num += (*iter)->getType()->mass;
       tmp = (*iter)->getType()->mass * (*iter)->getPosition();
+      Num += (*iter)->getType()->getMass();
+      tmp = (*iter)->getType()->getMass() * (*iter)->getPosition();
       (*a) += tmp;
+    }
 …
 void molecule::CenterPeriodic()
+{
+  DeterminePeriodicCenter(Center);
+  Vector NewCenter;
+  DeterminePeriodicCenter(NewCenter);
+  // go through all atoms
+  BOOST_FOREACH(atom* iter, atoms){
+    *iter -= NewCenter;
+  }
 };
 …
 void molecule::CenterAtVector(Vector *newcenter)
+{
+  Center = *newcenter;
+  // go through all atoms
+  BOOST_FOREACH(atom* iter, atoms){
+    *iter -= *newcenter;
+  }
 };
 …
   bool flag;
   Vector Testvector, Translationvector;
+  Vector Center;
   do {
 …
     for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
 #ifdef ADDHYDROGEN
       if ((*iter)->getType()->Z != 1) {
+      if ((*iter)->getType()->getAtomicNumber() != 1) {
 #endif
         Testvector = inversematrix * (*iter)->getPosition();
 …
         // now also change all hydrogens
         for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
           if ((*Runner)->GetOtherAtom((*iter))->getType()->Z == 1) {
+          if ((*Runner)->GetOtherAtom((*iter))->getType()->getAtomicNumber() == 1) {
             Testvector = inversematrix * (*Runner)->GetOtherAtom((*iter))->getPosition();
             Testvector += Translationvector;
 …
   Center.Scale(1./static_cast<double>(getAtomCount()));
+  CenterAtVector(&Center);
 };

src/molecule_graph.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * molecule_graph.cpp
 …
  */
+// include config.h
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 …
         OtherAtom = (*Runner)->GetOtherAtom(Walker);
 #ifdef ADDHYDROGEN
         if (OtherAtom->getType()->Z != 1) {
+        if (OtherAtom->getType()->getAtomicNumber() != 1) {
 #endif
         DoLog(2) && (Log() << Verbose(2) << "Current OtherAtom is: " << OtherAtom->getName() << " for bond " << *(*Runner) << "." << endl);

src/molecule_pointcloud.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * molecule_pointcloud.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/moleculelist.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file MoleculeListClass.cpp
+ *
 …
  */
+// include config.h
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 …
 MoleculeListClass::MoleculeListClass(World *_world) :
   Observable("MoleculeListClass"),
   world(_world),
   MaxIndex(1)
+  MaxIndex(1),
+  world(_world)
 {};
 …
+      }
       // Center and size
+      (*out) << "\t" << (*ListRunner)->Center << "\t" << sqrt(size) << endl;
+      Vector *Center = (*ListRunner)->DetermineCenterOfAll();
+      (*out) << "\t" << *Center << "\t" << sqrt(size) << endl;
+      delete(Center);
+    }
+  }
 …
 };
-/** Simple merge of two molecules into one.
- * \param *mol destination molecule
- * \param *srcmol source molecule
- * \return true - merge successful, false - merge failed (probably due to non-existant indices
- */
-bool MoleculeListClass::SimpleMerge(molecule *mol, molecule *srcmol)
+{
-  if (srcmol == NULL)
-    return false;
-  // put all molecules of src into mol
-  for (molecule::iterator iter = srcmol->begin(); !srcmol->empty(); iter=srcmol->begin()) {
-    atom * const Walker = *iter;
-    srcmol->UnlinkAtom(Walker);
-    mol->AddAtom(Walker);
+  }
-  // remove src
-  ListOfMolecules.remove(srcmol);
-  World::getInstance().destroyMolecule(srcmol);
-  return true;
-};
-/** Simple add of one molecules into another.
- * \param *mol destination molecule
- * \param *srcmol source molecule
- * \return true - merge successful, false - merge failed (probably due to non-existant indices
- */
-bool MoleculeListClass::SimpleAdd(molecule *mol, molecule *srcmol)
+{
-  if (srcmol == NULL)
-    return false;
-  // put all molecules of src into mol
-  atom *Walker = NULL;
-  for (molecule::iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
-    Walker = mol->AddCopyAtom((*iter));
-    Walker->father = Walker;
+  }
-  return true;
-};
-/** Simple merge of a given set of molecules into one.
- * \param *mol destination molecule
- * \param *src index of set of source molecule
- * \param N number of source molecules
- * \return true - merge successful, false - some merges failed (probably due to non-existant indices)
- */
-bool MoleculeListClass::SimpleMultiMerge(molecule *mol, int *src, int N)
+{
-  bool status = true;
-  // check presence of all source molecules
-  for (int i=0;i<N;i++) {
-    molecule *srcmol = ReturnIndex(src[i]);
-    status = status && SimpleMerge(mol, srcmol);
+  }
-  insert(mol);
-  return status;
-};
-/** Simple add of a given set of molecules into one.
- * \param *mol destination molecule
- * \param *src index of set of source molecule
- * \param N number of source molecules
- * \return true - merge successful, false - some merges failed (probably due to non-existant indices)
- */
-bool MoleculeListClass::SimpleMultiAdd(molecule *mol, int *src, int N)
+{
-  bool status = true;
-  // check presence of all source molecules
-  for (int i=0;i<N;i++) {
-    molecule *srcmol = ReturnIndex(src[i]);
-    status = status && SimpleAdd(mol, srcmol);
+  }
-  return status;
-};
-/** Scatter merge of a given set of molecules into one.
- * Scatter merge distributes the molecules in such a manner that they don't overlap.
- * \param *mol destination molecule
- * \param *src index of set of source molecule
- * \param N number of source molecules
- * \return true - merge successful, false - merge failed (probably due to non-existant indices
- * \TODO find scatter center for each src molecule
- */
-bool MoleculeListClass::ScatterMerge(molecule *mol, int *src, int N)
+{
-  // check presence of all source molecules
-  for (int i=0;i<N;i++) {
-    // get pointer to src molecule
-    molecule *srcmol = ReturnIndex(src[i]);
-    if (srcmol == NULL)
-      return false;
+  }
-  // adapt each Center
-  for (int i=0;i<N;i++) {
-    // get pointer to src molecule
-    molecule *srcmol = ReturnIndex(src[i]);
-    //srcmol->Center.Zero();
-    srcmol->Translate(&srcmol->Center);
+  }
-  // perform a simple multi merge
-  SimpleMultiMerge(mol, src, N);
-  return true;
-};
-/** Embedding merge of a given set of molecules into one.
- * Embedding merge inserts one molecule into the other.
- * \param *mol destination molecule (fixed one)
- * \param *srcmol source molecule (variable one, where atoms are taken from)
- * \return true - merge successful, false - merge failed (probably due to non-existant indices)
- * \TODO linked cell dimensions for boundary points has to be as big as inner diameter!
- */
-bool MoleculeListClass::EmbedMerge(molecule *mol, molecule *srcmol)
+{
-  LinkedCell *LCList = NULL;
-  Tesselation *TesselStruct = NULL;
-  if ((srcmol == NULL) || (mol == NULL)) {
-    DoeLog(1) && (eLog()<< Verbose(1) << "Either fixed or variable molecule is given as NULL." << endl);
-    return false;
+  }
-  // calculate envelope for *mol
-  LCList = new LinkedCell(mol, 8.);
-  FindNonConvexBorder(mol, TesselStruct, (const LinkedCell *&)LCList, 4., NULL);
-  if (TesselStruct == NULL) {
-    DoeLog(1) && (eLog()<< Verbose(1) << "Could not tesselate the fixed molecule." << endl);
-    return false;
+  }
-  delete(LCList);
-  LCList = new LinkedCell(TesselStruct, 8.);  // re-create with boundary points only!
-  // prepare index list for bonds
-  atom ** CopyAtoms = new atom*[srcmol->getAtomCount()];
-  for(int i=0;i<srcmol->getAtomCount();i++)
-    CopyAtoms[i] = NULL;
-  // for each of the source atoms check whether we are in- or outside and add copy atom
-  int nr=0;
-  for (molecule::const_iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
-    DoLog(2) && (Log() << Verbose(2) << "INFO: Current Walker is " << **iter << "." << endl);
-    if (!TesselStruct->IsInnerPoint((*iter)->getPosition(), LCList)) {
-      CopyAtoms[(*iter)->nr] = (*iter)->clone();
-      mol->AddAtom(CopyAtoms[(*iter)->nr]);
-      nr++;
-    } else {
-      // do nothing
+    }
+  }
-  DoLog(1) && (Log() << Verbose(1) << nr << " of " << srcmol->getAtomCount() << " atoms have been merged.");
-  // go through all bonds and add as well
-  for(molecule::iterator AtomRunner = srcmol->begin(); AtomRunner != srcmol->end(); ++AtomRunner)
-    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
-      if ((*BondRunner)->leftatom == *AtomRunner) {
-        DoLog(3) && (Log() << Verbose(3) << "Adding Bond between " << *CopyAtoms[(*BondRunner)->leftatom->nr] << " and " << *CopyAtoms[(*BondRunner)->rightatom->nr]<< "." << endl);
-        mol->AddBond(CopyAtoms[(*BondRunner)->leftatom->nr], CopyAtoms[(*BondRunner)->rightatom->nr], (*BondRunner)->BondDegree);
+      }
-  delete(LCList);
-  return true;
-};
 /** Simple output of the pointers in ListOfMolecules.
 …
     for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
       //Log() << Verbose(1) << "(*iter): " << *(*iter) << " with first bond " << *((*iter)->ListOfBonds.begin()) << "." << endl;
       if (((*iter)->getType()->Z == 1) && (((*iter)->father == NULL)
           || ((*iter)->father->getType()->Z != 1))) { // if it's a hydrogen
+      if (((*iter)->getType()->getAtomicNumber() == 1) && (((*iter)->father == NULL)
+          || ((*iter)->father->getType()->getAtomicNumber() != 1))) { // if it's a hydrogen
         for (molecule::const_iterator runner = (*ListRunner)->begin(); runner != (*ListRunner)->end(); ++runner) {
           //Log() << Verbose(2) << "Runner: " << *(*runner) << " with first bond " << *((*iter)->ListOfBonds.begin()) << "." << endl;
           // 3. take every other hydrogen that is the not the first and not bound to same bonding partner
           Binder = *((*runner)->ListOfBonds.begin());
           if (((*runner)->getType()->Z == 1) && ((*runner)->nr > (*iter)->nr) && (Binder->GetOtherAtom((*runner)) != Binder->GetOtherAtom((*iter)))) { // (hydrogens have only one bonding partner!)
+          if (((*runner)->getType()->getAtomicNumber() == 1) && ((*runner)->nr > (*iter)->nr) && (Binder->GetOtherAtom((*runner)) != Binder->GetOtherAtom((*iter)))) { // (hydrogens have only one bonding partner!)
             // 4. evaluate the morse potential for each matrix component and add up
             distance = (*runner)->distance(*(*iter));
 …
 };
-/** Dissects given \a *mol into connected subgraphs and inserts them as new molecules but with old atoms into \a this.
- * \param *out output stream for debugging
- * \param *periode periodentafel
- * \param *configuration config with BondGraph
- */
-void MoleculeListClass::DissectMoleculeIntoConnectedSubgraphs(const periodentafel * const periode, config * const configuration)
+{
-  // 0a. remove all present molecules
-  vector<molecule *> allmolecules = World::getInstance().getAllMolecules();
-  for (vector<molecule *>::iterator MolRunner = allmolecules.begin(); MolRunner != allmolecules.end(); ++MolRunner) {
-    erase(*MolRunner);
-    World::getInstance().destroyMolecule(*MolRunner);
+  }
-  // 0b. remove all bonds and construct a molecule with all atoms
-  molecule *mol = World::getInstance().createMolecule();
-  vector <atom *> allatoms = World::getInstance().getAllAtoms();
-  for(vector<atom *>::iterator AtomRunner = allatoms.begin(); AtomRunner != allatoms.end(); ++AtomRunner) {
-    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); !(*AtomRunner)->ListOfBonds.empty(); BondRunner = (*AtomRunner)->ListOfBonds.begin())
-      delete(*BondRunner);
-    mol->AddAtom(*AtomRunner);
+  }
-  // 1. dissect the molecule into connected subgraphs
-  if (configuration->BG != NULL) {
-    if (!configuration->BG->ConstructBondGraph(mol)) {
-      World::getInstance().destroyMolecule(mol);
-      DoeLog(1) && (eLog()<< Verbose(1) << "There are no bonds." << endl);
-      return;
+    }
-  } else {
-    DoeLog(1) && (eLog()<< Verbose(1) << "There is no BondGraph class present to create bonds." << endl);
-    return;
+  }
-  // 2. scan for connected subgraphs
-  MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
-  class StackClass<bond *> *BackEdgeStack = NULL;
-  Subgraphs = mol->DepthFirstSearchAnalysis(BackEdgeStack);
-  delete(BackEdgeStack);
-  if ((Subgraphs == NULL) || (Subgraphs->next == NULL)) {
-    World::getInstance().destroyMolecule(mol);
-    DoeLog(1) && (eLog()<< Verbose(1) << "There are no atoms." << endl);
-    return;
+  }
-  // 3. dissect (the following construct is needed to have the atoms not in the order of the DFS, but in
-  // the original one as parsed in)
-  // TODO: Optimize this, when molecules just contain pointer list of global atoms!
-  // 4a. create array of molecules to fill
-  const int MolCount = Subgraphs->next->Count();
-  char number[MAXSTRINGSIZE];
-  molecule **molecules = new molecule *[MolCount];
-  MoleculeLeafClass *MolecularWalker = Subgraphs;
-  for (int i=0;i<MolCount;i++) {
-    MolecularWalker = MolecularWalker->next;
-    molecules[i] = World::getInstance().createMolecule();
-    molecules[i]->ActiveFlag = true;
-    strncpy(molecules[i]->name, mol->name, MAXSTRINGSIZE);
-    if (MolCount > 1) {
-      sprintf(number, "-%d", i+1);
-      strncat(molecules[i]->name, number, MAXSTRINGSIZE - strlen(mol->name) - 1);
+    }
-    DoLog(1) && (Log() << Verbose(1) << "MolName is " << molecules[i]->name << ", id is " << molecules[i]->getId() << endl);
-    for (molecule::iterator iter = MolecularWalker->Leaf->begin(); iter != MolecularWalker->Leaf->end(); ++iter) {
-      DoLog(1) && (Log() << Verbose(1) << **iter << endl);
+    }
-    insert(molecules[i]);
+  }
-  // 4b. create and fill map of which atom is associated to which connected molecule (note, counting starts at 1)
-  int FragmentCounter = 0;
-  map<int, atom *> AtomToFragmentMap;
-  MolecularWalker = Subgraphs;
-  while (MolecularWalker->next != NULL) {
-    MolecularWalker = MolecularWalker->next;
-    for (molecule::iterator iter = MolecularWalker->Leaf->begin(); !MolecularWalker->Leaf->empty(); iter = MolecularWalker->Leaf->begin()) {
-      atom * Walker = *iter;
-      DoLog(1) && (Log() << Verbose(1) << "Re-linking " << Walker << "..." << endl);
-      MolecularWalker->Leaf->erase(iter);
-      molecules[FragmentCounter]->AddAtom(Walker);    // counting starts at 1
+    }
-    FragmentCounter++;
+  }
-  World::getInstance().destroyMolecule(mol);
-  // 4d. we don't need to redo bonds, as they are connected subgraphs and still maintain their ListOfBonds, but we have to remove them from first..last list
-  // TODO: check whether this is really not needed anymore
-  // 4e. free Leafs
-  MolecularWalker = Subgraphs;
-  while (MolecularWalker->next != NULL) {
-    MolecularWalker = MolecularWalker->next;
-    delete(MolecularWalker->previous);
+  }
-  delete(MolecularWalker);
-  delete[](molecules);
-  DoLog(1) && (Log() << Verbose(1) << "I scanned " << FragmentCounter << " molecules." << endl);
-};
 /** Count all atoms in each molecule.
  * \return number of atoms in the MoleculeListClass.
 …
         if (AtomMask[Father->nr]) // apply mask
 #ifdef ADDHYDROGEN
           if ((*iter)->getType()->Z != 1) // skip hydrogen
+          if ((*iter)->getType()->getAtomicNumber() != 1) // skip hydrogen
 #endif
           RootStack[FragmentCounter].push_front((*iter)->nr);

src/parser.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file parsing.cpp
+ *
 …
 // ======================================= INCLUDES ==========================================
-#include "Helpers/MemDebug.hpp"
-#include <cstring>
-#include "Helpers/helpers.hpp"
-#include "parser.hpp"
-#include "Helpers/Verbose.hpp"
 // include config.h
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
+#include "Helpers/MemDebug.hpp"
+#include <cstring>
+#include "Helpers/helpers.hpp"
+#include "parser.hpp"
+#include "Helpers/Verbose.hpp"
 // ======================================= FUNCTIONS ==========================================

src/periodentafel.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /** \file periodentafel.cpp
+ *
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
-using namespace std;
 #include <iomanip>
 …
+  {
     stringstream input(elementsDB,ios_base::in);
     bool status = LoadElementsDatabase(&input);
+    bool status = LoadElementsDatabase(input);
     ASSERT(status,  "General element initialization failed");
+  }
 …
  * \return iterator to added element
  */
 periodentafel::iterator periodentafel::AddElement(element * const pointer)
+periodentafel::iterator periodentafel::AddElement(element * pointer)
+{
   atomicNumber_t Z = pointer->getNumber();
   ASSERT(!elements.count(Z), "Element is already present.");
-  pointer->sort = &pointer->Z;
   if (pointer->getNumber() < 1 && pointer->getNumber() >= MAX_ELEMENTS)
     DoeLog(0) && (eLog() << Verbose(0) << "Invalid Z number!\n");
 …
  * \param *pointer element to be removed
  */
 size_t periodentafel::RemoveElement(element * const pointer)
+size_t periodentafel::RemoveElement(const element * pointer)
+{
   return RemoveElement(pointer->getNumber());
 …
  * \return pointer to element or NULL if not found
  */
 element * const periodentafel::FindElement(atomicNumber_t Z) const
+const element * periodentafel::FindElement(atomicNumber_t Z) const
+{
   const_iterator res = elements.find(Z);
 …
  * \return pointer to element
  */
 element * const periodentafel::FindElement(const string &shorthand) const
+const element * periodentafel::FindElement(const string &shorthand) const
+{
   element *res = 0;
 …
  * \return desired element or NULL
  */
 element * const periodentafel::AskElement() const
+{
   element * walker = NULL;
+const element * periodentafel::AskElement() const
+{
+  const element * walker = NULL;
   int Z;
   do {
 …
  * \return pointer to either present or newly created element
  */
 element * const periodentafel::EnterElement()
+const element * periodentafel::EnterElement()
+{
   atomicNumber_t Z = 0;
   DoLog(0) && (Log() << Verbose(0) << "Atomic number: " << Z << endl);
   cin >> Z;
   element * const res = FindElement(Z);
+  const element *res = FindElement(Z);
   if (!res) {
     // TODO: make this using the constructor
 …
     cin >> tmp->mass;
     DoLog(0) && (Log() << Verbose(0) << "Name [max 64 chars]: " << endl);
     cin >> tmp->name;
+    cin >> tmp->getName();
     DoLog(0) && (Log() << Verbose(0) << "Short form [max 3 chars]: " << endl);
     cin >> tmp->symbol;
+    cin >> tmp->getSymbol();
     AddElement(tmp);
     return tmp;
 …
 /******************** Access to iterators ****************************/
 periodentafel::const_iterator periodentafel::begin(){
+periodentafel::const_iterator periodentafel::begin() const{
   return elements.begin();
+}
 periodentafel::const_iterator periodentafel::end(){
+periodentafel::const_iterator periodentafel::end() const{
   return elements.end();
+}
 periodentafel::reverse_iterator periodentafel::rbegin(){
+periodentafel::reverse_iterator periodentafel::rbegin() const{
   return reverse_iterator(elements.end());
+}
 periodentafel::reverse_iterator periodentafel::rend(){
+periodentafel::reverse_iterator periodentafel::rend() const{
   return reverse_iterator(elements.begin());
+}
 …
   if (!input.fail())
     DoLog(0) && (Log() << Verbose(0) << "Using " << filename << " as elements database." << endl);
   status = status && LoadElementsDatabase(&input);
+  status = status && LoadElementsDatabase(input);
   input.close();
   input.clear();
 …
  * \return true - parsing successful, false - something went wrong
  */
 bool periodentafel::LoadElementsDatabase(istream *input)
+bool periodentafel::LoadElementsDatabase(istream &input)
+{
   bool status = true;
+  int counter = 0;
+  pair< std::map<atomicNumber_t,element*>::iterator, bool > InserterTest;
+  if (!(*input).fail()) {
+    (*input).getline(header1, MAXSTRINGSIZE);
+    (*input).getline(header2, MAXSTRINGSIZE); // skip first two header lines
+  string header1tmp,header2tmp;
+  // first parse into a map, so we can revert to old status in case something goes wront
+  map<atomicNumber_t,element*> parsedElements;
+  if (!input.fail()) {
+    getline(input,header1tmp);
+    getline(input,header2tmp); // skip first two header lines
+    //cout << "First header: " << header1tmp << endl;
+    //cout << "Second header: " << header2tmp << endl;
     DoLog(0) && (Log() << Verbose(0) <<  "Parsed elements:");
     while (!(*input).eof()) {
+    while (!input.eof()) {
       element *neues = new element;
       (*input) >> neues->name;
       //(*input) >> ws;
       (*input) >> neues->symbol;
       //(*input) >> ws;
       (*input) >> neues->period;
       //(*input) >> ws;
       (*input) >> neues->group;
       //(*input) >> ws;
       (*input) >> neues->block;
       //(*input) >> ws;
       (*input) >> neues->Z;
       //(*input) >> ws;
       (*input) >> neues->mass;
       //(*input) >> ws;
       (*input) >> neues->CovalentRadius;
       //(*input) >> ws;
       (*input) >> neues->VanDerWaalsRadius;
       //(*input) >> ws;
       (*input) >> ws;
+      input >> neues->name;
+      //(*input) >> ws;
+      input >> neues->symbol;
+      //(*input) >> ws;
+      input >> neues->period;
+      //(*input) >> ws;
+      input >> neues->group;
+      //(*input) >> ws;
+      input >> neues->block;
+      //(*input) >> ws;
+      input >> neues->Z;
+      //(*input) >> ws;
+      input >> neues->mass;
+      //(*input) >> ws;
+      input >> neues->CovalentRadius;
+      //(*input) >> ws;
+      input >> neues->VanDerWaalsRadius;
+      //(*input) >> ws;
+      input >> ws;
       //neues->Output((ofstream *)&cout);
       if ((neues->getNumber() > 0) && (neues->getNumber() < MAX_ELEMENTS)) {
+        if (elements.count(neues->getNumber())) {// if element already present, remove and delete old one (i.e. replace it)
+          //cout << neues->symbol << " is present already." << endl;
+          element * const Elemental = FindElement(neues->getNumber());
+          ASSERT(Elemental != NULL, "element should be present but is not??");
+          *Elemental = *neues;
+          delete(neues);
+          neues = Elemental;
+        } else {
+          InserterTest = elements.insert(pair <atomicNumber_t,element*> (neues->getNumber(), neues));
+          ASSERT(InserterTest.second, "Could not insert new element into periodentafel on LoadElementsDatabase().");
+        }
+        DoLog(0) && (Log() << Verbose(0) << " " << elements[neues->getNumber()]->symbol);
+        counter++;
+        parsedElements[neues->Z] = neues;
+        DoLog(0) && (Log() << Verbose(0) << " " << *neues);
       } else {
         DoeLog(2) && (eLog() << Verbose(2) << "Detected empty line or invalid element in elements db, discarding." << endl);
 …
         delete(neues);
+      }
+      // when the input is in failed state, we most likely just read garbage
+      if(input.fail()) {
+        DoeLog(2) && (eLog() << Verbose(2) << "Error parsing elements db." << endl);
+        status = false;
+        break;
+      }
+    }
     DoLog(0) && (Log() << Verbose(0) << endl);
 …
+  }
   if (counter == 0)
+  if (!parsedElements.size())
     status = false;
+  if(status){
+    for(map<atomicNumber_t,element*>::iterator iter=parsedElements.begin();
+                                               iter!=parsedElements.end();
+                                               ++iter){
+      if (elements.count(iter->first)) {
+        // if element already present, replace the old one
+        // pointer to old element might still be in use, so we have to replace into the old element
+        *(elements[iter->first])=*iter->second;
+        delete(iter->second);
+      }
+      else {
+        // no such element in periodentafel... we can just insert
+        elements[iter->first] = iter->second;
+      }
+    }
+    // all went well.. we now copy the header
+    strncpy(header1,header1tmp.c_str(),MAXSTRINGSIZE);
+    header1[MAXSTRINGSIZE-1]=0;
+    strncpy(header2,header2tmp.c_str(),MAXSTRINGSIZE);
+    header2[MAXSTRINGSIZE-1]=0;
+  }
   return status;

src/periodentafel.hpp

-              r8006ee
+              r994713
   ~periodentafel();
   iterator AddElement(element * const pointer);
   size_t RemoveElement(element * const pointer);
+  iterator AddElement(element * pointer);
+  size_t RemoveElement(const element * pointer);
   size_t RemoveElement(atomicNumber_t);
   void CleanupPeriodtable();
   element * const FindElement(atomicNumber_t) const;
   element * const FindElement(const std::string &shorthand) const;
   element * const AskElement() const;
   element * const EnterElement();
+  const element * FindElement(atomicNumber_t) const;
+  const element * FindElement(const std::string &shorthand) const;
+  const element * AskElement() const;
+  const element * EnterElement();
   const_iterator begin();
   const_iterator end();
   reverse_iterator rbegin();
   reverse_iterator rend();
+  const_iterator begin() const;
+  const_iterator end() const;
+  reverse_iterator rbegin() const;
+  reverse_iterator rend() const;
   bool Output(std::ostream * const output) const;
   bool LoadPeriodentafel(const char * const path);
 …
   private:
   bool LoadElementsDatabase(std::istream *input);
+  bool LoadElementsDatabase(std::istream &input);
   bool LoadValenceDatabase(std::istream *input);
   bool LoadOrbitalsDatabase(std::istream *input);

src/tesselation.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * tesselation.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/tesselationhelpers.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * TesselationHelpers.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
   Center += helper[1] * b;
   Center += helper[2] * c;
+  Center.Scale(1./(helper[0]+helper[1]+helper[2]));
+  if (fabs(helper[0]+helper[1]+helper[2]) > MYEPSILON)
+    Center.Scale(1./(helper[0]+helper[1]+helper[2]));
   Log() << Verbose(1) << "INFO: Center (2nd algo) is at " << Center << "." << endl;
 };

src/triangleintersectionlist.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * triangleintersectionlist.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"

src/unittests/ActOnAllUnitTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ActOnAllUnitTest.cpp
 …
  *      Author: FrederikHeber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/ActionSequenceTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ActionSequenzTest.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include <cppunit/CompilerOutputter.h>

src/unittests/AnalysisCorrelationToPointUnitTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * AnalysisCorrelationToPointUnitTest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;
 …
   // construct element list
   std::vector<element *> elements;
+  std::vector<const element *> elements;
   hydrogen = World::getInstance().getPeriode()->FindElement(1);
   CPPUNIT_ASSERT(hydrogen != NULL && "hydrogen element not found");

src/unittests/AnalysisCorrelationToPointUnitTest.hpp

r8006ee	r994713
37	37	std::vector<molecule *> allMolecules;
38	38	molecule *TestMolecule;
39		element *hydrogen;
	39	const element *hydrogen;
40	40
41	41	CorrelationToPointMap *pointmap;

src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * AnalysisCorrelationToSurfaceUnitTest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/AnalysisCorrelationToSurfaceUnitTest.hpp

-              r8006ee
+              r994713
       std::vector<molecule *> allMolecules;
       molecule *TestSurfaceMolecule;
       element *hydrogen;
       element *carbon;
       std::vector<element *> elements;
+      const element *hydrogen;
+      const element *carbon;
+      std::vector<const element *> elements;
       CorrelationToSurfaceMap *surfacemap;

src/unittests/AnalysisPairCorrelationUnitTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * AnalysisPairCorrelationUnitTest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;
 …
   // construct element list
   std::vector<element *> elements;
+  std::vector<const element *> elements;
   hydrogen = World::getInstance().getPeriode()->FindElement(1);
   CPPUNIT_ASSERT(hydrogen != NULL && "hydrogen element not found");

src/unittests/AnalysisPairCorrelationUnitTest.hpp

r8006ee	r994713
37	37	std::vector<molecule *> allMolecules;
38	38	molecule *TestMolecule;
39		element *hydrogen;
	39	const element *hydrogen;
40	40
41	41	PairCorrelationMap *correlationmap;

src/unittests/AtomDescriptorTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * DescriptorUnittest.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "AtomDescriptorTest.hpp"

src/unittests/BoxUnittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * BoxUnittest.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "BoxUnittest.hpp"

src/unittests/CacheableTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * CacheableTest.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "CacheableTest.hpp"

src/unittests/CountBondsUnitTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * CountBondsUnitTest.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/FormulaUnittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * FormulaUnittest.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "FormulaUnittest.hpp"

src/unittests/LineUnittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * LineUnittest.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "LineUnittest.hpp"

src/unittests/LinkedCellUnitTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * LinkedCellUnitTest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/Makefile.am

-              r8006ee
+              r994713
   atomsCalculationTest \
   AtomDescriptorTest \
+  BaseShapesUnitTest \
   BondGraphUnitTest \
   BoxUnittest \
 …
   AtomDescriptorTest.cpp \
   atomsCalculationTest.cpp \
+  BaseShapesUnittest.cpp \
   bondgraphunittest.cpp \
   BoxUnittest.cpp \
 …
   AtomDescriptorTest.hpp \
   atomsCalculationTest.hpp \
+  BaseShapesUnittest.hpp \
   bondgraphunittest.hpp \
   BoxUnittest.hpp \
 …
 AtomDescriptorTest_LDADD = ${ALLLIBS}
+BaseShapesUnitTest_SOURCES = UnitTestMain.cpp BaseShapesUnittest.cpp BaseShapesUnittest.hpp
+BaseShapesUnitTest_LDADD = ${ALLLIBS}
 BondGraphUnitTest_SOURCES = UnitTestMain.cpp bondgraphunittest.cpp bondgraphunittest.hpp
 BondGraphUnitTest_LDADD = ${ALLLIBS}

src/unittests/MapofActionsTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * analysisbondsunittest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/MatrixUnittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MatrixUnittest.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include <cppunit/CompilerOutputter.h>
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <cppunit/ui/text/TestRunner.h>
+#include <cmath>
 #include "MatrixUnittest.hpp"
 …
+    }
+  }
+}
+void MatrixUnittest::TransposeTest(){
+  Matrix res;
+  // transpose of unit is unit
+  res.one();
+  (const Matrix)res.transpose();
+  CPPUNIT_ASSERT_EQUAL(res,*one);
+  // transpose of transpose is same matrix
+  res.zero();
+  res.set(2,2, 1.);
+  CPPUNIT_ASSERT_EQUAL(res.transpose().transpose(),res);
+}
 …
+}
+void MatrixUnittest::RotationTest(){
+  Matrix res;
+  Matrix inverse;
+  // zero rotation angles yields unity matrix
+  res.rotation(0,0,0);
+  CPPUNIT_ASSERT_EQUAL(*one, res);
+  // arbitrary rotation matrix has det = 1
+  res.rotation(M_PI/3.,1.,M_PI/7.);
+  CPPUNIT_ASSERT(fabs(fabs(res.determinant()) -1.) < MYEPSILON);
+  // inverse is rotation matrix with negative angles
+  res.rotation(M_PI/3.,0.,0.);
+  inverse.rotation(-M_PI/3.,0.,0.);
+  CPPUNIT_ASSERT_EQUAL(*one, res * inverse);
+  // ... or transposed
+  res.rotation(M_PI/3.,0.,0.);
+  CPPUNIT_ASSERT_EQUAL(inverse, ((const Matrix) res).transpose());
+}
 void MatrixUnittest::InvertTest(){

src/unittests/MatrixUnittest.hpp

-              r8006ee
+              r994713
   CPPUNIT_TEST ( VectorTest );
   CPPUNIT_TEST ( OperationTest );
+  CPPUNIT_TEST ( TransposeTest );
+  CPPUNIT_TEST ( RotationTest );
   CPPUNIT_TEST ( InvertTest );
   CPPUNIT_TEST ( DeterminantTest );
 …
   void VectorTest();
   void OperationTest();
+  void TransposeTest();
+  void RotationTest();
   void InvertTest();
   void DeterminantTest();

src/unittests/MoleculeDescriptorTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * MoleculeDescriptorTest.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "MoleculeDescriptorTest.hpp"

src/unittests/ObserverTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ObserverTest.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "ObserverTest.hpp"

src/unittests/ParserUnitTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ParserUnitTest.cpp
 …
  *      Author: metzler
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "ParserUnitTest.hpp"

src/unittests/PlaneUnittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * PlaneUnittest.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "PlaneUnittest.hpp"

src/unittests/ShapeUnittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * ShapeUnittest.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "ShapeUnittest.hpp"
 …
 #include <cppunit/ui/text/TestRunner.h>
+#include <cmath>
 #ifdef HAVE_TESTRUNNER
 #include "UnitTestMain.hpp"
 …
 #include "LinearAlgebra/Vector.hpp"
 #include "Shapes/Shape.hpp"
+#include "Shapes/BaseShapes.hpp"
 // Registers the fixture into the 'registry'
 …
+}
 void ShapeUnittest::operatorTest(){
+  {

src/unittests/SingletonTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * SingletonTest.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "SingletonTest.hpp"

src/unittests/TestRunnerMain.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * TestRunnerMain.cpp

src/unittests/UnitTestMain.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * UnitTestMain.cpp

src/unittests/analysisbondsunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * analysisbondsunittest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/atomsCalculationTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * atomsCalculationTest.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "atomsCalculationTest.hpp"

src/unittests/bondgraphunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * bondgraphunittest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/gslmatrixsymmetricunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * gslmatrixunittest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/gslmatrixunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * gslmatrixunittest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/gslvectorunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * gslvectorunittest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/infounittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * InfoUnitTest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/linearsystemofequationsunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * linearsystemofequationsunittest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/listofbondsunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * listofbondsunittest.cpp
 …
  *      Author: user
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/logunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * logunittest.cpp
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/manipulateAtomsTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * manipulateAtomsTest.cpp
 …
  *      Author: crueger
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "manipulateAtomsTest.hpp"

src/unittests/memoryallocatorunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * memoryallocatorunittest.cpp
+ *
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/memoryusageobserverunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * memoryusageobserverunittest.cpp
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/periodentafelTest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * periodentafelTest.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;
 …
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <cppunit/ui/text/TestRunner.h>
+#include <sstream>
+#include <iostream>
 #include "Helpers/Assert.hpp"
 …
+{
   // reload all databases
+  CPPUNIT_ASSERT(tafel->LoadElementsDatabase(new stringstream(elementsDB,ios_base::in)) && "General element initialization failed");
+  stringstream elementsDBstream(elementsDB,ios_base::in);
+  CPPUNIT_ASSERT(tafel->LoadElementsDatabase(elementsDBstream) && "General element initialization failed");
   CPPUNIT_ASSERT(tafel->LoadValenceDatabase(new stringstream(valenceDB,ios_base::in)) && "Valence entry of element initialization failed");
   CPPUNIT_ASSERT(tafel->LoadOrbitalsDatabase(new stringstream(orbitalsDB,ios_base::in)) && "Orbitals entry of element initialization failed");

src/unittests/periodentafelTest.hpp

-              r8006ee
+              r994713
 private:
       element *hydrogen;
       element *carbon;
+      const element *hydrogen;
+      const element *carbon;
       periodentafel *tafel;

src/unittests/stackclassunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * stackclassunittest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/tesselation_boundarytriangleunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * tesselation_boundarytriangleunittest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/tesselation_insideoutsideunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * tesselation_insideoutsideunittest.cpp
 …
  *      Author: heber
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/tesselationunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * tesselationunittest.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/unittests/vectorunittest.cpp

-              r8006ee
+              r994713
+/*
+ * Project: MoleCuilder
+ * Description: creates and alters molecular systems
+ * Copyright (C)  2010 University of Bonn. All rights reserved.
+ * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
+ */
 /*
  * unittest.cpp
 …
  */
+// include config.h
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 using namespace std;

src/version.h

r8006ee	r994713
2	2	#define VERSION_H_
3	3
4		extern const char *~~ESPACKVersion~~;
	4	extern const char *MOLECUILDERVERSION;
5	5
6	6	#endif /* VERSION_H_ */

test_all.sh

-              r8006ee
+              r994713
 #!/bin/bash
+optimizations=("-O0"\
+optimizations=("-g3"\
+               "-O0"\
                "-O1"\
                "-O2"\
 …
+}
+function logdate()
+{
+  echo -e "Launched on `date`.\n\n" >> $logfile 2>&1;
+}
 while getopts âho:f:j:scO:t:p:â OPTION
 do
 …
 function configure(){
   echo "Configuring";
   CXXFLAGS="$2" $1/configure --prefix=$PWD >> $logfile 2>&1;
+  $1/configure $3 --prefix=$PWD CXXFLAGS="-Wall $2" >> $logfile 2>&1;
+}
 …
     then
       echo -n "    $test: " >> $outfile;
       valgrind -v --error-exitcode=255 $test >> $logfile 2>&1;
+      valgrind -v --leak-check=full --leak-resolution=high --show-reachable=yes --error-exitcode=255 $test >> $logfile 2>&1;
       if [ $? ]
       then
 …
 function test(){
   echo "Testing with \"$2\"";
+  echo "Testing with \"$2 $3\"";
   echo "" >> $logfile;
   echo "" >> $logfile;
   echo "" >> $logfile;
+  echo "Testing with \"$2\"" >> $logfile;
+  echo -n "  Configuring: " >> $outfile;
+  if configure "$1" "$2"
+  echo "Testing with \"$2 $3\"" >> $logfile;
+  if [ x"$2" == x"-g3" ]
+  then
+    valgrind="--with-valgrind"
+  else
+    valgrind="--without-valgrind"
+  fi
+  echo -n "  Configuring $valgrind: " >> $outfile;
+  if configure "$1" "$2 $3" "$valgrind"
   then
     echo "OK" >> $outfile;
 …
 function run(){
   echo "Testing with \"$1\":" >> $outfile;
+  echo "Testing with \"$1 $2\":" >> $outfile;
   testdir=`mktemp -d --tmpdir=$tmpdir $tmppattern.XXXXXXXXXX`;
   basedir=$PWD;
   cd $testdir;
   test "$basedir" "$1";
+  test "$basedir" "$1" "$2";
   cd $basedir;
   rm -rf $testdir;
 …
   for option in "${options[@]}"
   do
     run "$optimization $option";
+    run "$optimization" "$option";
   done
 done

tests/regression/Makefile.am

-              r8006ee
+              r994713
 AUTOM4TE = autom4te
+EXTRA_DIST = testsuite.at $(TESTSUITE) atlocal.in regression
+EXTRA_DIST = \
+        testsuite*.at \
+        $(TESTSUITE) \
+        atlocal.in \
+        molecuider.in \
+        Analysis \
+        Domain \
+        Filling \
+        Fragmentation \
+        Graph \
+        Molecules \
+        Simple_configuration \
+        Tesselation
 TESTSUITE = $(srcdir)/testsuite

tests/regression/Simple_configuration/5/pre/test.conf

-              r8006ee
+              r994713
 OutSrcStep      5       # Output "restart" data every ..th step
 TargetTemp      0.000950045     # Target temperature
 MaxPsiStep      0       # number of Minimisation steps per state (0 - default)
+MaxPsiStep      3       # number of Minimisation steps per state (0 - default)
 EpsWannier      1e-07   # tolerance value for spread minimisation of orbitals
 …
 RelEpsTotalE    1e-07   # relative change in total energy
 RelEpsKineticE  1e-05   # relative change in kinetic energy
 MaxMinStopStep  0       # check every ..th steps
 MaxMinGapStopStep       0       # check every ..th steps
+MaxMinStopStep  1       # check every ..th steps
+MaxMinGapStopStep       1       # check every ..th steps
 # Values specifying when to stop for INIT, otherwise same as above
 …
 InitRelEpsTotalE        1e-05   # relative change in total energy
 InitRelEpsKineticE      0.0001  # relative change in kinetic energy
 InitMaxMinStopStep      0       # check every ..th steps
 InitMaxMinGapStopStep   0       # check every ..th steps
+InitMaxMinStopStep      1       # check every ..th steps
+InitMaxMinGapStopStep   1       # check every ..th steps
 BoxLength                       # (Length of a unit cell)
 …
 Level0Factor    2       # factor by which node number increases from S to 0 level
 RiemannTensor   0       # (Use metric)
 PsiType         0       # 0 - doubly occupied, 1 - SpinUp,SpinDown
+PsiType         1       # 0 - doubly occupied, 1 - SpinUp,SpinDown
 MaxPsiDouble    0       # here: specifying both maximum number of SpinUp- and -Down-states
 PsiMaxNoUp      0       # here: specifying maximum number of SpinUp-states
 PsiMaxNoDown    0       # here: specifying maximum number of SpinDown-states
+PsiMaxNoDown    1       # here: specifying maximum number of SpinDown-states
 AddPsis         0       # Additional unoccupied Psis for bandgap determination

tests/regression/Simple_configuration/8/post/test.xyz-sorted

-              r8006ee
+              r994713
 C       8.53279 4.15859 3.53589
 C       9.78209 3.27519 3.53589
+H       0.758602        0       0
+H       0.758602        0       1.00857
+H       0.758602        0       11.4286
+H       0.758602        0       12.4371
+H       0.758602        0       14.2857
+H       0.758602        0       15.2943
+H       0.758602        0       17.1429
+H       0.758602        0       18.1514
+H       0.758602        0       2.85714
+H       0.758602        0       3.86571
+H       0.758602        0       5.71429
+H       0.758602        0       6.72285
+H       0.758602        0       8.57143
+H       0.758602        0       9.58
+H       0.758602        11.4286 0
+H       0.758602        11.4286 1.00857
+H       0.758602        11.4286 11.4286
+H       0.758602        11.4286 12.4371
+H       0.758602        11.4286 14.2857
+H       0.758602        11.4286 15.2943
+H       0.758602        11.4286 17.1429
+H       0.758602        11.4286 18.1514
+H       0.758602        11.4286 2.85714
+H       0.758602        11.4286 3.86571
+H       0.758602        11.4286 5.71429
+H       0.758602        11.4286 6.72285
+H       0.758602        11.4286 8.57143
+H       0.758602        11.4286 9.58
+H       0.758602        14.2857 0
+H       0.758602        14.2857 1.00857
+H       0.758602        14.2857 11.4286
+H       0.758602        14.2857 12.4371
+H       0.758602        14.2857 14.2857
+H       0.758602        14.2857 15.2943
+H       0.758602        14.2857 17.1429
+H       0.758602        14.2857 18.1514
+H       0.758602        14.2857 2.85714
+H       0.758602        14.2857 3.86571
+H       0.758602        14.2857 5.71429
+H       0.758602        14.2857 6.72285
+H       0.758602        14.2857 8.57143
+H       0.758602        14.2857 9.58
+H       0.758602        17.1429 0
+H       0.758602        17.1429 1.00857
+H       0.758602        17.1429 11.4286
+H       0.758602        17.1429 12.4371
+H       0.758602        17.1429 14.2857
+H       0.758602        17.1429 15.2943
+H       0.758602        17.1429 17.1429
+H       0.758602        17.1429 18.1514
+H       0.758602        17.1429 2.85714
+H       0.758602        17.1429 3.86571
+H       0.758602        17.1429 5.71429
+H       0.758602        17.1429 6.72285
+H       0.758602        17.1429 8.57143
+H       0.758602        17.1429 9.58
+H       0.758602        2.85714 0
+H       0.758602        2.85714 1.00857
+H       0.758602        2.85714 11.4286
+H       0.758602        2.85714 12.4371
+H       0.758602        2.85714 14.2857
+H       0.758602        2.85714 15.2943
+H       0.758602        2.85714 17.1429
+H       0.758602        2.85714 18.1514
 H       0.758602        2.85714 2.85714
 H       0.758602        2.85714 3.86571
 H       0.758602        2.85714 5.71429
+H       0.758602        2.85714 6.72285
+H       0.758602        2.85714 8.57143
+H       0.758602        2.85714 9.58
+H       0.758602        5.71429 0
+H       0.758602        5.71429 1.00857
+H       0.758602        5.71429 11.4286
+H       0.758602        5.71429 12.4371
+H       0.758602        5.71429 14.2857
+H       0.758602        5.71429 15.2943
+H       0.758602        5.71429 17.1429
+H       0.758602        5.71429 18.1514
 H       0.758602        5.71429 2.85714
 H       0.758602        5.71429 3.86571
+H       0.758602        5.71429 5.71429
+H       0.758602        5.71429 6.72285
+H       0.758602        5.71429 8.57143
+H       0.758602        5.71429 9.58
+H       0.758602        8.57143 0
+H       0.758602        8.57143 1.00857
+H       0.758602        8.57143 11.4286
+H       0.758602        8.57143 12.4371
+H       0.758602        8.57143 14.2857
+H       0.758602        8.57143 15.2943
+H       0.758602        8.57143 17.1429
+H       0.758602        8.57143 18.1514
+H       0.758602        8.57143 2.85714
+H       0.758602        8.57143 3.86571
+H       0.758602        8.57143 5.71429
+H       0.758602        8.57143 6.72285
+H       0.758602        8.57143 8.57143
+H       0.758602        8.57143 9.58
 H       10.672  3.90454 3.53589
 H       12.1872 0       0
 H       12.1872 0       1.00857
+H       12.1872 0       11.4286
+H       12.1872 0       12.4371
+H       12.1872 0       14.2857
+H       12.1872 0       15.2943
+H       12.1872 0       17.1429
+H       12.1872 0       18.1514
 H       12.1872 0       2.85714
 H       12.1872 0       3.86571
 H       12.1872 0       5.71429
 H       12.1872 0       6.72285
+H       12.1872 0       8.57143
+H       12.1872 0       9.58
+H       12.1872 11.4286 0
+H       12.1872 11.4286 1.00857
+H       12.1872 11.4286 11.4286
+H       12.1872 11.4286 12.4371
+H       12.1872 11.4286 14.2857
+H       12.1872 11.4286 15.2943
+H       12.1872 11.4286 17.1429
+H       12.1872 11.4286 18.1514
+H       12.1872 11.4286 2.85714
+H       12.1872 11.4286 3.86571
+H       12.1872 11.4286 5.71429
+H       12.1872 11.4286 6.72285
+H       12.1872 11.4286 8.57143
+H       12.1872 11.4286 9.58
+H       12.1872 14.2857 0
+H       12.1872 14.2857 1.00857
+H       12.1872 14.2857 11.4286
+H       12.1872 14.2857 12.4371
+H       12.1872 14.2857 14.2857
+H       12.1872 14.2857 15.2943
+H       12.1872 14.2857 17.1429
+H       12.1872 14.2857 18.1514
+H       12.1872 14.2857 2.85714
+H       12.1872 14.2857 3.86571
+H       12.1872 14.2857 5.71429
+H       12.1872 14.2857 6.72285
+H       12.1872 14.2857 8.57143
+H       12.1872 14.2857 9.58
+H       12.1872 17.1429 0
+H       12.1872 17.1429 1.00857
+H       12.1872 17.1429 11.4286
+H       12.1872 17.1429 12.4371
+H       12.1872 17.1429 14.2857
+H       12.1872 17.1429 15.2943
+H       12.1872 17.1429 17.1429
+H       12.1872 17.1429 18.1514
+H       12.1872 17.1429 2.85714
+H       12.1872 17.1429 3.86571
+H       12.1872 17.1429 5.71429
+H       12.1872 17.1429 6.72285
+H       12.1872 17.1429 8.57143
+H       12.1872 17.1429 9.58
 H       12.1872 2.85714 0
 H       12.1872 2.85714 1.00857
+H       12.1872 2.85714 11.4286
+H       12.1872 2.85714 12.4371
+H       12.1872 2.85714 14.2857
+H       12.1872 2.85714 15.2943
+H       12.1872 2.85714 17.1429
+H       12.1872 2.85714 18.1514
 H       12.1872 2.85714 5.71429
 H       12.1872 2.85714 6.72285
+H       12.1872 2.85714 8.57143
+H       12.1872 2.85714 9.58
 H       12.1872 5.71429 0
 H       12.1872 5.71429 1.00857
+H       12.1872 5.71429 11.4286
+H       12.1872 5.71429 12.4371
+H       12.1872 5.71429 14.2857
+H       12.1872 5.71429 15.2943
+H       12.1872 5.71429 17.1429
+H       12.1872 5.71429 18.1514
 H       12.1872 5.71429 2.85714
 H       12.1872 5.71429 3.86571
 H       12.1872 5.71429 5.71429
 H       12.1872 5.71429 6.72285
+H       12.1872 5.71429 8.57143
+H       12.1872 5.71429 9.58
+H       12.1872 8.57143 0
+H       12.1872 8.57143 1.00857
+H       12.1872 8.57143 11.4286
+H       12.1872 8.57143 12.4371
+H       12.1872 8.57143 14.2857
+H       12.1872 8.57143 15.2943
+H       12.1872 8.57143 17.1429
+H       12.1872 8.57143 18.1514
+H       12.1872 8.57143 2.85714
+H       12.1872 8.57143 3.86571
+H       12.1872 8.57143 5.71429
+H       12.1872 8.57143 6.72285
+H       12.1872 8.57143 8.57143
+H       12.1872 8.57143 9.58
+H       15.0443 0       0
+H       15.0443 0       1.00857
+H       15.0443 0       11.4286
+H       15.0443 0       12.4371
+H       15.0443 0       14.2857
+H       15.0443 0       15.2943
+H       15.0443 0       17.1429
+H       15.0443 0       18.1514
+H       15.0443 0       2.85714
+H       15.0443 0       3.86571
+H       15.0443 0       5.71429
+H       15.0443 0       6.72285
+H       15.0443 0       8.57143
+H       15.0443 0       9.58
+H       15.0443 11.4286 0
+H       15.0443 11.4286 1.00857
+H       15.0443 11.4286 11.4286
+H       15.0443 11.4286 12.4371
+H       15.0443 11.4286 14.2857
+H       15.0443 11.4286 15.2943
+H       15.0443 11.4286 17.1429
+H       15.0443 11.4286 18.1514
+H       15.0443 11.4286 2.85714
+H       15.0443 11.4286 3.86571
+H       15.0443 11.4286 5.71429
+H       15.0443 11.4286 6.72285
+H       15.0443 11.4286 8.57143
+H       15.0443 11.4286 9.58
+H       15.0443 14.2857 0
+H       15.0443 14.2857 1.00857
+H       15.0443 14.2857 11.4286
+H       15.0443 14.2857 12.4371
+H       15.0443 14.2857 14.2857
+H       15.0443 14.2857 15.2943
+H       15.0443 14.2857 17.1429
+H       15.0443 14.2857 18.1514
+H       15.0443 14.2857 2.85714
+H       15.0443 14.2857 3.86571
+H       15.0443 14.2857 5.71429
+H       15.0443 14.2857 6.72285
+H       15.0443 14.2857 8.57143
+H       15.0443 14.2857 9.58
+H       15.0443 17.1429 0
+H       15.0443 17.1429 1.00857
+H       15.0443 17.1429 11.4286
+H       15.0443 17.1429 12.4371
+H       15.0443 17.1429 14.2857
+H       15.0443 17.1429 15.2943
+H       15.0443 17.1429 17.1429
+H       15.0443 17.1429 18.1514
+H       15.0443 17.1429 2.85714
+H       15.0443 17.1429 3.86571
+H       15.0443 17.1429 5.71429
+H       15.0443 17.1429 6.72285
+H       15.0443 17.1429 8.57143
+H       15.0443 17.1429 9.58
+H       15.0443 2.85714 0
+H       15.0443 2.85714 1.00857
+H       15.0443 2.85714 11.4286
+H       15.0443 2.85714 12.4371
+H       15.0443 2.85714 14.2857
+H       15.0443 2.85714 15.2943
+H       15.0443 2.85714 17.1429
+H       15.0443 2.85714 18.1514
+H       15.0443 2.85714 2.85714
+H       15.0443 2.85714 3.86571
+H       15.0443 2.85714 5.71429
+H       15.0443 2.85714 6.72285
+H       15.0443 2.85714 8.57143
+H       15.0443 2.85714 9.58
+H       15.0443 5.71429 0
+H       15.0443 5.71429 1.00857
+H       15.0443 5.71429 11.4286
+H       15.0443 5.71429 12.4371
+H       15.0443 5.71429 14.2857
+H       15.0443 5.71429 15.2943
+H       15.0443 5.71429 17.1429
+H       15.0443 5.71429 18.1514
+H       15.0443 5.71429 2.85714
+H       15.0443 5.71429 3.86571
+H       15.0443 5.71429 5.71429
+H       15.0443 5.71429 6.72285
+H       15.0443 5.71429 8.57143
+H       15.0443 5.71429 9.58
+H       15.0443 8.57143 0
+H       15.0443 8.57143 1.00857
+H       15.0443 8.57143 11.4286
+H       15.0443 8.57143 12.4371
+H       15.0443 8.57143 14.2857
+H       15.0443 8.57143 15.2943
+H       15.0443 8.57143 17.1429
+H       15.0443 8.57143 18.1514
+H       15.0443 8.57143 2.85714
+H       15.0443 8.57143 3.86571
+H       15.0443 8.57143 5.71429
+H       15.0443 8.57143 6.72285
+H       15.0443 8.57143 8.57143
+H       15.0443 8.57143 9.58
+H       17.9015 0       0
+H       17.9015 0       1.00857
+H       17.9015 0       11.4286
+H       17.9015 0       12.4371
+H       17.9015 0       14.2857
+H       17.9015 0       15.2943
+H       17.9015 0       17.1429
+H       17.9015 0       18.1514
+H       17.9015 0       2.85714
+H       17.9015 0       3.86571
+H       17.9015 0       5.71429
+H       17.9015 0       6.72285
+H       17.9015 0       8.57143
+H       17.9015 0       9.58
+H       17.9015 11.4286 0
+H       17.9015 11.4286 1.00857
+H       17.9015 11.4286 11.4286
+H       17.9015 11.4286 12.4371
+H       17.9015 11.4286 14.2857
+H       17.9015 11.4286 15.2943
+H       17.9015 11.4286 17.1429
+H       17.9015 11.4286 18.1514
+H       17.9015 11.4286 2.85714
+H       17.9015 11.4286 3.86571
+H       17.9015 11.4286 5.71429
+H       17.9015 11.4286 6.72285
+H       17.9015 11.4286 8.57143
+H       17.9015 11.4286 9.58
+H       17.9015 14.2857 0
+H       17.9015 14.2857 1.00857
+H       17.9015 14.2857 11.4286
+H       17.9015 14.2857 12.4371
+H       17.9015 14.2857 14.2857
+H       17.9015 14.2857 15.2943
+H       17.9015 14.2857 17.1429
+H       17.9015 14.2857 18.1514
+H       17.9015 14.2857 2.85714
+H       17.9015 14.2857 3.86571
+H       17.9015 14.2857 5.71429
+H       17.9015 14.2857 6.72285
+H       17.9015 14.2857 8.57143
+H       17.9015 14.2857 9.58
+H       17.9015 17.1429 0
+H       17.9015 17.1429 1.00857
+H       17.9015 17.1429 11.4286
+H       17.9015 17.1429 12.4371
+H       17.9015 17.1429 14.2857
+H       17.9015 17.1429 15.2943
+H       17.9015 17.1429 17.1429
+H       17.9015 17.1429 18.1514
+H       17.9015 17.1429 2.85714
+H       17.9015 17.1429 3.86571
+H       17.9015 17.1429 5.71429
+H       17.9015 17.1429 6.72285
+H       17.9015 17.1429 8.57143
+H       17.9015 17.1429 9.58
+H       17.9015 2.85714 0
+H       17.9015 2.85714 1.00857
+H       17.9015 2.85714 11.4286
+H       17.9015 2.85714 12.4371
+H       17.9015 2.85714 14.2857
+H       17.9015 2.85714 15.2943
+H       17.9015 2.85714 17.1429
+H       17.9015 2.85714 18.1514
+H       17.9015 2.85714 2.85714
+H       17.9015 2.85714 3.86571
+H       17.9015 2.85714 5.71429
+H       17.9015 2.85714 6.72285
+H       17.9015 2.85714 8.57143
+H       17.9015 2.85714 9.58
+H       17.9015 5.71429 0
+H       17.9015 5.71429 1.00857
+H       17.9015 5.71429 11.4286
+H       17.9015 5.71429 12.4371
+H       17.9015 5.71429 14.2857
+H       17.9015 5.71429 15.2943
+H       17.9015 5.71429 17.1429
+H       17.9015 5.71429 18.1514
+H       17.9015 5.71429 2.85714
+H       17.9015 5.71429 3.86571
+H       17.9015 5.71429 5.71429
+H       17.9015 5.71429 6.72285
+H       17.9015 5.71429 8.57143
+H       17.9015 5.71429 9.58
+H       17.9015 8.57143 0
+H       17.9015 8.57143 1.00857
+H       17.9015 8.57143 11.4286
+H       17.9015 8.57143 12.4371
+H       17.9015 8.57143 14.2857
+H       17.9015 8.57143 15.2943
+H       17.9015 8.57143 17.1429
+H       17.9015 8.57143 18.1514
+H       17.9015 8.57143 2.85714
+H       17.9015 8.57143 3.86571
+H       17.9015 8.57143 5.71429
+H       17.9015 8.57143 6.72285
+H       17.9015 8.57143 8.57143
+H       17.9015 8.57143 9.58
 H       3.61574 0       0
 H       3.61574 0       1.00857
+H       3.61574 0       11.4286
+H       3.61574 0       12.4371
+H       3.61574 0       14.2857
+H       3.61574 0       15.2943
+H       3.61574 0       17.1429
+H       3.61574 0       18.1514
 H       3.61574 0       2.85714
 H       3.61574 0       3.86571
 H       3.61574 0       5.71429
 H       3.61574 0       6.72285
+H       3.61574 0       8.57143
+H       3.61574 0       9.58
+H       3.61574 11.4286 0
+H       3.61574 11.4286 1.00857
+H       3.61574 11.4286 11.4286
+H       3.61574 11.4286 12.4371
+H       3.61574 11.4286 14.2857
+H       3.61574 11.4286 15.2943
+H       3.61574 11.4286 17.1429
+H       3.61574 11.4286 18.1514
+H       3.61574 11.4286 2.85714
+H       3.61574 11.4286 3.86571
+H       3.61574 11.4286 5.71429
+H       3.61574 11.4286 6.72285
+H       3.61574 11.4286 8.57143
+H       3.61574 11.4286 9.58
+H       3.61574 14.2857 0
+H       3.61574 14.2857 1.00857
+H       3.61574 14.2857 11.4286
+H       3.61574 14.2857 12.4371
+H       3.61574 14.2857 14.2857
+H       3.61574 14.2857 15.2943
+H       3.61574 14.2857 17.1429
+H       3.61574 14.2857 18.1514
+H       3.61574 14.2857 2.85714
+H       3.61574 14.2857 3.86571
+H       3.61574 14.2857 5.71429
+H       3.61574 14.2857 6.72285
+H       3.61574 14.2857 8.57143
+H       3.61574 14.2857 9.58
+H       3.61574 17.1429 0
+H       3.61574 17.1429 1.00857
+H       3.61574 17.1429 11.4286
+H       3.61574 17.1429 12.4371
+H       3.61574 17.1429 14.2857
+H       3.61574 17.1429 15.2943
+H       3.61574 17.1429 17.1429
+H       3.61574 17.1429 18.1514
+H       3.61574 17.1429 2.85714
+H       3.61574 17.1429 3.86571
+H       3.61574 17.1429 5.71429
+H       3.61574 17.1429 6.72285
+H       3.61574 17.1429 8.57143
+H       3.61574 17.1429 9.58
 H       3.61574 2.85714 0
 H       3.61574 2.85714 1.00857
+H       3.61574 2.85714 11.4286
+H       3.61574 2.85714 12.4371
+H       3.61574 2.85714 14.2857
+H       3.61574 2.85714 15.2943
+H       3.61574 2.85714 17.1429
+H       3.61574 2.85714 18.1514
 H       3.61574 2.85714 2.85714
 H       3.61574 2.85714 3.86571
 …
 H       3.61574 2.85714 6.72285
 H       3.61574 2.85714 8.57143
+H       3.61574 2.85714 9.58
 H       3.61574 5.71429 0
 H       3.61574 5.71429 1.00857
+H       3.61574 5.71429 11.4286
+H       3.61574 5.71429 12.4371
+H       3.61574 5.71429 14.2857
+H       3.61574 5.71429 15.2943
+H       3.61574 5.71429 17.1429
+H       3.61574 5.71429 18.1514
 H       3.61574 5.71429 2.85714
 H       3.61574 5.71429 3.86571
 …
 H       3.61574 5.71429 6.72285
 H       3.61574 5.71429 8.57143
+H       3.61574 5.71429 9.58
+H       3.61574 8.57143 0
 H       3.61574 8.57143 1.00857
+H       3.61574 8.57143 11.4286
+H       3.61574 8.57143 12.4371
+H       3.61574 8.57143 14.2857
+H       3.61574 8.57143 15.2943
+H       3.61574 8.57143 17.1429
+H       3.61574 8.57143 18.1514
 H       3.61574 8.57143 2.85714
 H       3.61574 8.57143 3.86571
 H       3.61574 8.57143 5.71429
+H       3.61574 8.57143 6.72285
+H       3.61574 8.57143 8.57143
+H       3.61574 8.57143 9.58
 H       6.39363 3.90454 3.53589
 H       6.47289 0       0
 H       6.47289 0       1.00857
+H       6.47289 0       11.4286
+H       6.47289 0       12.4371
+H       6.47289 0       14.2857
+H       6.47289 0       15.2943
+H       6.47289 0       17.1429
+H       6.47289 0       18.1514
 H       6.47289 0       2.85714
 H       6.47289 0       3.86571
 …
 H       6.47289 0       8.57143
 H       6.47289 0       9.58
+H       6.47289 11.4286 0
+H       6.47289 11.4286 1.00857
+H       6.47289 11.4286 11.4286
+H       6.47289 11.4286 12.4371
+H       6.47289 11.4286 14.2857
+H       6.47289 11.4286 15.2943
+H       6.47289 11.4286 17.1429
+H       6.47289 11.4286 18.1514
+H       6.47289 11.4286 2.85714
+H       6.47289 11.4286 3.86571
+H       6.47289 11.4286 5.71429
+H       6.47289 11.4286 6.72285
+H       6.47289 11.4286 8.57143
+H       6.47289 11.4286 9.58
+H       6.47289 14.2857 0
+H       6.47289 14.2857 1.00857
+H       6.47289 14.2857 11.4286
+H       6.47289 14.2857 12.4371
+H       6.47289 14.2857 14.2857
+H       6.47289 14.2857 15.2943
+H       6.47289 14.2857 17.1429
+H       6.47289 14.2857 18.1514
+H       6.47289 14.2857 2.85714
+H       6.47289 14.2857 3.86571
+H       6.47289 14.2857 5.71429
+H       6.47289 14.2857 6.72285
+H       6.47289 14.2857 8.57143
+H       6.47289 14.2857 9.58
+H       6.47289 17.1429 0
+H       6.47289 17.1429 1.00857
+H       6.47289 17.1429 11.4286
+H       6.47289 17.1429 12.4371
+H       6.47289 17.1429 14.2857
+H       6.47289 17.1429 15.2943
+H       6.47289 17.1429 17.1429
+H       6.47289 17.1429 18.1514
+H       6.47289 17.1429 2.85714
+H       6.47289 17.1429 3.86571
+H       6.47289 17.1429 5.71429
+H       6.47289 17.1429 6.72285
+H       6.47289 17.1429 8.57143
+H       6.47289 17.1429 9.58
 H       6.47289 2.85714 0
+H       6.47289 2.85714 11.4286
+H       6.47289 2.85714 12.4371
+H       6.47289 2.85714 14.2857
+H       6.47289 2.85714 15.2943
+H       6.47289 2.85714 17.1429
+H       6.47289 2.85714 18.1514
 H       6.47289 2.85714 6.72285
 H       6.47289 2.85714 8.57143
 …
 H       6.47289 5.71429 0
 H       6.47289 5.71429 1.00857
+H       6.47289 5.71429 11.4286
+H       6.47289 5.71429 12.4371
+H       6.47289 5.71429 14.2857
+H       6.47289 5.71429 15.2943
+H       6.47289 5.71429 17.1429
+H       6.47289 5.71429 18.1514
 H       6.47289 5.71429 5.71429
 H       6.47289 5.71429 6.72285
 …
 H       6.47289 8.57143 0
 H       6.47289 8.57143 1.00857
+H       6.47289 8.57143 11.4286
+H       6.47289 8.57143 12.4371
+H       6.47289 8.57143 14.2857
+H       6.47289 8.57143 15.2943
+H       6.47289 8.57143 17.1429
+H       6.47289 8.57143 18.1514
 H       6.47289 8.57143 2.85714
 H       6.47289 8.57143 3.86571
 H       6.47289 8.57143 5.71429
 H       6.47289 8.57143 6.72285
+H       6.47289 8.57143 8.57143
+H       6.47289 8.57143 9.58
 H       7.28359 2.64589 2.64589
 H       7.28359 2.64589 4.42589
 …
 H       9.33003 0       0
 H       9.33003 0       1.00857
+H       9.33003 0       11.4286
+H       9.33003 0       12.4371
+H       9.33003 0       14.2857
+H       9.33003 0       15.2943
+H       9.33003 0       17.1429
+H       9.33003 0       18.1514
 H       9.33003 0       2.85714
 H       9.33003 0       3.86571
 …
 H       9.33003 0       6.72285
 H       9.33003 0       8.57143
+H       9.33003 0       9.58
+H       9.33003 11.4286 0
+H       9.33003 11.4286 1.00857
+H       9.33003 11.4286 11.4286
+H       9.33003 11.4286 12.4371
+H       9.33003 11.4286 14.2857
+H       9.33003 11.4286 15.2943
+H       9.33003 11.4286 17.1429
+H       9.33003 11.4286 18.1514
+H       9.33003 11.4286 2.85714
+H       9.33003 11.4286 3.86571
+H       9.33003 11.4286 5.71429
+H       9.33003 11.4286 6.72285
+H       9.33003 11.4286 8.57143
+H       9.33003 11.4286 9.58
+H       9.33003 14.2857 0
+H       9.33003 14.2857 1.00857
+H       9.33003 14.2857 11.4286
+H       9.33003 14.2857 12.4371
+H       9.33003 14.2857 14.2857
+H       9.33003 14.2857 15.2943
+H       9.33003 14.2857 17.1429
+H       9.33003 14.2857 18.1514
+H       9.33003 14.2857 2.85714
+H       9.33003 14.2857 3.86571
+H       9.33003 14.2857 5.71429
+H       9.33003 14.2857 6.72285
+H       9.33003 14.2857 8.57143
+H       9.33003 14.2857 9.58
+H       9.33003 17.1429 0
+H       9.33003 17.1429 1.00857
+H       9.33003 17.1429 11.4286
+H       9.33003 17.1429 12.4371
+H       9.33003 17.1429 14.2857
+H       9.33003 17.1429 15.2943
+H       9.33003 17.1429 17.1429
+H       9.33003 17.1429 18.1514
+H       9.33003 17.1429 2.85714
+H       9.33003 17.1429 3.86571
+H       9.33003 17.1429 5.71429
+H       9.33003 17.1429 6.72285
+H       9.33003 17.1429 8.57143
+H       9.33003 17.1429 9.58
 H       9.33003 2.85714 0
+H       9.33003 2.85714 11.4286
+H       9.33003 2.85714 12.4371
+H       9.33003 2.85714 14.2857
+H       9.33003 2.85714 15.2943
+H       9.33003 2.85714 17.1429
+H       9.33003 2.85714 18.1514
 H       9.33003 2.85714 6.72285
 H       9.33003 2.85714 8.57143
 H       9.33003 2.85714 9.58
 H       9.33003 5.71429 0
+H       9.33003 5.71429 11.4286
+H       9.33003 5.71429 12.4371
+H       9.33003 5.71429 14.2857
+H       9.33003 5.71429 15.2943
+H       9.33003 5.71429 17.1429
+H       9.33003 5.71429 18.1514
 H       9.33003 5.71429 6.72285
 H       9.33003 5.71429 8.57143
 …
 H       9.33003 8.57143 0
 H       9.33003 8.57143 1.00857
+H       9.33003 8.57143 11.4286
+H       9.33003 8.57143 12.4371
+H       9.33003 8.57143 14.2857
+H       9.33003 8.57143 15.2943
+H       9.33003 8.57143 17.1429
+H       9.33003 8.57143 18.1514
 H       9.33003 8.57143 2.85714
 H       9.33003 8.57143 3.86571
 H       9.33003 8.57143 5.71429
 H       9.33003 8.57143 6.72285
+H       9.33003 8.57143 8.57143
+H       9.33003 8.57143 9.58
 H       9.78209 2.64589 2.64589
 H       9.78209 2.64589 4.42589
+O       0       0       0.504284
+O       0       0       11.9329
+O       0       0       14.79
+O       0       0       17.6471
+O       0       0       3.36143
+O       0       0       6.21857
+O       0       0       9.07571
+O       0       11.4286 0.504284
+O       0       11.4286 11.9329
+O       0       11.4286 14.79
+O       0       11.4286 17.6471
+O       0       11.4286 3.36143
+O       0       11.4286 6.21857
+O       0       11.4286 9.07571
+O       0       14.2857 0.504284
+O       0       14.2857 11.9329
+O       0       14.2857 14.79
+O       0       14.2857 17.6471
+O       0       14.2857 3.36143
+O       0       14.2857 6.21857
+O       0       14.2857 9.07571
+O       0       17.1429 0.504284
+O       0       17.1429 11.9329
+O       0       17.1429 14.79
+O       0       17.1429 17.6471
+O       0       17.1429 3.36143
+O       0       17.1429 6.21857
+O       0       17.1429 9.07571
+O       0       2.85714 0.504284
+O       0       2.85714 11.9329
+O       0       2.85714 14.79
+O       0       2.85714 17.6471
+O       0       2.85714 3.36143
+O       0       2.85714 6.21857
+O       0       2.85714 9.07571
+O       0       5.71429 0.504284
+O       0       5.71429 11.9329
+O       0       5.71429 14.79
+O       0       5.71429 17.6471
+O       0       5.71429 3.36143
+O       0       5.71429 6.21857
+O       0       5.71429 9.07571
+O       0       8.57143 0.504284
+O       0       8.57143 11.9329
+O       0       8.57143 14.79
+O       0       8.57143 17.6471
+O       0       8.57143 3.36143
+O       0       8.57143 6.21857
+O       0       8.57143 9.07571
 O       11.4286 0       0.504284
+O       11.4286 0       11.9329
+O       11.4286 0       14.79
+O       11.4286 0       17.6471
 O       11.4286 0       3.36143
 O       11.4286 0       6.21857
+O       11.4286 0       9.07571
+O       11.4286 11.4286 0.504284
+O       11.4286 11.4286 11.9329
+O       11.4286 11.4286 14.79
+O       11.4286 11.4286 17.6471
+O       11.4286 11.4286 3.36143
+O       11.4286 11.4286 6.21857
+O       11.4286 11.4286 9.07571
+O       11.4286 14.2857 0.504284
+O       11.4286 14.2857 11.9329
+O       11.4286 14.2857 14.79
+O       11.4286 14.2857 17.6471
+O       11.4286 14.2857 3.36143
+O       11.4286 14.2857 6.21857
+O       11.4286 14.2857 9.07571
+O       11.4286 17.1429 0.504284
+O       11.4286 17.1429 11.9329
+O       11.4286 17.1429 14.79
+O       11.4286 17.1429 17.6471
+O       11.4286 17.1429 3.36143
+O       11.4286 17.1429 6.21857
+O       11.4286 17.1429 9.07571
 O       11.4286 2.85714 0.504284
+O       11.4286 2.85714 11.9329
+O       11.4286 2.85714 14.79
+O       11.4286 2.85714 17.6471
 O       11.4286 2.85714 6.21857
 O       11.4286 2.85714 9.07571
 O       11.4286 5.71429 0.504284
+O       11.4286 5.71429 11.9329
+O       11.4286 5.71429 14.79
+O       11.4286 5.71429 17.6471
 O       11.4286 5.71429 6.21857
+O       11.4286 5.71429 9.07571
+O       11.4286 8.57143 0.504284
+O       11.4286 8.57143 11.9329
+O       11.4286 8.57143 14.79
+O       11.4286 8.57143 17.6471
 O       11.4286 8.57143 3.36143
+O       11.4286 8.57143 6.21857
+O       11.4286 8.57143 9.07571
+O       14.2857 0       0.504284
+O       14.2857 0       11.9329
+O       14.2857 0       14.79
+O       14.2857 0       17.6471
+O       14.2857 0       3.36143
+O       14.2857 0       6.21857
+O       14.2857 0       9.07571
+O       14.2857 11.4286 0.504284
+O       14.2857 11.4286 11.9329
+O       14.2857 11.4286 14.79
+O       14.2857 11.4286 17.6471
+O       14.2857 11.4286 3.36143
+O       14.2857 11.4286 6.21857
+O       14.2857 11.4286 9.07571
+O       14.2857 14.2857 0.504284
+O       14.2857 14.2857 11.9329
+O       14.2857 14.2857 14.79
+O       14.2857 14.2857 17.6471
+O       14.2857 14.2857 3.36143
+O       14.2857 14.2857 6.21857
+O       14.2857 14.2857 9.07571
+O       14.2857 17.1429 0.504284
+O       14.2857 17.1429 11.9329
+O       14.2857 17.1429 14.79
+O       14.2857 17.1429 17.6471
+O       14.2857 17.1429 3.36143
+O       14.2857 17.1429 6.21857
+O       14.2857 17.1429 9.07571
+O       14.2857 2.85714 0.504284
+O       14.2857 2.85714 11.9329
+O       14.2857 2.85714 14.79
+O       14.2857 2.85714 17.6471
+O       14.2857 2.85714 3.36143
+O       14.2857 2.85714 6.21857
+O       14.2857 2.85714 9.07571
+O       14.2857 5.71429 0.504284
+O       14.2857 5.71429 11.9329
+O       14.2857 5.71429 14.79
+O       14.2857 5.71429 17.6471
+O       14.2857 5.71429 3.36143
+O       14.2857 5.71429 6.21857
+O       14.2857 5.71429 9.07571
+O       14.2857 8.57143 0.504284
+O       14.2857 8.57143 11.9329
+O       14.2857 8.57143 14.79
+O       14.2857 8.57143 17.6471
+O       14.2857 8.57143 3.36143
+O       14.2857 8.57143 6.21857
+O       14.2857 8.57143 9.07571
+O       17.1429 0       0.504284
+O       17.1429 0       11.9329
+O       17.1429 0       14.79
+O       17.1429 0       17.6471
+O       17.1429 0       3.36143
+O       17.1429 0       6.21857
+O       17.1429 0       9.07571
+O       17.1429 11.4286 0.504284
+O       17.1429 11.4286 11.9329
+O       17.1429 11.4286 14.79
+O       17.1429 11.4286 17.6471
+O       17.1429 11.4286 3.36143
+O       17.1429 11.4286 6.21857
+O       17.1429 11.4286 9.07571
+O       17.1429 14.2857 0.504284
+O       17.1429 14.2857 11.9329
+O       17.1429 14.2857 14.79
+O       17.1429 14.2857 17.6471
+O       17.1429 14.2857 3.36143
+O       17.1429 14.2857 6.21857
+O       17.1429 14.2857 9.07571
+O       17.1429 17.1429 0.504284
+O       17.1429 17.1429 11.9329
+O       17.1429 17.1429 14.79
+O       17.1429 17.1429 17.6471
+O       17.1429 17.1429 3.36143
+O       17.1429 17.1429 6.21857
+O       17.1429 17.1429 9.07571
+O       17.1429 2.85714 0.504284
+O       17.1429 2.85714 11.9329
+O       17.1429 2.85714 14.79
+O       17.1429 2.85714 17.6471
+O       17.1429 2.85714 3.36143
+O       17.1429 2.85714 6.21857
+O       17.1429 2.85714 9.07571
+O       17.1429 5.71429 0.504284
+O       17.1429 5.71429 11.9329
+O       17.1429 5.71429 14.79
+O       17.1429 5.71429 17.6471
+O       17.1429 5.71429 3.36143
+O       17.1429 5.71429 6.21857
+O       17.1429 5.71429 9.07571
+O       17.1429 8.57143 0.504284
+O       17.1429 8.57143 11.9329
+O       17.1429 8.57143 14.79
+O       17.1429 8.57143 17.6471
+O       17.1429 8.57143 3.36143
+O       17.1429 8.57143 6.21857
+O       17.1429 8.57143 9.07571
 O       2.85714 0       0.504284
+O       2.85714 0       11.9329
+O       2.85714 0       14.79
+O       2.85714 0       17.6471
 O       2.85714 0       3.36143
 O       2.85714 0       6.21857
+O       2.85714 0       9.07571
+O       2.85714 11.4286 0.504284
+O       2.85714 11.4286 11.9329
+O       2.85714 11.4286 14.79
+O       2.85714 11.4286 17.6471
+O       2.85714 11.4286 3.36143
+O       2.85714 11.4286 6.21857
+O       2.85714 11.4286 9.07571
+O       2.85714 14.2857 0.504284
+O       2.85714 14.2857 11.9329
+O       2.85714 14.2857 14.79
+O       2.85714 14.2857 17.6471
+O       2.85714 14.2857 3.36143
+O       2.85714 14.2857 6.21857
+O       2.85714 14.2857 9.07571
+O       2.85714 17.1429 0.504284
+O       2.85714 17.1429 11.9329
+O       2.85714 17.1429 14.79
+O       2.85714 17.1429 17.6471
+O       2.85714 17.1429 3.36143
+O       2.85714 17.1429 6.21857
+O       2.85714 17.1429 9.07571
 O       2.85714 2.85714 0.504284
+O       2.85714 2.85714 11.9329
+O       2.85714 2.85714 14.79
+O       2.85714 2.85714 17.6471
 O       2.85714 2.85714 3.36143
 O       2.85714 2.85714 6.21857
+O       2.85714 2.85714 9.07571
 O       2.85714 5.71429 0.504284
+O       2.85714 5.71429 11.9329
+O       2.85714 5.71429 14.79
+O       2.85714 5.71429 17.6471
 O       2.85714 5.71429 3.36143
 O       2.85714 5.71429 6.21857
+O       2.85714 5.71429 9.07571
+O       2.85714 8.57143 0.504284
+O       2.85714 8.57143 11.9329
+O       2.85714 8.57143 14.79
+O       2.85714 8.57143 17.6471
 O       2.85714 8.57143 3.36143
+O       2.85714 8.57143 6.21857
+O       2.85714 8.57143 9.07571
 O       5.71429 0       0.504284
+O       5.71429 0       11.9329
+O       5.71429 0       14.79
+O       5.71429 0       17.6471
 O       5.71429 0       3.36143
 O       5.71429 0       6.21857
 O       5.71429 0       9.07571
+O       5.71429 11.4286 0.504284
+O       5.71429 11.4286 11.9329
+O       5.71429 11.4286 14.79
+O       5.71429 11.4286 17.6471
+O       5.71429 11.4286 3.36143
+O       5.71429 11.4286 6.21857
+O       5.71429 11.4286 9.07571
+O       5.71429 14.2857 0.504284
+O       5.71429 14.2857 11.9329
+O       5.71429 14.2857 14.79
+O       5.71429 14.2857 17.6471
+O       5.71429 14.2857 3.36143
+O       5.71429 14.2857 6.21857
+O       5.71429 14.2857 9.07571
+O       5.71429 17.1429 0.504284
+O       5.71429 17.1429 11.9329
+O       5.71429 17.1429 14.79
+O       5.71429 17.1429 17.6471
+O       5.71429 17.1429 3.36143
+O       5.71429 17.1429 6.21857
+O       5.71429 17.1429 9.07571
 O       5.71429 2.85714 0.504284
+O       5.71429 2.85714 11.9329
+O       5.71429 2.85714 14.79
+O       5.71429 2.85714 17.6471
 O       5.71429 2.85714 6.21857
 O       5.71429 2.85714 9.07571
 O       5.71429 5.71429 0.504284
+O       5.71429 5.71429 11.9329
+O       5.71429 5.71429 14.79
+O       5.71429 5.71429 17.6471
 O       5.71429 5.71429 6.21857
 O       5.71429 5.71429 9.07571
 O       5.71429 8.57143 0.504284
+O       5.71429 8.57143 11.9329
+O       5.71429 8.57143 14.79
+O       5.71429 8.57143 17.6471
 O       5.71429 8.57143 3.36143
 O       5.71429 8.57143 6.21857
+O       5.71429 8.57143 9.07571
 O       8.57143 0       0.504284
+O       8.57143 0       11.9329
+O       8.57143 0       14.79
+O       8.57143 0       17.6471
 O       8.57143 0       3.36143
 O       8.57143 0       6.21857
 O       8.57143 0       9.07571
+O       8.57143 11.4286 0.504284
+O       8.57143 11.4286 11.9329
+O       8.57143 11.4286 14.79
+O       8.57143 11.4286 17.6471
+O       8.57143 11.4286 3.36143
+O       8.57143 11.4286 6.21857
+O       8.57143 11.4286 9.07571
+O       8.57143 14.2857 0.504284
+O       8.57143 14.2857 11.9329
+O       8.57143 14.2857 14.79
+O       8.57143 14.2857 17.6471
+O       8.57143 14.2857 3.36143
+O       8.57143 14.2857 6.21857
+O       8.57143 14.2857 9.07571
+O       8.57143 17.1429 0.504284
+O       8.57143 17.1429 11.9329
+O       8.57143 17.1429 14.79
+O       8.57143 17.1429 17.6471
+O       8.57143 17.1429 3.36143
+O       8.57143 17.1429 6.21857
+O       8.57143 17.1429 9.07571
 O       8.57143 2.85714 0.504284
+O       8.57143 2.85714 11.9329
+O       8.57143 2.85714 14.79
+O       8.57143 2.85714 17.6471
 O       8.57143 2.85714 9.07571
 O       8.57143 5.71429 0.504284
+O       8.57143 5.71429 11.9329
+O       8.57143 5.71429 14.79
+O       8.57143 5.71429 17.6471
 O       8.57143 5.71429 9.07571
 O       8.57143 8.57143 0.504284
+O       8.57143 8.57143 11.9329
+O       8.57143 8.57143 14.79
+O       8.57143 8.57143 17.6471
 O       8.57143 8.57143 3.36143
 O       8.57143 8.57143 6.21857
+O       8.57143 8.57143 9.07571

tests/regression/atlocal.in

r8006ee	r994713
1	1	prefix='@prefix@'
2	2	exec_prefix='@prefix@'
3		topdir='@~~top~~dir@'
	3	topdir='@abs_top_builddir@'
4	4	bindir='@bindir@'
	5	valgrind='@VALGRIND@'

tests/regression/molecuilder.in

-              r8006ee
+              r994713
 # wrapper for testing molecuilder
 . ../../atconfig
+. ../../atlocal
+"${abs_top_builddir}/src/molecuilder" \
+        ${1+"$@"}
+if test ! -z ${valgrind}
+then
+G_SLICE=always-malloc G_DEBUG=gc-friendly \
+libtool --mode=execute \
+${valgrind} -v \
+--log-file=valgrind.log \
+--xml=yes \
+--xml-file=valgrind.err \
+--time-stamp=yes \
+--error-exitcode=255 \
+--leak-check=full \
+--leak-resolution=high \
+--num-callers=20 \
+--track-origins=yes \
+--show-reachable=yes \
+"${topdir}/src/molecuilder" \
+${1+"$@"}
+else
+"${topdir}/src/molecuilder" \
+${1+"$@"}
+fi
 status=$?

tests/regression/testsuite-analysis.at

r8006ee	r994713
39	39	AT_KEYWORDS([analysis])
40	40	AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/4/pre/test.conf .], 0)
41		AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -I --select-all-molecules --unselect-molecule-by-~~id 207 --surface-correlation --elements 1 --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-width 1. --bin-end 20 --molecule-by-id 207~~], 0, [stdout], [stderr])
	41	AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -I --select-all-molecules --unselect-molecule-by-formula C3H8 --surface-correlation --elements 1 --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-width 1. --bin-end 20 --molecule-by-id 1], 0, [stdout], [stderr])
42	42	AT_CHECK([fgrep "Begin of CorrelationToSurface" stdout], 0, [ignore], [ignore])
43	43	#AT_CHECK([file=output.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/4/post/$file], 0, [ignore], [ignore])

tests/regression/testsuite-graph.at

-              r8006ee
+              r994713
 AT_CLEANUP
+AT_SETUP([Graph - subgraph dissection with Undo/Redo])
+AT_KEYWORDS([graph])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Graph/2/pre/test.conf .], 0)
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -I], 0, [stdout], [stderr])
+AT_CHECK([fgrep "I scanned 31 molecules." stdout], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Graph/2/pre/test.conf .], 0)
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -I --undo], 0, [stdout], [stderr])
+AT_CHECK([fgrep "I scanned 31 molecules." stdout], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Graph/2/pre/test.conf .], 0)
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -I --undo --redo], 0, [stdout], [stderr])
+AT_CHECK([grep -c "I scanned 31 molecules." stdout], 0, [2
+], [ignore])
+AT_CLEANUP

tests/regression/testsuite-simple_configuration.at

-              r8006ee
+              r994713
 AT_CHECK([../../molecuilder -i test2.conf -e ${abs_top_srcdir}/src/ -o mpqc pcp xyz -a 1 --position "0., 0., -1."], 134, [ignore], [ignore])
 AT_CLEANUP
+AT_SETUP([Simple configuration - adding atom with Undo/Redo])
+AT_KEYWORDS([configuration])
+AT_CHECK([../../molecuilder -i empty.conf -o pcp -a 1 --position "10., 10., 10." --undo], 0, [ignore], [ignore])
+AT_CHECK([file=empty.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -o mpqc pcp xyz -a 1 --position "10., 10., 10." --undo --redo], 0, [ignore], [ignore])
+AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
+AT_CHECK([file=test.in; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
+AT_CHECK([file=test.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
+AT_CLEANUP
 # 4. change the element
 …
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/4/pre/test.xyz test.xyz], 0)
 AT_CHECK([../../molecuilder -i test.xyz -e ${abs_top_srcdir}/src/ --select-atom-by-id 0 -E 6 ], 0, [ignore], [ignore])
+AT_CHECK([file=test.xyz; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/4/post/$file], 0, [ignore], [ignore])
+AT_CLEANUP
+AT_SETUP([Simple configuration - Changing element with Undo/Redo])
+AT_KEYWORDS([configuration])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/4/pre/test.xyz test.xyz], 0)
+AT_CHECK([../../molecuilder -i test.xyz -e ${abs_top_srcdir}/src/ --select-atom-by-id 0 -E 6 --undo], 0, [ignore], [ignore])
+AT_CHECK([file=test.xyz; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/4/pre/$file], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/4/pre/test.xyz test.xyz], 0)
+AT_CHECK([../../molecuilder -i test.xyz -e ${abs_top_srcdir}/src/ --select-atom-by-id 0 -E 6 --undo --redo], 0, [ignore], [ignore])
 AT_CHECK([file=test.xyz; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/4/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_CHECK([file=test.in; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=test.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/post/$file], 0, [ignore], [ignore])
+AT_CLEANUP
+AT_SETUP([Simple configuration - Atom removal with Undo/Redo])
+AT_KEYWORDS([configuration])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/pre/test.conf .], 0)
+AT_CHECK([../../molecuilder -i test.conf --select-atom-by-id 0 -r --undo], 0, [ignore], [ignore])
+AT_CHECK([file=test.conf; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/pre/$file], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/pre/test.conf .], 0)
+AT_CHECK([../../molecuilder -i test.conf --select-atom-by-id 0 -r --undo --redo], 0, [ignore], [ignore])
+AT_CHECK([file=test.conf; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_CLEANUP
 # 8. Removing sphere of atoms
+# 8. Removing _shape_ of atoms
 AT_SETUP([Simple configuration - Removing sphere of atoms])
 AT_KEYWORDS([configuration])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.* .], 0)
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -o xyz -R 7. --position "7.283585982, 3.275186040, 3.535886037"], 0, [stdout], [stderr])
+AT_CHECK([sort -n test.xyz | grep -v "Created by" >test.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/test.xyz  | grep -v "Created by" >${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/test.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.xyz test-withoutsphere.xyz], 0)
+AT_CHECK([../../molecuilder -i test-withoutsphere.xyz --select-atoms-inside-sphere 7. --position "7.283585982, 3.275186040, 3.535886037" -r], 0, [stdout], [stderr])
+AT_CHECK([sort -n test-withoutsphere.xyz | grep -v -E "^[[[:digit:]]]+" | grep -v "Created by" >test-withoutsphere.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-withoutsphere.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.xyz test-sphere.xyz], 0)
+AT_CHECK([../../molecuilder -i test-sphere.xyz --select-all-atoms --unselect-atoms-inside-sphere 7. --position "7.283585982, 3.275186040, 3.535886037" -r], 0, [stdout], [stderr])
+AT_CHECK([sort -n test-sphere.xyz | grep -v -E "^[[[:digit:]]]+" | grep -v "Created by" >test-sphere.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-sphere.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
+AT_CHECK([cat test-sphere.xyz-sorted test-withoutsphere.xyz-sorted | sort -n >test.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
+AT_CLEANUP
+AT_SETUP([Simple configuration - Removing sphere of atoms with Undo/Redo])
+AT_KEYWORDS([configuration])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.xyz .], 0)
+AT_CHECK([../../molecuilder -i test.xyz --select-atoms-inside-sphere 7. --position "7.283585982, 3.275186040, 3.535886037" -r --undo], 0, [stdout], [stderr])
+AT_CHECK([file=test.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/$file], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.xyz test-withoutsphere.xyz], 0)
+AT_CHECK([../../molecuilder -i test-withoutsphere.xyz --select-atoms-inside-sphere 7. --position "7.283585982, 3.275186040, 3.535886037" -r --undo --redo], 0, [stdout], [stderr])
+AT_CHECK([sort -n test-withoutsphere.xyz | grep -v -E "^[[[:digit:]]]+" | grep -v "Created by" >test-withoutsphere.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-withoutsphere.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.xyz .], 0)
+AT_CHECK([../../molecuilder -i test.xyz --select-all-atoms --unselect-atoms-inside-sphere 7. --position "7.283585982, 3.275186040, 3.535886037" -r --undo], 0, [stdout], [stderr])
+AT_CHECK([file=test.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/$file], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.xyz test-sphere.xyz], 0)
+AT_CHECK([../../molecuilder -i test-sphere.xyz --select-all-atoms --unselect-atoms-inside-sphere 7. --position "7.283585982, 3.275186040, 3.535886037" -r --undo --redo], 0, [stdout], [stderr])
+AT_CHECK([sort -n test-sphere.xyz | grep -v -E "^[[[:digit:]]]+" | grep -v "Created by" >test-sphere.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-sphere.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
+AT_CHECK([cat test-sphere.xyz-sorted test-withoutsphere.xyz-sorted | sort -n >test.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
+AT_CLEANUP
+AT_SETUP([Simple configuration - Removing cuboid of atoms])
+AT_KEYWORDS([configuration])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.xyz test-withoutcuboid.xyz], 0)
+AT_CHECK([../../molecuilder -i test-withoutcuboid.xyz --select-atoms-inside-cuboid "2,2,2" --position "9.78,2.64,2.64" -r], 0, [stdout], [stderr])
+AT_CHECK([sort -n test-withoutcuboid.xyz | grep -v -E "^[[[:digit:]]]+" | grep -v "Created by" >test-withoutcuboid.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-withoutcuboid.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.xyz test-cuboid.xyz], 0)
+AT_CHECK([../../molecuilder -i test-cuboid.xyz --select-all-atoms --unselect-atoms-inside-cuboid "2,2,2" --position "9.78,2.64,2.64" -r], 0, [stdout], [stderr])
+AT_CHECK([sort -n test-cuboid.xyz | grep -v -E "^[[[:digit:]]]+" | grep -v "Created by" >test-cuboid.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-cuboid.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
+AT_CHECK([cat test-cuboid.xyz-sorted test-withoutcuboid.xyz-sorted | sort -n >test.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
+AT_CLEANUP
+AT_SETUP([Simple configuration - Removing cuboid of atoms with Undo/Redo])
+AT_KEYWORDS([configuration])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.xyz .], 0)
+AT_CHECK([../../molecuilder -i test.xyz --select-atoms-inside-cuboid "2,2,2" --position "9.78,2.64,2.64" -r --undo], 0, [stdout], [stderr])
+AT_CHECK([file=test.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/$file], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.xyz test-withoutcuboid.xyz], 0)
+AT_CHECK([../../molecuilder -i test-withoutcuboid.xyz --select-atoms-inside-cuboid "2,2,2" --position "9.78,2.64,2.64" -r --undo --redo], 0, [stdout], [stderr])
+AT_CHECK([sort -n test-withoutcuboid.xyz | grep -v -E "^[[[:digit:]]]+" | grep -v "Created by" >test-withoutcuboid.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-withoutcuboid.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.xyz .], 0)
+AT_CHECK([../../molecuilder -i test.xyz --select-all-atoms --unselect-atoms-inside-cuboid "2,2,2" --position "9.78,2.64,2.64" -r --undo], 0, [stdout], [stderr])
+AT_CHECK([file=test.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/$file], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.xyz test-cuboid.xyz], 0)
+AT_CHECK([../../molecuilder -i test-cuboid.xyz --select-all-atoms --unselect-atoms-inside-cuboid "2,2,2" --position "9.78,2.64,2.64" -r --undo --redo], 0, [stdout], [stderr])
+AT_CHECK([sort -n test-cuboid.xyz | grep -v -E "^[[[:digit:]]]+" | grep -v "Created by" >test-cuboid.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-cuboid.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
+AT_CHECK([cat test-cuboid.xyz-sorted test-withoutcuboid.xyz-sorted | sort -n >test.xyz-sorted], 0, [ignore], [ignore])
 AT_CHECK([file=test.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP

tests/regression/testsuite-standard_options.at

-              r8006ee
+              r994713
 AT_CHECK([pwd],[ignore],[ignore])
 AT_CHECK([../../molecuilder -v 1], 0, [stdout], [ignore])
+AT_CHECK([fgrep olecuilder stdout], 0, [ignore], [ignore])
+AT_CHECK([grep "Setting verbosity from .* to 1" stdout], 0, [ignore], [ignore])
+AT_CLEANUP
+AT_SETUP([Standard Options - verbosity with Undo/Redo])
+AT_KEYWORDS([options])
+AT_CHECK([../../molecuilder -v 1 --undo], 0, [stdout], [ignore])
+AT_CHECK([grep "Setting verbosity from 1 to .*" stdout], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -v 1 --undo --redo], 0, [stdout], [ignore])
+AT_CHECK([grep "Setting verbosity from .* to 1" stdout], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_CHECK([fgrep "I won't parse trajectories" stdout], 0, [ignore], [ignore])
 AT_CLEANUP
+AT_SETUP([Standard Options - fast trajectories with Undo/Redo])
+AT_KEYWORDS([options])
+AT_CHECK([../../molecuilder -i test.conf -n 1 --undo], 0, [stdout], [stderr])
+AT_CHECK([fgrep "I will parse trajectories." stdout], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -n 1 --undo --redo], 0, [stdout], [stderr])
+AT_CHECK([grep -c "I won't parse trajectories" stdout], 0, 2
+, [ignore])
+AT_CLEANUP
 # 7. molecule default name
 …
 AT_CHECK([fgrep "Default name of new molecules set to test." stdout], 0, [ignore], [ignore])
 AT_CLEANUP
+AT_SETUP([Standard Options - molecule default name with Undo/Redo])
+AT_KEYWORDS([options])
+AT_CHECK([../../molecuilder -i test.conf -X test --undo], 0, [stdout], [stderr])
+AT_CHECK([fgrep "Default name of new molecules set to none." stdout], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -X test --undo --redo], 0, [stdout], [stderr])
+AT_CHECK([fgrep "Default name of new molecules set to test." stdout], 0, [ignore], [ignore])
+AT_CLEANUP

tests/regression/testsuite.at

r8006ee	r994713
7	7	AT_TESTED(diff fgrep grep)
8	8
	9	# Use colored output with new-enough Autotest.
	10	m4_ifdef([AT_COLOR_TESTS], [AT_COLOR_TESTS])
9	11
10	12	m4_include(testsuite-standard_options.at)

Context Navigation

Changes in / [8006ee:994713]

Legend: