dan2097-opsin-12cfaef8a36f/.hg_archival.txt 0000644 0000000 0000000 00000000171 12172764765 016501 0 ustar 0000000 0000000 repo: e6e7d661ac0d4a52f1782ecd91caf02f437479f3
node: 12cfaef8a36f1a8f82dd6eaef3af6ad8a44dc47c
branch: default
tag: 1.5.0
dan2097-opsin-12cfaef8a36f/.hgignore 0000644 0000000 0000000 00000000122 12172764765 015212 0 ustar 0000000 0000000 relre:opsin-inchi/src/main/java/dl/*
relre:target/*
.classpath
.project
.settings
dan2097-opsin-12cfaef8a36f/.hgtags 0000644 0000000 0000000 00000000726 12172764765 014677 0 ustar 0000000 0000000 c61532ddc5f61d1465660cc78cb9a3201ac75263 0.6.0
f21e8eb2b4910cacd8f453f00e75ca56f9ee55ba 0.6.1
f29b4f25d6c626b6e164f8979a11e20af46eca06 0.7.0
1dda9b730d0ea89c68d18fdc598c1f789de35b27 0.8.0
7a17fa795c9af2a12c92091bb72fc35da9ccc109 0.9.0
3ff8245bb542fa05bc2dfb0961116d1b78fc82f9 1.0.0
d4f0e785d5ae9ce9a2a29b6e64fb63d44111bc05 1.1.0
bb5741be6c9707e89bcbecd4a50551ffd674a2e9 1.2.0
354121fd59845d60046430dd03e7a4c64e2bb94c 1.3.0
76ad2554bb162a428c0ce7d1edf9e25ad7b6664d 1.4.0
dan2097-opsin-12cfaef8a36f/Acknowledgments.txt 0000644 0000000 0000000 00000000553 12172764765 017305 0 ustar 0000000 0000000 The following have contributed to the code and systems here (although some of their code
may have been partially or wholly refactored out).
Alphabetical order:
Albina Absdulina
Rich Apodaca
Peter Corbett
Daniel Lowe (current maintainer)
Peter Murray-Rust
Thanks also goes to the many users who have contributed through suggestions and bug reporting. dan2097-opsin-12cfaef8a36f/LICENSE-External.txt 0000644 0000000 0000000 00000205071 12172764765 017024 0 ustar 0000000 0000000 ******************************* External Copyrighted Content *************************
This distribution contains some content that is copyrighted by its respective owners
and distributed under the indicated licenses.
Automaton (http://www.brics.dk/~amoeller/automaton) - content licensed under the BSD
License (see below)
XOM (http://www.xom.nu) - content licensed under the GNU Lesser General Public License (LGPL)
(see below)
log4j (http://logging.apache.org/log4j/) - content licenced under the The Apache Software License, Version 2.0
(see below)
Commons IO (http://commons.apache.org/io/) - content licenced under the The Apache Software License, Version 2.0
(see below)
Commons CLI (http://commons.apache.org/cli/) - content licenced under the The Apache Software License, Version 2.0
(see below)
For Testing only:
JUnit (http://junit.org) - content licenced under the Common Public Licence version 1.0
(see below)
Mockito (http://mockito.org/) - content licenced under the MIT License
(see below)
If using OPSIN's inchi module:
JNI InChI (http://jni-inchi.sourceforge.net) - content licensed under the GNU Lesser General Public License (LGPL)
(see below)
****************************** COMMON PUBLIC LICENSE **********************************
Common Public License Version 1.0
THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS COMMON PUBLIC
LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
1. DEFINITIONS
"Contribution" means:
a) in the case of the initial Contributor, the initial code and
documentation distributed under this Agreement, and
b) in the case of each subsequent Contributor:
i) changes to the Program, and
ii) additions to the Program;
where such changes and/or additions to the Program originate from and are
distributed by that particular Contributor. A Contribution 'originates' from a
Contributor if it was added to the Program by such Contributor itself or anyone
acting on such Contributor's behalf. Contributions do not include additions to
the Program which: (i) are separate modules of software distributed in
conjunction with the Program under their own license agreement, and (ii) are not
derivative works of the Program.
"Contributor" means any person or entity that distributes the Program.
"Licensed Patents " mean patent claims licensable by a Contributor which are
necessarily infringed by the use or sale of its Contribution alone or when
combined with the Program.
"Program" means the Contributions distributed in accordance with this Agreement.
"Recipient" means anyone who receives the Program under this Agreement,
including all Contributors.
2. GRANT OF RIGHTS
a) Subject to the terms of this Agreement, each Contributor hereby grants
Recipient a non-exclusive, worldwide, royalty-free copyright license to
reproduce, prepare derivative works of, publicly display, publicly perform,
distribute and sublicense the Contribution of such Contributor, if any, and such
derivative works, in source code and object code form.
b) Subject to the terms of this Agreement, each Contributor hereby grants
Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed
Patents to make, use, sell, offer to sell, import and otherwise transfer the
Contribution of such Contributor, if any, in source code and object code form.
This patent license shall apply to the combination of the Contribution and the
Program if, at the time the Contribution is added by the Contributor, such
addition of the Contribution causes such combination to be covered by the
Licensed Patents. The patent license shall not apply to any other combinations
which include the Contribution. No hardware per se is licensed hereunder.
c) Recipient understands that although each Contributor grants the licenses
to its Contributions set forth herein, no assurances are provided by any
Contributor that the Program does not infringe the patent or other intellectual
property rights of any other entity. Each Contributor disclaims any liability to
Recipient for claims brought by any other entity based on infringement of
intellectual property rights or otherwise. As a condition to exercising the
rights and licenses granted hereunder, each Recipient hereby assumes sole
responsibility to secure any other intellectual property rights needed, if any.
For example, if a third party patent license is required to allow Recipient to
distribute the Program, it is Recipient's responsibility to acquire that license
before distributing the Program.
d) Each Contributor represents that to its knowledge it has sufficient
copyright rights in its Contribution, if any, to grant the copyright license set
forth in this Agreement.
3. REQUIREMENTS
A Contributor may choose to distribute the Program in object code form under its
own license agreement, provided that:
a) it complies with the terms and conditions of this Agreement; and
b) its license agreement:
i) effectively disclaims on behalf of all Contributors all warranties and
conditions, express and implied, including warranties or conditions of title and
non-infringement, and implied warranties or conditions of merchantability and
fitness for a particular purpose;
ii) effectively excludes on behalf of all Contributors all liability for
damages, including direct, indirect, special, incidental and consequential
damages, such as lost profits;
iii) states that any provisions which differ from this Agreement are offered
by that Contributor alone and not by any other party; and
iv) states that source code for the Program is available from such
Contributor, and informs licensees how to obtain it in a reasonable manner on or
through a medium customarily used for software exchange.
When the Program is made available in source code form:
a) it must be made available under this Agreement; and
b) a copy of this Agreement must be included with each copy of the Program.
Contributors may not remove or alter any copyright notices contained within the
Program.
Each Contributor must identify itself as the originator of its Contribution, if
any, in a manner that reasonably allows subsequent Recipients to identify the
originator of the Contribution.
4. COMMERCIAL DISTRIBUTION
Commercial distributors of software may accept certain responsibilities with
respect to end users, business partners and the like. While this license is
intended to facilitate the commercial use of the Program, the Contributor who
includes the Program in a commercial product offering should do so in a manner
which does not create potential liability for other Contributors. Therefore, if
a Contributor includes the Program in a commercial product offering, such
Contributor ("Commercial Contributor") hereby agrees to defend and indemnify
every other Contributor ("Indemnified Contributor") against any losses, damages
and costs (collectively "Losses") arising from claims, lawsuits and other legal
actions brought by a third party against the Indemnified Contributor to the
extent caused by the acts or omissions of such Commercial Contributor in
connection with its distribution of the Program in a commercial product
offering. The obligations in this section do not apply to any claims or Losses
relating to any actual or alleged intellectual property infringement. In order
to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
Contributor in writing of such claim, and b) allow the Commercial Contributor to
control, and cooperate with the Commercial Contributor in, the defense and any
related settlement negotiations. The Indemnified Contributor may participate in
any such claim at its own expense.
For example, a Contributor might include the Program in a commercial product
offering, Product X. That Contributor is then a Commercial Contributor. If that
Commercial Contributor then makes performance claims, or offers warranties
related to Product X, those performance claims and warranties are such
Commercial Contributor's responsibility alone. Under this section, the
Commercial Contributor would have to defend claims against the other
Contributors related to those performance claims and warranties, and if a court
requires any other Contributor to pay any damages as a result, the Commercial
Contributor must pay those damages.
5. NO WARRANTY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each
Recipient is solely responsible for determining the appropriateness of using and
distributing the Program and assumes all risks associated with its exercise of
rights under this Agreement, including but not limited to the risks and costs of
program errors, compliance with applicable laws, damage to or loss of data,
programs or equipment, and unavailability or interruption of operations.
6. DISCLAIMER OF LIABILITY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
7. GENERAL
If any provision of this Agreement is invalid or unenforceable under applicable
law, it shall not affect the validity or enforceability of the remainder of the
terms of this Agreement, and without further action by the parties hereto, such
provision shall be reformed to the minimum extent necessary to make such
provision valid and enforceable.
If Recipient institutes patent litigation against a Contributor with respect to
a patent applicable to software (including a cross-claim or counterclaim in a
lawsuit), then any patent licenses granted by that Contributor to such Recipient
under this Agreement shall terminate as of the date such litigation is filed. In
addition, if Recipient institutes patent litigation against any entity
(including a cross-claim or counterclaim in a lawsuit) alleging that the Program
itself (excluding combinations of the Program with other software or hardware)
infringes such Recipient's patent(s), then such Recipient's rights granted under
Section 2(b) shall terminate as of the date such litigation is filed.
All Recipient's rights under this Agreement shall terminate if it fails to
comply with any of the material terms or conditions of this Agreement and does
not cure such failure in a reasonable period of time after becoming aware of
such noncompliance. If all Recipient's rights under this Agreement terminate,
Recipient agrees to cease use and distribution of the Program as soon as
reasonably practicable. However, Recipient's obligations under this Agreement
and any licenses granted by Recipient relating to the Program shall continue and
survive.
Everyone is permitted to copy and distribute copies of this Agreement, but in
order to avoid inconsistency the Agreement is copyrighted and may only be
modified in the following manner. The Agreement Steward reserves the right to
publish new versions (including revisions) of this Agreement from time to time.
No one other than the Agreement Steward has the right to modify this Agreement.
IBM is the initial Agreement Steward. IBM may assign the responsibility to serve
as the Agreement Steward to a suitable separate entity. Each new version of the
Agreement will be given a distinguishing version number. The Program (including
Contributions) may always be distributed subject to the version of the Agreement
under which it was received. In addition, after a new version of the Agreement
is published, Contributor may elect to distribute the Program (including its
Contributions) under the new version. Except as expressly stated in Sections
2(a) and 2(b) above, Recipient receives no rights or licenses to the
intellectual property of any Contributor under this Agreement, whether
expressly, by implication, estoppel or otherwise. All rights in the Program not
expressly granted under this Agreement are reserved.
This Agreement is governed by the laws of the State of New York and the
intellectual property laws of the United States of America. No party to this
Agreement will bring a legal action under this Agreement more than one year
after the cause of action arose. Each party waives its rights to a jury trial in
any resulting litigation.
****************************************************************************
GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright © 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below.
0. Additional Definitions.
As used herein, “this License” refers to version 3 of the GNU Lesser General Public License, and the “GNU GPL” refers to version 3 of the GNU General Public License.
“The Library” refers to a covered work governed by this License, other than an Application or a Combined Work as defined below.
An “Application” is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library.
A “Combined Work” is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the “Linked Version”.
The “Minimal Corresponding Source” for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version.
The “Corresponding Application Code” for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work.
1. Exception to Section 3 of the GNU GPL.
You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL.
2. Conveying Modified Versions.
If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version:
* a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or
* b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy.
3. Object Code Incorporating Material from Library Header Files.
The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following:
* a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License.
* b) Accompany the object code with a copy of the GNU GPL and this license document.
4. Combined Works.
You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following:
* a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License.
* b) Accompany the Combined Work with a copy of the GNU GPL and this license document.
* c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document.
* d) Do one of the following:
o 0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.
o 1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version.
* e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.)
5. Combined Libraries.
You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following:
* a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License.
* b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.
6. Revised Versions of the GNU Lesser General Public License.
The Free Software Foundation may publish revised and/or new versions of the GNU Lesser 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 Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License “or any later version” applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation.
If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library.
****************************************************************************
GNU GENERAL PUBLIC LICENSE (included for compliance with LGPL - no dependencies of OPSIN are GPL)
Version 3, 29 June 2007
Copyright © 2007 Free Software Foundation, Inc.
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 your programs, too.
When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for 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
0. 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.
1. 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.
2. 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.
3. 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 11 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.
4. 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.
5. 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 7. 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.
6. 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.
7. 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.
8. 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.
9. 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.
10. 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.
11. 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.
12. 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.
13. 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.
14. 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.
15. 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.
16. 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.
17. 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.
****************************************************************************
The BSD License
The following is a BSD license template. To generate your own license,change the values of OWNER, ORGANIZATION and YEAR from their original values as given here, and substitute your own.
Note: The advertising clause in the license appearing on BSD Unix files was officially rescinded by the Director of the Office of Technology Licensing of the University of California on July 22 1999. He states that clause 3 is "hereby deleted in its entirety."
Note the new BSD license is thus equivalent to the MIT License, except for the no-endorsement final clause.
= Regents of the University of California
= University of California, Berkeley
= 1998
In the original BSD license, both occurrences of the phrase "COPYRIGHT HOLDERS AND CONTRIBUTORS" in the disclaimer read "REGENTS AND CONTRIBUTORS".
Here is the license template:
Copyright (c) ,
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of the nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
****************************************************************************
The MIT License
Copyright (c) 2007 Mockito contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
dan2097-opsin-12cfaef8a36f/LICENSE.txt 0000644 0000000 0000000 00000021014 12172764765 015235 0 ustar 0000000 0000000 Artistic License 2.0
Copyright (c) 2000-2006, The Perl Foundation.
Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
Preamble
This license establishes the terms under which a given free software Package may be copied, modified, distributed, and/or redistributed. The intent is that the Copyright Holder maintains some artistic control over the development of that Package while still keeping the Package available as open source and free software.
You are always permitted to make arrangements wholly outside of this license directly with the Copyright Holder of a given Package. If the terms of this license do not permit the full use that you propose to make of the Package, you should contact the Copyright Holder and seek a different licensing arrangement.
Definitions
"Copyright Holder" means the individual(s) or organization(s) named in the copyright notice for the entire Package.
"Contributor" means any party that has contributed code or other material to the Package, in accordance with the Copyright Holder's procedures.
"You" and "your" means any person who would like to copy, distribute, or modify the Package.
"Package" means the collection of files distributed by the Copyright Holder, and derivatives of that collection and/or of those files. A given Package may consist of either the Standard Version, or a Modified Version.
"Distribute" means providing a copy of the Package or making it accessible to anyone else, or in the case of a company or organization, to others outside of your company or organization.
"Distributor Fee" means any fee that you charge for Distributing this Package or providing support for this Package to another party. It does not mean licensing fees.
"Standard Version" refers to the Package if it has not been modified, or has been modified only in ways explicitly requested by the Copyright Holder.
"Modified Version" means the Package, if it has been changed, and such changes were not explicitly requested by the Copyright Holder.
"Original License" means this Artistic License as Distributed with the Standard Version of the Package, in its current version or as it may be modified by The Perl Foundation in the future.
"Source" form means the source code, documentation source, and configuration files for the Package.
"Compiled" form means the compiled bytecode, object code, binary, or any other form resulting from mechanical transformation or translation of the Source form.
Permission for Use and Modification Without Distribution
(1) You are permitted to use the Standard Version and create and use Modified Versions for any purpose without restriction, provided that you do not Distribute the Modified Version.
Permissions for Redistribution of the Standard Version
(2) You may Distribute verbatim copies of the Source form of the Standard Version of this Package in any medium without restriction, either gratis or for a Distributor Fee, provided that you duplicate all of the original copyright notices and associated disclaimers. At your discretion, such verbatim copies may or may not include a Compiled form of the Package.
(3) You may apply any bug fixes, portability changes, and other modifications made available from the Copyright Holder. The resulting Package will still be considered the Standard Version, and as such will be subject to the Original License.
Distribution of Modified Versions of the Package as Source
(4) You may Distribute your Modified Version as Source (either gratis or for a Distributor Fee, and with or without a Compiled form of the Modified Version) provided that you clearly document how it differs from the Standard Version, including, but not limited to, documenting any non-standard features, executables, or modules, and provided that you do at least ONE of the following:
(a) make the Modified Version available to the Copyright Holder of the Standard Version, under the Original License, so that the Copyright Holder may include your modifications in the Standard Version.
(b) ensure that installation of your Modified Version does not prevent the user installing or running the Standard Version. In addition, the Modified Version must bear a name that is different from the name of the Standard Version.
(c) allow anyone who receives a copy of the Modified Version to make the Source form of the Modified Version available to others under
(i) the Original License or
(ii) a license that permits the licensee to freely copy, modify and redistribute the Modified Version using the same licensing terms that apply to the copy that the licensee received, and requires that the Source form of the Modified Version, and of any works derived from it, be made freely available in that license fees are prohibited but Distributor Fees are allowed.
Distribution of Compiled Forms of the Standard Version or Modified Versions without the Source
(5) You may Distribute Compiled forms of the Standard Version without the Source, provided that you include complete instructions on how to get the Source of the Standard Version. Such instructions must be valid at the time of your distribution. If these instructions, at any time while you are carrying out such distribution, become invalid, you must provide new instructions on demand or cease further distribution. If you provide valid instructions or cease distribution within thirty days after you become aware that the instructions are invalid, then you do not forfeit any of your rights under this license.
(6) You may Distribute a Modified Version in Compiled form without the Source, provided that you comply with Section 4 with respect to the Source of the Modified Version.
Aggregating or Linking the Package
(7) You may aggregate the Package (either the Standard Version or Modified Version) with other packages and Distribute the resulting aggregation provided that you do not charge a licensing fee for the Package. Distributor Fees are permitted, and licensing fees for other components in the aggregation are permitted. The terms of this license apply to the use and Distribution of the Standard or Modified Versions as included in the aggregation.
(8) You are permitted to link Modified and Standard Versions with other works, to embed the Package in a larger work of your own, or to build stand-alone binary or bytecode versions of applications that include the Package, and Distribute the result without restriction, provided the result does not expose a direct interface to the Package.
Items That are Not Considered Part of a Modified Version
(9) Works (including, but not limited to, modules and scripts) that merely extend or make use of the Package, do not, by themselves, cause the Package to be a Modified Version. In addition, such works are not considered parts of the Package itself, and are not subject to the terms of this license.
General Provisions
(10) Any use, modification, and distribution of the Standard or Modified Versions is governed by this Artistic License. By using, modifying or distributing the Package, you accept this license. Do not use, modify, or distribute the Package, if you do not accept this license.
(11) If your Modified Version has been derived from a Modified Version made by someone other than you, you are nevertheless required to ensure that your Modified Version complies with the requirements of this license.
(12) This license does not grant you the right to use any trademark, service mark, tradename, or logo of the Copyright Holder.
(13) This license includes the non-exclusive, worldwide, free-of-charge patent license to make, have made, use, offer to sell, sell, import and otherwise transfer the Package with respect to any patent claims licensable by the Copyright Holder that are necessarily infringed by the Package. If you institute patent litigation (including a cross-claim or counterclaim) against any party alleging that the Package constitutes direct or contributory patent infringement, then this Artistic License to you shall terminate on the date that such litigation is filed.
(14) Disclaimer of Warranty: THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS IS' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES. THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY YOUR LOCAL LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. dan2097-opsin-12cfaef8a36f/README.text 0000644 0000000 0000000 00000017417 12172764765 015271 0 ustar 0000000 0000000 OPSIN - Open Parser for Systematic IUPAC Nomenclature
=====================================================
__Version 1.5.0 (see ReleaseNotes.txt for what's new in this version)__
__Contact address: __
__Source code: __
__Web interface and informational site: __
__License: [Artistic License 2.0](http://opensource.org/licenses/Artistic-2.0)__
OPSIN is a Java(1.5+) library for IUPAC name-to-structure conversion offering high recall and precision on organic chemical nomenclature.
Supported outputs are SMILES, CML (Chemical Markup Language), InChI (IUPAC International Chemical Identifier) and Standard InChI
### Simple Usage Examples
#### Convert a chemical name to SMILES
`java -jar opsin-1.5.0-jar-with-dependencies.jar -osmi input.txt output.txt`
where input.txt contains chemical name/s, one per line
NameToStructure nts = NameToStructure.getInstance();
String smiles = nts.parseToSmiles("acetonitrile");
#### Convert a chemical name to CML
`java -jar opsin-1.5.0-jar-with-dependencies.jar -ocml input.txt output.txt`
where input.txt contains chemical name/s, one per line
NameToStructure nts = NameToStructure.getInstance();
Element cml = nts.parseToCML("acetonitrile");
#### Convert a chemical name to InChI/StdInChI
`java -jar opsin-1.5.0-jar-with-dependencies.jar -oinchi input.txt output.txt`
`java -jar opsin-1.5.0-jar-with-dependencies.jar -ostdinchi input.txt output.txt`
where input.txt contains chemical name/s, one per line
NameToInchi nti = new NameToInchi()
String inchi = nti.parseToInchi("acetonitrile");
String stdinchi = nti.parseToStdInchi("acetonitrile");
### Advanced Usage
OPSIN 1.5.0 allows enabling of the following parameters:
* allowRadicals: Allows substituents to be interpretable e.g. allows ethyl be interpretable
* wildcardRadicals: If allowRadicals is enabled, this option uses atom/s in the output to represent radical/s; 'R' in CML and '*' in SMILES e.g. changes the output of ethyl from C[CH2] to CC\*
* detailedFailureAnalysis: Provides a potentially more accurate reason as to why a chemical name could not be parsed. This is done by parsing the chemical name from right to left. The trade-off for enabling this is slightly increased memory usage.
* allowAcidsWithoutAcid: Allows interpretation of acids without the word acid e.g. "acetic"
* allowUninterpretableStereo: Allows stereochemistry uninterpretable by OPSIN to be ignored (When used as a library the OpsinResult has a status of WARNING if stereochemistry was ignored)
* verbose: Enables debugging output\*
\*When used as a library this is done by modifying Log4J's logging level e.g. `Logger.getLogger("uk.ac.cam.ch.wwmm.opsin").setLevel(Level.DEBUG);`
The usage of these parameters on the command line is described in the command line's help dialog accessible via:
`java -jar opsin-1.5.0-jar-with-dependencies.jar -h`
These parameters may be controlled using the following code:
NameToStructure nts = NameToStructure.getInstance();
NameToStructureConfig ntsconfig = new NameToStructureConfig();
//a new NameToStructureConfig starts as a copy of OPSIN's default configuration
ntsconfig.setAllowRadicals(true);
OpsinResult result = nts.parseChemicalName("acetonitrile", ntsconfig);
Element cml = result.getCml();
String smiles = result.getSmiles();
String inchi = NameToInchi.convertResultToInChI(result);
String stdinchi = NameToInchi.convertResultToStdInChI(result);
`result.getStatus()` may be checked to see if the conversion was successful. If conversion was unsuccessful the output will always be null.
Note that (std)InChI cannot be generated for polymers or radicals generated in combination with the wildcardRadicals option
### Availability
OPSIN is available as a standalone JAR from Bitbucket,
`opsin-1.5.0-jar-with-dependencies.jar` can be executed as a commandline application or added to the classpath for library usage.
OPSIN is also available from the Maven Central Repository for users of Apache Maven.
If you are using Maven then add the following to your pom.xml:
uk.ac.cam.ch.opsin
opsin-core
1.5.0
If you need just CML or SMILES output support
or
uk.ac.cam.ch.opsin
opsin-inchi
1.5.0
if you also need InChI output support.
### About OPSIN
The workings of OPSIN are more fully described in:
Chemical Name to Structure: OPSIN, an Open Source Solution
Daniel M. Lowe, Peter T. Corbett, Peter Murray-Rust, Robert C. Glen
Journal of Chemical Information and Modeling 2011 51 (3), 739-753
If you use OPSIN to produce results for publication, then it would be great if you could cite us.
The following list broadly summarises what OPSIN can currently do and what will be worked on in the future.
#### Supported nomenclature includes:
* alkanes/alkenes/alkynes/heteroatom chains e.g. hexane, hex-1-ene, tetrasiloxane and their cyclic analogues e.g. cyclopropane
* All IUPAC 1993 recommended rings
* Trivial acids
* Hantzsch-Widman e.g. 1,3-oxazole
* Spiro systems
* All von Baeyer rings e.g. bicyclo[2.2.2]octane
* Hydro e.g. 2,3-dihydropyridine
* Indicated hydrogen e.g. 1H-benzoimidazole
* Heteroatom replacement
* Specification of charge e.g. ium/ide/ylium/uide
* Multiplicative nomenclature e.g. ethylenediaminetetraacetic acid
* Conjunctive nomenclature e.g. cyclohexaneethanol
* Fused ring systems e.g. imidazo[4,5-d]pyridine
* Ring assemblies e.g. biphenyl
* Most prefix and infix functional replacement nomenclature
* The following functional classes: acids, acetals, alcohols, amides, anhydrides, azetidides, azides, bromides, chlorides, cyanates, cyanides,
esters, di/tri/tetra esters, ethers, fluorides, fulminates, glycols, glycol ethers, hemiacetals, hemiketal, hydrazones, hydroperoxides,
hydrazides, imides, iodides, isocyanates, isocyanides, isoselenocyanates, isothiocyanates, ketals, ketones, lactams, lactims,
lactones, selenocyanates, thiocyanates, selenols, thiols, mercaptans, morpholides, oxides, oximes, peroxides, piperazides, piperidides, pyrrolidides, selenides, selenones, selenoxides,
selones, selenoketones, selenosemicarbazones, semicarbazones, sulfides, sulfones, sulfoxides, sultams, sultims, sultines, sultones,
tellurides, telluroketones, tellurosemicarbazones, tellurones, telluroxides, thioketones and thiosemicarbazones
* Greek letters
* Lambda convention
* Amino Acids and derivatives
* Structure-based polymer names e.g. poly(2,2'-diamino-5-hexadecylbiphenyl-3,3'-diyl)
* Simple bridge prefixes e.g. methano
* Specification of oxidation numbers and charge on elements
* Perhalogeno terms
* Subtractive prefixes: deoxy, dehydro, anhydro
* Stoichiometry ratios and mixture indicators
* Nucleosides, (oligo)nucleotides and their esters
* Carbohydrate nomenclature
* Simple CAS names including inverted CAS names
* Steroids including alpha/beta stereochemistry
* E/Z/R/S stereochemistry
* cis/trans indicating relative stereochemistry on rings and as a synonym of E/Z
#### Currently UNsupported nomenclature includes:
* Other less common stereochemical terms
* Most natural Products other than steroids
* Natural product specific nomenclature operations
* Multiplied, unsaturated or composite bridge prefixes e.g. epoxymethano
### Developers and Contributors
* Dr. Daniel Lowe (Current maintainer)
* Dr. Peter Corbett
* Prof. Peter Murray-Rust
We are thankful for contributions from Albina Asadulina and Rich Apodaca
Good Luck and let us know if you have problems, comments or suggestions!
Bugs may be reported on the project's [issue tracker](https://bitbucket.org/dan2097/opsin/issues). dan2097-opsin-12cfaef8a36f/ReleaseNotes.txt 0000644 0000000 0000000 00000027552 12172764765 016561 0 ustar 0000000 0000000 Version 1.5.0
Command line interface now accepts files to read and write to as arguments
Added option to allow interpretation of acids missing the word acid e.g. "acetic" (off by default)
Added option to treat uninterpretable stereochemistry as a warning rather than a failure (off by default)
Added support for nucleotide chains e.g. guanylyl(3'-5')uridine
Added support for parabens, azetidides, morpholides, piperazides, piperidides and pyrrolidides
Vocabulary improvements e.g. homo/beta amino acids
Many minor bug fixes e.g. fulminic acid correctly interpreted
Version 1.4.0
Added support for dialdoses,diketoses,ketoaldoses,alditols,aldonic acids,uronic acids,aldaric acids,glycosides,oligosacchardides, named systematically or from trivial stems, in cyclic or acyclic form
Added support for ketoses named using dehydro
Added support for anhydro
Added more trivial carbohydrate names
Added support for sn-glcyerol
Improved heuristics for phospho substitution
Added hydrazido and anilate suffixes
Allowed more functional class nomenclature to apply to amino acids
Added support for inverting CAS names with substituted functional terms e.g. Acetaldehyde, O-methyloxime
Double substitution of a deoxy chiral centre now uses the CIP rules to decide which substituent replaced the hydroxy group
Unicode right arrows, superscripts and the soft hyphen are now recognised
Version 1.3.0
Added option to output radicals as R groups (* in SMILES)
Added support for carbolactone/dicarboximide/lactam/lactim/lactone/olide/sultam/sultim/sultine/sultone suffixes
Resolved some cases of ambiguity in the grammar; the program's capability to handle longer peptide names is improved
Allowed one (as in ketone) before yl e.g. indol-2-on-3-yl
Allowed primed locants to be used as unprimed locants in a bracket e.g. 2-(4'-methylphenyl)pyridine
Vocabulary improvements
SMILES writer will no longer reuse ring closures on the same atom
Fixed case where a name formed of many words that could be parsed ambiguously would cause OPSIN to run out of memory
NameToStructure.getInstance() no longer throws a checked exception
Many minor bug fixes
Version 1.2.0
OPSIN is now available from Maven Central
Basic support for cylised carbohydrates e.g. alpha-D-glucopyranose
Basic support for systematic carbohydrate stems e.g. D-glycero-D-gluco-Heptose
Added heuristic for correcting esters with omitted spaces
Added support for xanthates/xanthic acid
Minor vocabulary improvements
Fixed a few minor bugs/limitations in the Cahn-Ingold-Prelog rules implementation and made more memory efficient
Many minor improvements and bug fixes
Version 1.1.0
Significant improvements to fused ring numbering code, specifically 3/4/5/7/8 member rings are no longer only allowed in chains of rings
Added support for outputting to StdInChI
Small improvements to fused ring building code
Improvements to heuristics for disambiguating what group is being referred to by a locant
Lower case indicated hydrogen is now recognised
Improvements to parsing speed
Many minor improvements and bug fixes
Version 1.0.0
Added native isomeric SMILES output
Improved command-line interface. The desired format i.e. CML/SMILES/InChI as well as options such as allowing radicals can now all be specified via flags
Debugging is now performed using log4j rather than by passing a verbose flag
Added traditional locants to carboxylic acids and alkanes e.g. beta-hydroxybutyric acid
Added support for cis/trans indicating the relative stereochemistry of two substituents on rings and fused rings sytems
Added support for stoichiometry ratios and mixture indicators
Added support for alpha/beta stereochemistry on steroids
Added support for the method for naming spiro systems described in the 1979 recommendations rule A-42
Added detailedFailureAnalysis option to detect the part of a chemical name that fails to parse
Added support for deoxy
Added open-chain saccharides
Improvements to CAS index name uninversion algorithm
Added support for isotopes into the program allowing deuterio/tritio
Added support for R/S stereochemistry indicated by a locant which is also used to indicate the point of substitution for a substituent
Many minor improvements and bug fixes
Version 0.9.0
Added transition metals/f-block elements and nobel gases
Added support for specifying the charge or oxidation number on elements e.g. aluminium(3+), iron(II)
Calculations based off a van Arkel diagram are now used to determine whether functional bonds to metals should be treated as ionic or covalent
Improved support for prefix functional replacement e.g. hydrazono/amido/imido/hydrazido/nitrido/pseudohalides can now be used for functional replacement on appropriate acids
Ortho/meta/para handling improved - can now only apply to six membered rings
Added support for methylenedioxy
Added support for simple bridge prefixes e.g. methano as in 2,3-methanoindene
Added support for perfluoro/perchloro/perbromo/periodo
Generalised alkane support to allow alkanes of lengths up to 9999 to be described without enumeration
Updated dependency on JNI-InChI to 0.7, hence InChI 1.03 is now used.
Improved algorithm for assigning unlocanted hydro terms
Improved heuristic for determing meaning of oxido
Improved charge balancing e.g. ionic substance of an implicit ratio 2:3 can now be handled rather than being represented as a net charged 1:1 mixture
Grammar is a bit more lenient of placement of stereochemistry and multipliers
Vocabulary improvements especially in the area of nucleosides and nucleotides
Esters of biochemical compounds e.g. triphosphates are now supported
Many minor improvements and bug fixes
Version 0.8.0
NameToStructureConfig can now be used to configure whether radicals e.g. ethyl are output or not.
Names like carbon tetrachloride are now supported
glycol ethers e.g. ethylene glycol ethyl ether are now supported
Prefix functional replacement support now includes halogens e.g. chlorophosphate
Added support for epoxy/epithio/episeleno/epitelluro
Added suport for hydrazides/fluorohydrins/chlorohydrins/bromohydrins/iodohydrins/cyanohydrins/acetals/ketals/hemiacetals/hemiketals/diketones/disulfones named using functional class nomenclature
Improvements to algorithm for assigning and finding atoms corresponding to element symbol locants
Added experimental right to left parser (ReverseParseRules.java)
Vocabulary improvements
Parsing is now even faster
Various bug fixes and name intepretation fixes
Version 0.7.0
Added full support for conjunctive nomenclature e.g. 1,3,5-benzenetriacetic acid
Added basic support for CAS names
Added trivial poly-noncarboxylic acids and more trivial carboxylic acids
Added support for spirobi/spiroter/dispiroter and the majority of spiro(ring-locant-ring) nomenclature
Indicators of the direction that a chemical rotates plane polarised light are now detected and ignored
Fixed many cases of trivial names being interpreted systematically by adding more trivial names and detecting such cases
Names such as oxalic bromide cyanide where a halide/pseudohalide replaces an oxygen are now supported
Amino acid ester named from the neutral amino acid are now supported e.g. glycine ethyl ester
Added more heteroatom replacement terms
Allowed creation of an OPSIN parse through NameToStructure.getOpsinParser()
Added support for dehydro - for unsaturating bonds
Improvements to element symbol locant assignment and retrieving appropriate atoms from locants like N2
OPSIN's SMILES parser now accept specification of number of hydrogens in cases other than chiral atoms
Mixtures specified by separating components by semicolonspace are now supported
Many internal improvements and bug fixes
Version 0.6.1
Counter ions are now duplicated such as to lead to if possible a neutral compound
In names like nitrous amide the atoms modified by the functional replacement can now be substituted
Allowed ~number~ for specifying superscripts
Vocabulary improvements
Added quinone suffix
Tetrahedral sulfur stereochemistry is now recognised
Bug fixes to fix incorrect interpretation of some names e.g. triphosgene is now unparseable rather than 3 x phosghene, phospho has different meanings depending on whether it used on an amino acid or another group etc.
Version 0.6.0
OPSIN is now a mavenised project consisting of two modules: core and inchi. Core does name -->CML, inchi depends on core and allows conversion to inchi
Instead of CML an OpsinResult can be returned which can yield information as to why a name was not interpretable
Added support for unlocanted R/S/E/Z stereochemistry. Removed limit on number of atoms that stereochemistry code can handle
Added support for polymers e.g. poly(ethylene)
Improvements in handling of multiplicative nomenclature
Improvements to fusion nomenclature handling: multiplied components and multi parent systems are now supported
Improved support for functional class nomenclature; space detection has been improved and support has been added for anhydride,oxide,oxime,hydrazone,semicarbazone,thiosemicarbazone,selenosemicarbazone,tellurosemicarbazone,imide
Support for the lambda convention
Locanted esters
Improvements in dearomatisation code
CML output changed to being CML-Lite compliant
Speed improvements
Support for greek letters e.g. as alpha or $a or α
Added more infixes
Added more suffixes
Vocabulary improvements
Systematic handling of amino acid nomenclature
Added support for perhydro
Support for ylium/uide
Support for locants like N-1 (instead of N1)
Fixed potential infinite loop in fused ring numbering
Made grammar more lenient in many places e.g. euphonic o, optional sqaure brackets
Sulph is now treated like sulf as in sulphuric acid
and many misc fixes and improvements
Version 0.5.3
Added support for amic, aldehydic, anilic, anilide, carboxanilide and amoyl suffixes
Added support for cyclic imides e.g. succinimide/succinimido
Added support for amide functional class
Support for locants such as N5 which means a nitrogen that is attached in some way to position 5. Locants of this type may also be used in ester formation.
Some improvements to functional replacement using prefixes e.g. thioethanoic acid now works
Disabled stereochemistry in molecules with over 300 atoms as a temporary fix to the problem in 0.52
Slight improvement in method for deciding which group detachable hydro prefixes apply to.
Minor vocabulary update
Version 0.5.2
Outputting directly to InChI is now supported using the separately available nameToInchi jar (an OPSIN jar is expected in the same location as the nameToInchi jar)
Fused rings with any number of rings in a chain or formed entirely of 6 membered rings can now be numbered
Added support for E/Z/R/S where locants are given. Unlocanted cases will be dealt with in a subsequent release. In very large molecules a lack of memory may be encountered, this will be resolved in a subsequent release
Some Infixes are now supported e.g. ethanthioic acid
All spiro systems with Von Baeyer brackets are now supported e.g. dispiro[4.2.4.2]tetradecane
Vocabulary increase (especially: terpenes, ingorganic acids, fused ring components)
Fixed some problems with components with both acylic and cyclic sections e.g. trityl
Improved locant assignments e.g. 2-furyl is now also fur-2-yl
Speed improvements
Removed dependence on Nux/Saxon
Misc minor fixes
Version 0.5.1
Huge reduction in OPSIN initialisation time (typical ~7 seconds -->800ms)
Allowed thio/seleno/telluro as divalent linkers and for functional replacement when used as prefixes. Peroxy can now be used for functional replacement
Better support for semi-trivally named hydrocarbon fused rings e.g. tetracene
Better handling of carbonic acid derivatives
Improvements to locant assignment
Support for names like triethyltetramine and triethylene glycol
Misc other fixes to prevent OPSIN generating the wrong structure for certain types of names
Version 0.5
Too many changes to list
Version 0.1
Initial release dan2097-opsin-12cfaef8a36f/fullAssembly.xml 0000644 0000000 0000000 00000002427 12172764765 016605 0 ustar 0000000 0000000
jar-with-dependencies
jar
uk.ac.cam.ch.opsin:opsin-core
uk.ac.cam.ch.opsin:opsin-inchi
false
src/main/java
true
Acknowledgments.txt
LICENSE.txt
LICENSE-External.txt
README.text
ReleaseNotes.txt
false
true
runtime
${project.build.outputDirectory}
dan2097-opsin-12cfaef8a36f/opsin-core/pom.xml 0000644 0000000 0000000 00000003756 12172764765 017022 0 ustar 0000000 0000000
4.0.0
opsin
uk.ac.cam.ch.opsin
1.5.0
opsin-core
OPSIN Core
Core files of OPSIN. Allows conversion of chemical names to CML (Chemical Markup Language)
maven-assembly-plugin
jar-with-dependencies
uk.ac.cam.ch.wwmm.opsin.NameToStructure
dk.brics.automaton
automaton
xom
xom
commons-io
commons-io
commons-cli
commons-cli
log4j
log4j
junit
junit
test
org.mockito
mockito-all
test
dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/Atom.java 0000644 0000000 0000000 00000046447 12172764765 026163 0 ustar 0000000 0000000 package uk.ac.cam.ch.wwmm.opsin;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import nu.xom.Attribute;
import nu.xom.Element;
import static uk.ac.cam.ch.wwmm.opsin.OpsinTools.*;
/**
* An atom. Carries information about which fragment it is in, and an ID
* number and a list of bonds that it is involved. It may also have other information such as
* whether it has "spare valencies" due to unsaturation, its charge, locant labels, stereochemistry and notes
*
* @author ptc24
* @author dl387
*
*/
class Atom {
/**The (unique over the molecule) ID of the atom.*/
private int ID;
/**The atomic symbol of the atom. */
private String element;
/**The locants that pertain to the atom.*/
private final List locants = new ArrayList();
/**The formal charge on the atom.*/
private int charge = 0;
/**The isotope of the atom. Null if not defined explicitly.*/
private Integer isotope = null;
/**
* Holds the atomParity object associated with this object
* null by default
*/
private AtomParity atomParity = null;
/**The bonds that involve the atom*/
private final List bonds = new ArrayList();
/**A map between PropertyKey s as declared here and useful atom properties, usually relating to some kind of special case. */
@SuppressWarnings("rawtypes")
private final Map properties = new HashMap();
/** A set of atoms that were equally plausible to perform functional replacement on */
static final PropertyKey> AMBIGUOUS_ELEMENT_ASSIGNMENT = new PropertyKey>("ambiguousElementAssignment");
/** The hydrogen count as set in the SMILES*/
static final PropertyKey SMILES_HYDROGEN_COUNT = new PropertyKey("smilesHydrogenCount");
/** The oxidation number as specified by Roman numerals in the name*/
static final PropertyKey OXIDATION_NUMBER = new PropertyKey("oxidationNumber");
/** Is this atom the carbon of an aldehyde? (however NOT formaldehyde)*/
static final PropertyKey ISALDEHYDE = new PropertyKey("isAldehyde");
/** Indicates that this atom is an anomeric atom in a cyclised carbohydrate*/
static final PropertyKey ISANOMERIC = new PropertyKey("isAnomeric");
/** Transient integer used to indicate traversal of fragments*/
static final PropertyKey VISITED = new PropertyKey("visited");
/**The fragment to which the atom belongs.*/
private Fragment frag;
/** Whether an atom is part of a delocalised set of double bonds. A double bond in a kekule structure
* can be mapped to a single bond with this attribute set to true on both atoms that were in the double bond
* For example, benzene could be temporarily represented by six singly-bonded atoms, each with a set
* spare valency attribute , and later converted into a fully-specified valence structure.*/
private boolean spareValency = false;
/**The total bond order of all bonds that are expected to be used for inter fragment bonding
* e.g. in butan-2-ylidene this would be 2 for the atom at position 2 and 0 for the other 3 */
private int outValency = 0;
/** Null by default or set by the lambda convention.*/
private Integer lambdaConventionValency;
/** Null by default or set by the SMILES builder*/
private Integer minimumValency;
/** This is modified by ium/ide/ylium/uide and is used to choose the appropriate valency for the atom*/
private int protonsExplicitlyAddedOrRemoved = 0;
/**
* Takes same values as type in Fragment. Useful for discriminating suffix atoms from other atoms when a suffix is incorporated into another fragments
*/
private String type;
/**
* Is this atom in a ring. Default false. Set by the CycleDetector.
* Double bonds are only converted to spareValency if atom is in a ring
* Some suffixes have different meanings if an atom is part of a ring or not c.g. cyclohexanal vs ethanal
*/
private boolean atomIsInACycle =false;
/**
* Builds an Atom from scratch.
* GENERALLY EXCEPT FOR TESTING SHOULD NOT BE CALLED EXCEPT FROM THE FRAGMANAGER
* @param ID The ID number, unique to the atom in the molecule being built
* @param element The atomic symbol of the chemical element
* @param frag the Fragment to contain the Atom
*/
Atom(int ID, String element, Fragment frag) {
if (frag==null){
throw new IllegalArgumentException("Atom is not in a fragment!");
}
if (element==null){
throw new IllegalArgumentException("Atom does not have an element!");
}
this.frag = frag;
this.ID = ID;
this.element = element;
this.type =frag.getType();
}
/** Used to build a DUMMY atom.
* Does not have an id/frag/type as would be expected for a proper atom
* @param element An identifier for this atom
*/
Atom(String element){
this.element = element;
}
/**Produces a nu.xom.Element for a CML Atom tag, containing
* attributes for id, elementType and (if appropriate) formalCharge, isotopeNumber.
* Where applicable child elements are created for atomParity and locant labels
*
* @return nu.xom.Element for a CML Atom tag
*/
Element toCMLAtom() {
Element elem = new Element("atom", XmlDeclarations.CML_NAMESPACE);
elem.addAttribute(new Attribute("id", "a" + Integer.toString(ID)));
elem.addAttribute(new Attribute("elementType", element));
if(charge != 0){
elem.addAttribute(new Attribute("formalCharge", Integer.toString(charge)));
}
if(isotope != null){
elem.addAttribute(new Attribute("isotopeNumber", Integer.toString(isotope)));
}
if (!element.equals("H")){
int hydrogenCount =0;
List neighbours = this.getAtomNeighbours();
for (Atom neighbour : neighbours) {
if (neighbour.getElement().equals("H")){
hydrogenCount++;
}
}
if (hydrogenCount==0){//prevent adding of implicit hydrogen
elem.addAttribute(new Attribute("hydrogenCount", "0"));
}
}
if(atomParity != null){
elem.appendChild(atomParity.toCML());
}
for(String l : locants) {
Element locant = new Element("label", XmlDeclarations.CML_NAMESPACE);
locant.addAttribute(new Attribute("value", l));
locant.addAttribute(new Attribute("dictRef", "cmlDict:locant" ));
elem.appendChild(locant);
}
return elem;
}
/**
* Uses the lambdaConventionValency or if that is not available
* the default valency assuming this is >= the current valency
* If not then allowed the chemically sensible valencies of the atom are checked with the one that is closest and >= to the current valency
* being returned. If the valency has still not been determined the current valency i.e. assuming the atom to have 0 implicit hydrogen is returned.
* This is the correct behaviour for inorganics. For p block elements it means that OPSIN does not believe the atom to be in a valid valency (too high)
*
* if considerOutValency is true, the valency that will be used to form bonds using the outAtoms is
* taken into account i.e. if any radicals were used to form bonds
* @param considerOutValency
* @return
*/
int determineValency(boolean considerOutValency) {
if (lambdaConventionValency != null){
return lambdaConventionValency +protonsExplicitlyAddedOrRemoved;
}
int currentValency =getIncomingValency();
if (considerOutValency){
currentValency+=outValency;
}
Integer calculatedMinValency = minimumValency == null ? null : minimumValency + protonsExplicitlyAddedOrRemoved;
if (charge ==0 || protonsExplicitlyAddedOrRemoved !=0){
Integer defaultValency =ValencyChecker.getDefaultValency(element);
if (defaultValency !=null){
defaultValency += protonsExplicitlyAddedOrRemoved;
if (currentValency <= defaultValency && (calculatedMinValency == null || defaultValency >= calculatedMinValency)){
return defaultValency;
}
}
}
Integer[] possibleValencies =ValencyChecker.getPossibleValencies(element, charge);
if (possibleValencies!=null) {
if (calculatedMinValency!=null && calculatedMinValency >= currentValency){
return calculatedMinValency;
}
for (Integer possibleValency : possibleValencies) {
if (calculatedMinValency!=null && possibleValency < calculatedMinValency){
continue;
}
if (currentValency <= possibleValency){
return possibleValency;
}
}
}
if (calculatedMinValency!=null && calculatedMinValency>= currentValency){
return calculatedMinValency;
}
else{
return currentValency;
}
}
/**Adds a locant to the Atom. Other locants are preserved.
* Also associates the locant with the atom in the parent fragments hash
*
* @param locant The new locant
*/
void addLocant(String locant) {
locants.add(locant);
frag.addMappingToAtomLocantMap(locant, this);
}
/**Replaces all existing locants with a new one.
*
* @param locant The new locant
*/
void replaceLocants(String locant) {
clearLocants();
addLocant(locant);
}
void removeLocant(String locantToRemove) {
int locantArraySize =locants.size();
for (int i = locantArraySize -1; i >=0 ; i--) {
if (locants.get(i).equals(locantToRemove)){
locants.remove(i);
frag.removeMappingFromAtomLocantMap(locantToRemove);
}
}
}
/**Removes all locants from the Atom.
*
*/
void clearLocants() {
for (String l : locants) {
frag.removeMappingFromAtomLocantMap(l);
}
locants.clear();
}
/**
* Removes only elementSymbolLocants: e.g. N, S', Se
*/
void removeElementSymbolLocants() {
for (int i = locants.size()-1; i >=0; i--) {
String l =locants.get(i);
if (MATCH_ELEMENT_SYMBOL_LOCANT.matcher(l).matches()){
frag.removeMappingFromAtomLocantMap(l);
locants.remove(i);
}
}
}
/**
* Removes all locants other than elementSymbolLocants (e.g. N, S', Se)
* Hence removes numeric locants and greek locants
*/
void removeLocantsOtherThanElementSymbolLocants() {
for (int i = locants.size()-1; i >=0; i--) {
String l =locants.get(i);
if (!MATCH_ELEMENT_SYMBOL_LOCANT.matcher(l).matches()){
frag.removeMappingFromAtomLocantMap(l);
locants.remove(i);
}
}
}
/**Checks if the Atom has a given locant.
*
* @param locant The locant to test for
* @return true if it has, false if not
*/
boolean hasLocant(String locant) {
for(String l : locants) {
if(l.equals(locant))
return true;
}
Matcher m = MATCH_AMINOACID_STYLE_LOCANT.matcher(locant);
if (m.matches()){//e.g. N'5
if (element.equals(m.group(1))){//element symbol
if (!m.group(2).equals("") && (!hasLocant(m.group(1) +m.group(2)))){//has primes
return false;//must have exact locant e.g. N'
}
if (OpsinTools.depthFirstSearchForNonSuffixAtomWithLocant(this, m.group(3))!=null){
return true;
}
}
}
return false;
}
/**Gets the first locant for the Atom. This may be the locant that was initially
* specified, or the most recent locant specified using replaceLocant, or first
* locant to be added since the last invocation of clearLocants.
*
* @return The locant, or null if there is no locant
*/
String getFirstLocant() {
if(locants.size() == 0)
return null;
return locants.get(0);
}
/**Returns the array of locants containing all locants associated with the atom
*
* @return The list of locants (may be empty)
*/
List getLocants() {
return Collections.unmodifiableList(locants);
}
/**Returns the subset of the locants which are element symbol locants e.g. N, S', Se
*
* @return The list of locants (may be empty)
*/
List getElementSymbolLocants() {
List elementSymbolLocants =new ArrayList();
for (String l : locants) {
if (MATCH_ELEMENT_SYMBOL_LOCANT.matcher(l).matches()) {
elementSymbolLocants.add(l);
}
}
return elementSymbolLocants;
}
void setFrag(Fragment f) {
frag = f;
}
Fragment getFrag() {
return frag;
}
/**Gets the ID of the atom.
*
* @return The ID of the atom
*/
int getID() {
return ID;
}
/**Gets the atomic symbol corresponding to the element of the atom.
*
* @return The atomic symbol corresponding to the element of the atom
*/
String getElement() {
return element;
}
/**Sets the atomic symbol corresponding to the element of the atom.
*
* @param elem The atomic symbol corresponding to the element of the atom
*/
void setElement(String elem) {
element = elem;
}
/**Gets the formal charge on the atom.
*
* @return The formal charge on the atom
*/
int getCharge() {
return charge;
}
/**Modifies the charge of this atom by the amount given. This can be any integer
* The number of protons changed is noted so as to calculate the correct valency for the atom. This can be any integer.
* For example ide is the loss of a proton so is charge=-1, protons =-1
* @param charge
* @param protons
*/
void addChargeAndProtons(int charge, int protons){
this.charge += charge;
protonsExplicitlyAddedOrRemoved+=protons;
}
/**Sets the formal charge on the atom.
* NOTE: make sure to update protonsExplicitlyAddedOrRemoved if necessary
*
* @param c The formal charge on the atom
*/
void setCharge(int c) {
charge = c;
}
/**
* Sets the formal charge and number of protonsExplicitlyAddedOrRemoved to 0
*/
void neutraliseCharge() {
charge = 0;
protonsExplicitlyAddedOrRemoved = 0;
}
/**
* Gets the mass number of the atom or null if not explicitly defined
* e.g. 3 for tritium
* @return
*/
Integer getIsotope() {
return isotope;
}
/**
* Sets the mass number of the atom explicitly
* @param isotope
*/
void setIsotope(Integer isotope) {
this.isotope = isotope;
}
/**Adds a bond to the atom
*
* @param b The bond to be added
*/
void addBond(Bond b) {
if (!bonds.contains(b)){
bonds.add(b);
}
}
/**Removes a bond to the atom
*
* @param b The bond to be removed
* @return whether bond was present
*/
boolean removeBond(Bond b) {
return bonds.remove(b);
}
/**Calculates the number of bonds connecting to the atom, excluding bonds to implicit
* hydrogens. Double bonds count as
* two bonds, etc. Eg ethene - both C's have an incoming valency of 2.
*
* @return Incoming Valency
*/
int getIncomingValency() {
int v = 0;
for(Bond b : bonds) {
v += b.getOrder();
}
return v;
}
int getProtonsExplicitlyAddedOrRemoved() {
return protonsExplicitlyAddedOrRemoved;
}
void setProtonsExplicitlyAddedOrRemoved(int protonsExplicitlyAddedOrRemoved) {
this.protonsExplicitlyAddedOrRemoved = protonsExplicitlyAddedOrRemoved;
}
/**Does the atom have spare valency to form double bonds?
*
* @return true if atom has spare valency
*/
boolean hasSpareValency() {
return spareValency;
}
/**Set whether an atom has spare valency
*
* @param sv The spare valency
*/
void setSpareValency(boolean sv) {
spareValency = sv;
}
/**Gets the total bond order of the bonds expected to be created from this atom for inter fragment bonding
*
* @return The outValency
*/
int getOutValency() {
return outValency;
}
/**Adds to the total bond order of the bonds expected to be created from this atom for inter fragment bonding
*
* @param outV The outValency to be added
*/
void addOutValency(int outV) {
outValency += outV;
}
List getBonds() {
return Collections.unmodifiableList(bonds);
}
/**Gets a list of atoms that connect to the atom
*
* @return The list of atoms connected to the atom
*/
List getAtomNeighbours(){
List results = new ArrayList();
for(Bond b : bonds) {
results.add(b.getOtherAtom(this));
}
return results;
}
Integer getLambdaConventionValency() {
return lambdaConventionValency;
}
void setLambdaConventionValency(Integer valency) {
this.lambdaConventionValency = valency;
}
String getType() {
return type;
}
void setType(String type) {
this.type = type;
}
boolean getAtomIsInACycle() {
return atomIsInACycle;
}
/**
* Sets whether atom is in a cycle, true if it is
* @param atomIsInACycle
*/
void setAtomIsInACycle(boolean atomIsInACycle) {
this.atomIsInACycle = atomIsInACycle;
}
AtomParity getAtomParity() {
return atomParity;
}
void setAtomParity(AtomParity atomParity) {
this.atomParity = atomParity;
}
void setAtomParity(Atom[] atomRefs4, int parity) {
atomParity = new AtomParity(atomRefs4, parity);
}
Integer getMinimumValency() {
return minimumValency;
}
void setMinimumValency(Integer minimumValency) {
this.minimumValency = minimumValency;
}
@SuppressWarnings("unchecked")
T getProperty(PropertyKey propertyKey) {
return (T) properties.get(propertyKey);
}
void setProperty(PropertyKey propertyKey, T value) {
properties.put(propertyKey, value);
}
/**
* Checks if the valency of this atom allows it to have the amount of spare valency that the atom currently has
* May reduce the spare valency on the atom to be consistent with the valency of the atom
* Does nothing if the atom has no spare valency
* @param takeIntoAccountExternalBonds
* @throws StructureBuildingException
*/
void ensureSVIsConsistantWithValency(boolean takeIntoAccountExternalBonds) throws StructureBuildingException {
if (spareValency){
Integer maxValency;
if (lambdaConventionValency!=null){
maxValency=lambdaConventionValency + protonsExplicitlyAddedOrRemoved;
}
else{
if (element.equals("C")){
maxValency = 4 + protonsExplicitlyAddedOrRemoved;
}
else{
if (ValencyChecker.getHWValency(element)==null){
throw new StructureBuildingException(element +" is not expected to be aromatic!");
}
maxValency = ValencyChecker.getHWValency(element) + protonsExplicitlyAddedOrRemoved;
}
}
int maxSpareValency;
if (takeIntoAccountExternalBonds){
maxSpareValency =maxValency-getIncomingValency() -outValency;
}
else{
maxSpareValency =maxValency-frag.getIntraFragmentIncomingValency(this);
}
if (maxSpareValency < 1){
setSpareValency(false);
}
}
}
/**
* Returns the the first bond in the atom's bond list or null if it has no bonds
* @return
*/
Bond getFirstBond() {
if (bonds.size() > 0){
return bonds.get(0);
}
return null;
}
/**Gets the bond between this atom and a given atom
*
* @param a The atom to find a bond to
* @return The bond, or null if there is no bond
*/
Bond getBondToAtom(Atom a) {
for (Bond b : bonds) {
if(b.getOtherAtom(this) == a){
return b;
}
}
return null;
}
/**Gets the bond between this atom and a given atom, throwing if fails.
*
* @param a The atom to find a bond to
* @return The bond found
* @throws StructureBuildingException
*/
Bond getBondToAtomOrThrow(Atom a) throws StructureBuildingException {
Bond b = getBondToAtom(a);
if(b == null){
throw new StructureBuildingException("Couldn't find specified bond");
}
return b;
}
}
dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/AtomParity.java 0000644 0000000 0000000 00000003636 12172764765 027345 0 ustar 0000000 0000000 package uk.ac.cam.ch.wwmm.opsin;
import nu.xom.Attribute;
import nu.xom.Element;
/**
* Hold information about 4 atoms and their chiral determinant allowing the description of tetrahedral stereochemistry
* @author dl387
*
*/
class AtomParity {
/**
* A dummy hydrogen atom. Used to represent an implicit hydrogen that is attached to a tetrahedral stereocentre
*/
static final Atom hydrogen = new Atom("H");
/**
* A dummy hydrogen atom. Used to represent the hydrogen that replaced a hydroxy at a tetrahedral stereocentre
*/
static final Atom deoxyHydrogen = new Atom("H");
private Atom[] atomRefs4;
private int parity;
/**
* Create an atomParity from an array of 4 atoms and the parity of the chiral determinant
* @param atomRefs4
* @param parity
*/
AtomParity(Atom[] atomRefs4, int parity){
if (atomRefs4.length !=4){
throw new IllegalArgumentException("atomRefs4 must contain references to 4 atoms");
}
this.atomRefs4 = atomRefs4;
this.parity = parity;
}
/**
* Serialises this object to CML
* @return
*/
Element toCML() {
Element atomParityElement = new Element(XmlDeclarations.CML_ATOMPARITY_EL, XmlDeclarations.CML_NAMESPACE);
StringBuilder atomRefsSb = new StringBuilder();
for(int i=0; i1.8), polar or covalent (diff < 1.2)
*/
static final Map elementToPaulingElectronegativity = new HashMap();
static final Map elementToAtomicNumber = new HashMap();
/**
* Maps element symbol to the priority of that atom in Hantzch-Widman system. A higher value indicates a higher priority.
*/
static final Map elementToHwPriority = new HashMap();
static{
elementToPaulingElectronegativity.put("H", 2.20);
elementToPaulingElectronegativity.put("Li", 0.98);
elementToPaulingElectronegativity.put("Be", 1.57);
elementToPaulingElectronegativity.put("B", 2.04);
elementToPaulingElectronegativity.put("C", 2.55);
elementToPaulingElectronegativity.put("N", 3.04);
elementToPaulingElectronegativity.put("O", 3.44);
elementToPaulingElectronegativity.put("F", 3.98);
elementToPaulingElectronegativity.put("Na", 0.93);
elementToPaulingElectronegativity.put("Mg", 1.31);
elementToPaulingElectronegativity.put("Al", 1.61);
elementToPaulingElectronegativity.put("Si", 1.90);
elementToPaulingElectronegativity.put("P", 2.19);
elementToPaulingElectronegativity.put("S", 2.58);
elementToPaulingElectronegativity.put("Cl", 3.16);
elementToPaulingElectronegativity.put("K", 0.82);
elementToPaulingElectronegativity.put("Ca", 1.00);
elementToPaulingElectronegativity.put("Sc", 1.36);
elementToPaulingElectronegativity.put("Ti", 1.54);
elementToPaulingElectronegativity.put("V", 1.63);
elementToPaulingElectronegativity.put("Cr", 1.66);
elementToPaulingElectronegativity.put("Mn", 1.55);
elementToPaulingElectronegativity.put("Fe", 1.83);
elementToPaulingElectronegativity.put("Co", 1.88);
elementToPaulingElectronegativity.put("Ni", 1.91);
elementToPaulingElectronegativity.put("Cu", 1.90);
elementToPaulingElectronegativity.put("Zn", 1.65);
elementToPaulingElectronegativity.put("Ga", 1.81);
elementToPaulingElectronegativity.put("Ge", 2.01);
elementToPaulingElectronegativity.put("As", 2.18);
elementToPaulingElectronegativity.put("Se", 2.55);
elementToPaulingElectronegativity.put("Br", 2.96);
elementToPaulingElectronegativity.put("Kr", 3.00);
elementToPaulingElectronegativity.put("Rb", 0.82);
elementToPaulingElectronegativity.put("Sr", 0.95);
elementToPaulingElectronegativity.put("Y", 1.22);
elementToPaulingElectronegativity.put("Zr", 1.33);
elementToPaulingElectronegativity.put("Nb", 1.6);
elementToPaulingElectronegativity.put("Mo", 2.16);
elementToPaulingElectronegativity.put("Tc", 1.9);
elementToPaulingElectronegativity.put("Ru", 2.2);
elementToPaulingElectronegativity.put("Rh", 2.28);
elementToPaulingElectronegativity.put("Pd", 2.20);
elementToPaulingElectronegativity.put("Ag", 1.93);
elementToPaulingElectronegativity.put("Cd", 1.69);
elementToPaulingElectronegativity.put("In", 1.78);
elementToPaulingElectronegativity.put("Sn", 1.96);
elementToPaulingElectronegativity.put("Sb", 2.05);
elementToPaulingElectronegativity.put("Te", 2.1);
elementToPaulingElectronegativity.put("I", 2.66);
elementToPaulingElectronegativity.put("Xe", 2.60);
elementToPaulingElectronegativity.put("Cs", 0.79);
elementToPaulingElectronegativity.put("Ba", 0.89);
elementToPaulingElectronegativity.put("La", 1.1);
elementToPaulingElectronegativity.put("Ce", 1.12);
elementToPaulingElectronegativity.put("Pr", 1.13);
elementToPaulingElectronegativity.put("Nd", 1.14);
elementToPaulingElectronegativity.put("Pm", 1.13);
elementToPaulingElectronegativity.put("Sm", 1.17);
elementToPaulingElectronegativity.put("Eu", 1.2);
elementToPaulingElectronegativity.put("Gd", 1.2);
elementToPaulingElectronegativity.put("Tb", 1.1);
elementToPaulingElectronegativity.put("Dy", 1.22);
elementToPaulingElectronegativity.put("Ho", 1.23);
elementToPaulingElectronegativity.put("Er", 1.24);
elementToPaulingElectronegativity.put("Tm", 1.25);
elementToPaulingElectronegativity.put("Yb", 1.1);
elementToPaulingElectronegativity.put("Lu", 1.27);
elementToPaulingElectronegativity.put("Hf", 1.3);
elementToPaulingElectronegativity.put("Ta", 1.5);
elementToPaulingElectronegativity.put("W", 2.36);
elementToPaulingElectronegativity.put("Re", 1.9);
elementToPaulingElectronegativity.put("Os", 2.2);
elementToPaulingElectronegativity.put("Ir", 2.20);
elementToPaulingElectronegativity.put("Pt", 2.28);
elementToPaulingElectronegativity.put("Au", 2.54);
elementToPaulingElectronegativity.put("Hg", 2.00);
elementToPaulingElectronegativity.put("Tl", 1.62);
elementToPaulingElectronegativity.put("Pb", 2.33);
elementToPaulingElectronegativity.put("Bi", 2.02);
elementToPaulingElectronegativity.put("Po", 2.0);
elementToPaulingElectronegativity.put("At", 2.2);
elementToPaulingElectronegativity.put("Rn", 2.2);
elementToPaulingElectronegativity.put("Fr", 0.7);
elementToPaulingElectronegativity.put("Ra", 0.9);
elementToPaulingElectronegativity.put("Ac", 1.1);
elementToPaulingElectronegativity.put("Th", 1.3);
elementToPaulingElectronegativity.put("Pa", 1.5);
elementToPaulingElectronegativity.put("U", 1.38);
elementToPaulingElectronegativity.put("Np", 1.36);
elementToPaulingElectronegativity.put("Pu", 1.28);
elementToPaulingElectronegativity.put("Am", 1.13);
elementToPaulingElectronegativity.put("Cm", 1.28);
elementToPaulingElectronegativity.put("Bk", 1.3);
elementToPaulingElectronegativity.put("Cf", 1.3);
elementToPaulingElectronegativity.put("Es", 1.3);
elementToPaulingElectronegativity.put("Fm", 1.3);
elementToPaulingElectronegativity.put("Md", 1.3);
elementToPaulingElectronegativity.put("No", 1.3);
elementToPaulingElectronegativity.put("Lr", 1.3);
elementToAtomicNumber.put("H", 1);
elementToAtomicNumber.put("He", 2);
elementToAtomicNumber.put("Li", 3);
elementToAtomicNumber.put("Be", 4);
elementToAtomicNumber.put("B", 5);
elementToAtomicNumber.put("C", 6);
elementToAtomicNumber.put("N", 7);
elementToAtomicNumber.put("O", 8);
elementToAtomicNumber.put("F", 9);
elementToAtomicNumber.put("Ne", 10);
elementToAtomicNumber.put("Na", 11);
elementToAtomicNumber.put("Mg", 12);
elementToAtomicNumber.put("Al", 13);
elementToAtomicNumber.put("Si", 14);
elementToAtomicNumber.put("P", 15);
elementToAtomicNumber.put("S", 16);
elementToAtomicNumber.put("Cl", 17);
elementToAtomicNumber.put("Ar", 18);
elementToAtomicNumber.put("K", 19);
elementToAtomicNumber.put("Ca", 20);
elementToAtomicNumber.put("Sc", 21);
elementToAtomicNumber.put("Ti", 22);
elementToAtomicNumber.put("V", 23);
elementToAtomicNumber.put("Cr", 24);
elementToAtomicNumber.put("Mn", 25);
elementToAtomicNumber.put("Fe", 26);
elementToAtomicNumber.put("Co", 27);
elementToAtomicNumber.put("Ni", 28);
elementToAtomicNumber.put("Cu", 29);
elementToAtomicNumber.put("Zn", 30);
elementToAtomicNumber.put("Ga", 31);
elementToAtomicNumber.put("Ge", 32);
elementToAtomicNumber.put("As", 33);
elementToAtomicNumber.put("Se", 34);
elementToAtomicNumber.put("Br", 35);
elementToAtomicNumber.put("Kr", 36);
elementToAtomicNumber.put("Rb", 37);
elementToAtomicNumber.put("Sr", 38);
elementToAtomicNumber.put("Y", 39);
elementToAtomicNumber.put("Zr", 40);
elementToAtomicNumber.put("Nb", 41);
elementToAtomicNumber.put("Mo", 42);
elementToAtomicNumber.put("Tc", 43);
elementToAtomicNumber.put("Ru", 44);
elementToAtomicNumber.put("Rh", 45);
elementToAtomicNumber.put("Pd", 46);
elementToAtomicNumber.put("Ag", 47);
elementToAtomicNumber.put("Cd", 48);
elementToAtomicNumber.put("In", 49);
elementToAtomicNumber.put("Sn", 50);
elementToAtomicNumber.put("Sb", 51);
elementToAtomicNumber.put("Te", 52);
elementToAtomicNumber.put("I", 53);
elementToAtomicNumber.put("Xe", 54);
elementToAtomicNumber.put("Cs", 55);
elementToAtomicNumber.put("Ba", 56);
elementToAtomicNumber.put("La", 57);
elementToAtomicNumber.put("Ce", 58);
elementToAtomicNumber.put("Pr", 59);
elementToAtomicNumber.put("Nd", 60);
elementToAtomicNumber.put("Pm", 61);
elementToAtomicNumber.put("Sm", 62);
elementToAtomicNumber.put("Eu", 63);
elementToAtomicNumber.put("Gd", 64);
elementToAtomicNumber.put("Tb", 65);
elementToAtomicNumber.put("Dy", 66);
elementToAtomicNumber.put("Ho", 67);
elementToAtomicNumber.put("Er", 68);
elementToAtomicNumber.put("Tm", 69);
elementToAtomicNumber.put("Yb", 70);
elementToAtomicNumber.put("Lu", 71);
elementToAtomicNumber.put("Hf", 72);
elementToAtomicNumber.put("Ta", 73);
elementToAtomicNumber.put("W", 74);
elementToAtomicNumber.put("Re", 75);
elementToAtomicNumber.put("Os", 76);
elementToAtomicNumber.put("Ir", 77);
elementToAtomicNumber.put("Pt", 78);
elementToAtomicNumber.put("Au", 79);
elementToAtomicNumber.put("Hg", 80);
elementToAtomicNumber.put("Tl", 81);
elementToAtomicNumber.put("Pb", 82);
elementToAtomicNumber.put("Bi", 83);
elementToAtomicNumber.put("Po", 84);
elementToAtomicNumber.put("At", 85);
elementToAtomicNumber.put("Rn", 86);
elementToAtomicNumber.put("Fr", 87);
elementToAtomicNumber.put("Ra", 88);
elementToAtomicNumber.put("Ac", 89);
elementToAtomicNumber.put("Th", 90);
elementToAtomicNumber.put("Pa", 91);
elementToAtomicNumber.put("U", 92);
elementToAtomicNumber.put("Np", 93);
elementToAtomicNumber.put("Pu", 94);
elementToAtomicNumber.put("Am", 95);
elementToAtomicNumber.put("Cm", 96);
elementToAtomicNumber.put("Bk", 97);
elementToAtomicNumber.put("Cf", 98);
elementToAtomicNumber.put("Es", 99);
elementToAtomicNumber.put("Fm", 100);
elementToAtomicNumber.put("Md", 101);
elementToAtomicNumber.put("No", 102);
elementToAtomicNumber.put("Lr", 103);
elementToAtomicNumber.put("Rf", 104);
elementToAtomicNumber.put("Db", 105);
elementToAtomicNumber.put("Sg", 106);
elementToAtomicNumber.put("Bh", 107);
elementToAtomicNumber.put("Hs", 108);
elementToAtomicNumber.put("Mt", 109);
elementToAtomicNumber.put("Ds", 110);
elementToHwPriority.put("F", 23);
elementToHwPriority.put("Cl", 22);
elementToHwPriority.put("Br", 21);
elementToHwPriority.put("I", 20);
elementToHwPriority.put("O", 19);
elementToHwPriority.put("S", 18);
elementToHwPriority.put("Se", 17);
elementToHwPriority.put("Te", 16);
elementToHwPriority.put("N", 15);
elementToHwPriority.put("P", 14);
elementToHwPriority.put("As", 13);
elementToHwPriority.put("Sb", 12);
elementToHwPriority.put("Bi", 11);
elementToHwPriority.put("Si", 10);
elementToHwPriority.put("Ge", 9);
elementToHwPriority.put("Sn", 8);
elementToHwPriority.put("Pb", 7);
elementToHwPriority.put("B", 6);
elementToHwPriority.put("Al", 5);
elementToHwPriority.put("Ga", 4);
elementToHwPriority.put("In", 3);
elementToHwPriority.put("Tl", 2);
elementToHwPriority.put("Hg", 1);
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011216 L ustar 0000000 0000000 dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/AutomatonInitialiser.java dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/AutomatonInitialiser.jav0000644 0000000 0000000 00000011137 12172764765 031252 0 ustar 0000000 0000000 package uk.ac.cam.ch.wwmm.opsin;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import org.apache.commons.io.IOUtils;
import org.apache.log4j.Logger;
import dk.brics.automaton.Automaton;
import dk.brics.automaton.RegExp;
import dk.brics.automaton.RunAutomaton;
import dk.brics.automaton.SpecialOperations;
/**
* Handles storing and retrieving automata to/from files
* This is highly useful to do as building these deterministic automata from scratch can take minutes
* @author dl387
*
*/
class AutomatonInitialiser {
private static final Logger LOG = Logger.getLogger(AutomatonInitialiser.class);
private static final ResourceGetter resourceGetter = new ResourceGetter("uk/ac/cam/ch/wwmm/opsin/resources/serialisedAutomata/");
/**
* In preference serialised automata and their hashes will be looked for in the resource folder in your working directory
* If it cannot be found there then these files will be looked for in the standard resource folder
* (this is actually the standard behaviour of the resourceGetter but I'm reiterating it here as if the stored hash doesn't match
* the current hash then the creation of an updated serialised automaton and hash will occur in the working directory resource folder as the standard
* resource folder will not typically be writable)
* @param automatonName : A name for the automaton so that it can it can be saved/loaded from disk
* @param regex : the regex from which to build the RunAutomaton
* @param reverseAutomaton : should the automaton be reversed
* @param tableize: if true, a transition table is created which makes the run method faster in return of a higher memory usage (adds ~256kb)
* @return A RunAutomaton, may have been built from scratch or loaded from a file
*/
static RunAutomaton loadAutomaton(String automatonName, String regex, boolean tableize, boolean reverseAutomaton) {
if (reverseAutomaton){
automatonName+="_reversed_";
}
try{
if (isAutomatonCached(automatonName, regex)) {
return loadCachedAutomaton(automatonName);
}
}
catch (IOException e) {
LOG.warn("Error loading cached automaton: "+automatonName, e);
}
RunAutomaton automaton = createAutomaton(regex, tableize, reverseAutomaton);
cacheAutomaton(automatonName, automaton, regex);
return automaton;
}
private static boolean isAutomatonCached(String automatonName, String regex) {
String currentRegexHash = getRegexHash(regex);
String cachedRegexHash = getCachedRegexHash(automatonName);
return currentRegexHash.equals(cachedRegexHash);
}
private static String getRegexHash(String regex) {
return Integer.toString(regex.hashCode());
}
private static String getCachedRegexHash(String automatonName) {
/*This file contains the hashcode of the regex which was used to generate the automaton on the disk */
return resourceGetter.getFileContentsAsString(automatonName + "RegexHash.txt");
}
private static RunAutomaton loadCachedAutomaton(String automatonName) throws IOException{
InputStream automatonInput = resourceGetter.getInputstreamFromFileName(automatonName +"SerialisedAutomaton.aut");
try {
return RunAutomaton.load(automatonInput);
} catch (Exception e) {
IOException ioe = new IOException("Error loading automaton");
ioe.initCause(e);
throw ioe;
} finally {
IOUtils.closeQuietly(automatonInput);
}
}
private static RunAutomaton createAutomaton(String regex, boolean tableize, boolean reverseAutomaton) {
Automaton a = new RegExp(regex).toAutomaton();
if (reverseAutomaton){
SpecialOperations.reverse(a);
}
RunAutomaton ra = new RunAutomaton(a, tableize);
return ra;
}
private static void cacheAutomaton(String automatonName, RunAutomaton automaton, String regex) {
OutputStream regexHashOutputStream = null;
OutputStream automatonOutputStream = null;
try {
regexHashOutputStream = resourceGetter.getOutputStream(automatonName + "RegexHash.txt");
try {
regexHashOutputStream.write(getRegexHash(regex).getBytes("UTF-8"));
} catch (UnsupportedEncodingException e) {
throw new RuntimeException("Java VM is broken; UTF-8 should be supported", e);
}
automatonOutputStream = resourceGetter.getOutputStream(automatonName + "SerialisedAutomaton.aut");
automaton.store(automatonOutputStream);
} catch (IOException e) {
LOG.warn("Error serialising automaton: "+automatonName, e);
}
finally{
IOUtils.closeQuietly(regexHashOutputStream);
IOUtils.closeQuietly(automatonOutputStream);
}
}
}
dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/Bond.java 0000644 0000000 0000000 00000007544 12172764765 026140 0 ustar 0000000 0000000 package uk.ac.cam.ch.wwmm.opsin;
import java.util.ArrayList;
import java.util.List;
import uk.ac.cam.ch.wwmm.opsin.BondStereo.BondStereoValue;
import nu.xom.Attribute;
import nu.xom.Element;
/**A bond, between two atoms.
*
* @author ptc24
* @author dl387
*
*/
class Bond {
/** The Atom the bond comes from */
private final Atom from;
/** The Atom the bond goes to */
private final Atom to;
/** The bond order */
private int order;
static enum SMILES_BOND_DIRECTION{
RSLASH,
LSLASH
}
/** If this bond was built from SMILES can be set to either RSLASH or LSLASH. Subsequently read to add a bondStereoElement
* null by default*/
private SMILES_BOND_DIRECTION smilesBondDirection = null;
/**
* Holds the bondStereo object associated with this bond
* null by default
*/
private BondStereo bondStereo= null;
/**
* If the bond is a fusion bond this will in the fused ring numberer be populated with the rings that it connects
*/
private final List fusedRings = new ArrayList(2);
/** DO NOT CALL DIRECTLY EXCEPT FOR TESTING
* Creates a new Bond.
*
* @param from The Atom the bond comes from.
* @param to The Atom the bond goes to.
* @param order The bond order.
*/
Bond(Atom from, Atom to, int order) {
this.from = from;
this.to = to;
this.order = order;
}
List getFusedRings() {
return fusedRings;
}
void addFusedRing(Ring ring) {
if (fusedRings.size()<2) {
fusedRings.add(ring);
}
}
/**Produces a nu.xom.Element corresponding to a CML bond tag.
* Has attributes of atomRefs2 and order.
*
* @return The CML element.
*/
Element toCMLBond() {
Element elem = new Element("bond", XmlDeclarations.CML_NAMESPACE);
elem.addAttribute(new Attribute("id", "a" + Integer.toString(from.getID())
+ "_a" + Integer.toString(to.getID())));
elem.addAttribute(new Attribute("atomRefs2", "a" + Integer.toString(from.getID())
+ " a" + Integer.toString(to.getID())));
if (order==1){
elem.addAttribute(new Attribute("order", "S"));
}
else if (order==2){
elem.addAttribute(new Attribute("order", "D"));
}
else if (order==3){
elem.addAttribute(new Attribute("order", "T"));
}
else{
elem.addAttribute(new Attribute("order", "unknown"));
}
if (bondStereo!=null){
elem.appendChild(bondStereo.toCML());
}
return elem;
}
/**
* Gets from ID
* @return ID
*/
int getFrom() {
return from.getID();
}
/**
* Gets to ID
* @return ID
*/
int getTo() {
return to.getID();
}
/**Gets order.
* @return*/
int getOrder() {
return order;
}
/**Sets order.
* @param order*/
void setOrder(int order) {
this.order = order;
}
/**
* Gets from Atom
* @return Atom
*/
Atom getFromAtom() {
return from;
}
/**
* Gets to Atom
* @return Atom
*/
Atom getToAtom() {
return to;
}
/**Adds to the bond order.
*
* @param o The value to be added to the bond order.
*/
void addOrder(int o) {
order += o;
}
/**
* Returns either null or RSLASH or LSLASH
* @return
*/
SMILES_BOND_DIRECTION getSmilesStereochemistry() {
return smilesBondDirection;
}
void setSmilesStereochemistry(SMILES_BOND_DIRECTION bondDirection) {
this.smilesBondDirection = bondDirection;
}
BondStereo getBondStereo() {
return bondStereo;
}
void setBondStereo(BondStereo bondStereo) {
this.bondStereo = bondStereo;
}
void setBondStereoElement(Atom[] atomRefs4, BondStereoValue cOrT) {
bondStereo = new BondStereo(atomRefs4, cOrT);
}
/**
* Returns the atom at the other end of the bond to given atom
* @param atom
* @return
*/
Atom getOtherAtom(Atom atom) {
if (from ==atom){
return to;
}
else if (to ==atom){
return from;
}
else{
return null;
}
}
}
dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/BondStereo.java 0000644 0000000 0000000 00000004237 12172764765 027316 0 ustar 0000000 0000000 package uk.ac.cam.ch.wwmm.opsin;
import nu.xom.Attribute;
import nu.xom.Element;
/**
* Holds information about the positions of 2 atoms relative to a double bond allowing the specification of cis/trans stereochemistry
* @author dl387
*
*/
class BondStereo {
private Atom[] atomRefs4;
private BondStereoValue bondStereoValue;
/**
* Possible values for a bondStereo element
* @author dl387
*
*/
enum BondStereoValue{
CIS("C"),
TRANS("T");
private final String value;
BondStereoValue(String value){
this.value = value;
}
@Override
public String toString() {
return value;
}
}
/**
* Create a bondStereo from an array of 4 atoms. The 2nd and 3rd atoms of this array are connected via a double bond.
* The 1st and 4th atoms are at either end of this bond and indication is given as to whether they are cis or trans to each other.
* @param atomRefs4
* @param cOrT
*/
BondStereo(Atom[] atomRefs4, BondStereoValue cOrT) {
if (atomRefs4.length !=4){
throw new IllegalArgumentException("atomRefs4 must contain references to 4 atoms");
}
this.atomRefs4 = atomRefs4;
this.bondStereoValue = cOrT;
}
/**
* Serialises this object to CML
* @return
*/
Element toCML() {
Element bondStereoElement = new Element(XmlDeclarations.CML_BONDSTEREO_EL, XmlDeclarations.CML_NAMESPACE);
StringBuilder atomRefsSb = new StringBuilder();
for(int i=0; i outAtoms;
/**The atoms that may be used to from things like esters*/
private final LinkedList functionalAtoms;
/**A list of fragments that have been evaluated to form this BuildResults. They are in the order they would be found in the XML*/
private final LinkedHashSet fragments;
/**A BuildResults is constructed from a list of Fragments.
* This constructor creates this list from the groups present in an XML word/bracket/sub element.
* @param state
* @param wordSubOrBracket*/
BuildResults(BuildState state, Element wordSubOrBracket) {
outAtoms = new LinkedList();
functionalAtoms = new LinkedList();
fragments = new LinkedHashSet();
List groups = XOMTools.getDescendantElementsWithTagName(wordSubOrBracket, XmlDeclarations.GROUP_EL);
for (Element group : groups) {
Fragment frag = state.xmlFragmentMap.get(group);
fragments.add(frag);
for (int i = 0, l = frag.getOutAtomCount(); i < l; i++) {
outAtoms.add(frag.getOutAtom(i));
}
int functionalAtomCount = frag.getFunctionalAtomCount();
if (functionalAtomCount > 0){
Element parent = (Element) group.getParent();
if (parent.getLocalName().equals(XmlDeclarations.ROOT_EL) ||
OpsinTools.getNextGroup(group) == null){
for (int i = 0, l = functionalAtomCount; i < l; i++) {
functionalAtoms.add(frag.getFunctionalAtom(i));
}
}
}
}
}
/**
* Construct a blank buildResults
*/
BuildResults() {
outAtoms = new LinkedList();
functionalAtoms = new LinkedList();
fragments = new LinkedHashSet();
}
/**
* Returns a read only view of the fragments in this BuildResults
* @return
*/
Set getFragments(){
return Collections.unmodifiableSet(fragments);
}
int getFragmentCount(){
return fragments.size();
}
/**
* Returns the atom corresponding to position i in the outAtoms list
* If not set explicitly and atom would violate valency or break aromaticity another is looked for
* @param i index
* @return atom
* @throws StructureBuildingException
*/
Atom getOutAtomTakingIntoAccountWhetherSetExplicitly(int i) throws StructureBuildingException {
OutAtom outAtom = outAtoms.get(i);
if (outAtom.isSetExplicitly()){
return outAtom.getAtom();
}
else{
return outAtom.getAtom().getFrag().getAtomOrNextSuitableAtomOrThrow(outAtom.getAtom(), outAtom.getValency(), false);
}
}
OutAtom getOutAtom(int i){
return outAtoms.get(i);
}
int getOutAtomCount(){
return outAtoms.size();
}
OutAtom removeOutAtom(int i) {
OutAtom outAtom =outAtoms.get(i);
outAtom.getAtom().getFrag().removeOutAtom(outAtom);
return outAtoms.remove(i);
}
void removeAllOutAtoms() {
for (int i = outAtoms.size() -1; i >=0 ; i--) {
removeOutAtom(i);
}
}
/**
* Returns the atom corresponding to position i in the functionalAtoms list
* @param i index
* @return atom
*/
Atom getFunctionalAtom(int i){
return functionalAtoms.get(i).getAtom();
}
FunctionalAtom removeFunctionalAtom(int i) {
FunctionalAtom functionalAtom =functionalAtoms.get(i);
functionalAtom.getAtom().getFrag().removeFunctionalAtom(functionalAtom);
return functionalAtoms.remove(i);
}
int getFunctionalAtomCount(){
return functionalAtoms.size();
}
/**
* Returns the first OutAtom
* @return OutAtom
*/
OutAtom getFirstOutAtom(){
return outAtoms.get(0);
}
/**
* Returns the atom corresponding to the given id assuming the atom the id corresponds to is within the list of fragment in this Buildresults
* @param id index
* @return atom
* @throws StructureBuildingException
*/
Atom getAtomByIdOrThrow(int id) throws StructureBuildingException {
for (Fragment fragment : fragments) {
Atom outAtom =fragment.getAtomByID(id);
if (outAtom!=null){
return outAtom;
}
}
throw new StructureBuildingException("No fragment contained this id: " + id);
}
void mergeBuildResults(BuildResults otherBR) {
outAtoms.addAll(otherBR.outAtoms);
functionalAtoms.addAll(otherBR.functionalAtoms);
fragments.addAll(otherBR.fragments);
}
/**
* Returns the sum of the charges of the fragments in the buildResults
* @return
*/
int getCharge() {
int totalCharge=0;
for (Fragment frag : fragments) {
totalCharge+=frag.getCharge();
}
return totalCharge;
}
}
dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/BuildState.java 0000644 0000000 0000000 00000005556 12172764765 027317 0 ustar 0000000 0000000 package uk.ac.cam.ch.wwmm.opsin;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import nu.xom.Element;
/**
* Used to pass the current mode, IDManager, FragmentManager and wordRule around as well as a mapping between the XML and fragments
*
* @author dl387
*
*/
class BuildState {
final IDManager idManager;
final FragmentManager fragManager;
final BiDirectionalHashMap xmlFragmentMap;
final HashMap> xmlSuffixMap;
final NameToStructureConfig n2sConfig;
WordRule currentWordRule = null;
private String warningMessage = null;
String getWarningMessage() {
return warningMessage;
}
void addWarningMessage(String warningMessage) {
if (warningMessage == null){
this.warningMessage = warningMessage;
}
else{
this.warningMessage += ("\n" + warningMessage);
}
}
/**
* Wrapper class for returning multiple objects
*/
final static class BiDirectionalHashMap implements Map{
final HashMap xmlFragmentMap = new HashMap();
final HashMap fragmentXmlMap = new HashMap();
public void clear() {
xmlFragmentMap.clear();
fragmentXmlMap.clear();
}
public boolean containsKey(Object key) {
return xmlFragmentMap.containsKey(key);
}
public boolean containsValue(Object value) {
return xmlFragmentMap.containsValue(value);
}
public Set> entrySet() {
return xmlFragmentMap.entrySet();
}
public Fragment get(Object key) {
return xmlFragmentMap.get(key);
}
public boolean isEmpty() {
return xmlFragmentMap.isEmpty();
}
public Set keySet() {
return xmlFragmentMap.keySet();
}
public Fragment put(Element key, Fragment value) {
fragmentXmlMap.put(value, key);
return xmlFragmentMap.put(key, value);
}
public void putAll(Map m) {
for (Entry e : m.entrySet()) {
fragmentXmlMap.put(e.getValue(), e.getKey());
}
xmlFragmentMap.putAll(m);
}
public Fragment remove(Object key) {
Fragment f =xmlFragmentMap.remove(key);
fragmentXmlMap.remove(f);
return f;
}
public int size() {
return xmlFragmentMap.size();
}
public Collection values() {
return xmlFragmentMap.values();
}
public Element getElement(Fragment key) {
return fragmentXmlMap.get(key);
}
}
BuildState(NameToStructureConfig n2sConfig, SMILESFragmentBuilder sBuilder) {
this.n2sConfig = n2sConfig;
idManager = new IDManager();
fragManager = new FragmentManager(sBuilder, idManager);
xmlFragmentMap = new BiDirectionalHashMap();
xmlSuffixMap = new HashMap>();
}
}
dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/CASTools.java 0000644 0000000 0000000 00000023565 12172764765 026706 0 ustar 0000000 0000000 package uk.ac.cam.ch.wwmm.opsin;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static uk.ac.cam.ch.wwmm.opsin.OpsinTools.*;
/**
* Tools for converting CAS nomenclature into IUPAC nomenclature.
* @author dl387
*/
class CASTools {
private static final Pattern matchCasCollectiveIndex = Pattern.compile("([\\[\\(\\{]([1-9][0-9]?[cC][iI][, ]?)+[\\]\\)\\}])+|[1-9][0-9]?[cC][iI]", Pattern.CASE_INSENSITIVE);
private static final Pattern matchAcid = Pattern.compile("acid[\\]\\)\\}]*", Pattern.CASE_INSENSITIVE);
private static final Pattern matchCommaSpace = Pattern.compile(", ");
private static final Pattern matchCompoundWithPhrase = Pattern.compile("(compd\\. with|compound with|and) ", Pattern.CASE_INSENSITIVE);
private static final Pattern matchFunctionalTermAllowingSubstituentPrefix = Pattern.compile("(amide|hydrazide|(thi|selen|tellur)?oxime|hydrazone|(iso)?(semicarbazone|thiosemicarbazone|selenosemicarbazone|tellurosemicarbazone)|imide|imine|semioxamazone)[\\]\\)\\}]*", Pattern.CASE_INSENSITIVE);
/**
* Inverts a CAS name.
* Throws an exception is OPSIN is unable to determine whether something is a substituent or functional term
* or if something unexpected in a CAS name is encountered
* @param name
* @return
* @throws ParsingException
*/
static String uninvertCASName(String name, ParseRules parseRules) throws ParsingException {
List nameComponents = new ArrayList(Arrays.asList(matchCommaSpace.split(name)));
List substituents = new ArrayList();
List seperateWordSubstituents = new ArrayList();
List functionalTerms = new ArrayList();
String parent = nameComponents.get(0);
String[] parentNameParts = MATCH_SPACE.split(parent);
if (parentNameParts.length != 1) {
if (matchCasCollectiveIndex.matcher(parentNameParts[parentNameParts.length - 1]).matches()) {//CAS collective index description should be ignored
StringBuilder parentSB = new StringBuilder();
for (int i = 0; i < parentNameParts.length - 1; i++) {
parentSB.append(parentNameParts[i]);
}
parent = parentSB.toString();
parentNameParts = MATCH_SPACE.split(parent);
}
for (int i = 1; i < parentNameParts.length; i++) {
if (!matchAcid.matcher(parentNameParts[i]).matches()) {
ParseRulesResults results = parseRules.getParses(parentNameParts[i]);
List parseTokens = results.getParseTokensList();
if (parseTokens.isEmpty()) {
throw new ParsingException("Invalid CAS name. Parent compound was followed by an unexpected term");
}
}
}
}
boolean addedBracket = false;
boolean esterEncountered = false;
for (int i = 1; i < nameComponents.size(); i++) {
String nameComponent = nameComponents.get(i);
Matcher m = matchCompoundWithPhrase.matcher(nameComponent);
boolean compoundWithcomponent = false;
if (m.lookingAt()) {
nameComponent = nameComponent.substring(m.group().length());
compoundWithcomponent = true;
}
String[] components = MATCH_SPACE.split(nameComponents.get(i));
for (String component : components) {
if (compoundWithcomponent) {
functionalTerms.add(component);
continue;
}
if (component.endsWith("-")) {
Character missingCloseBracket = missingCloseBracketCharIfApplicable(component);
if (missingCloseBracket !=null) {
if (addedBracket) {
throw new ParsingException("Close bracket appears to be missing");
}
parent += missingCloseBracket;
addedBracket = true;
}
substituents.add(component);
} else {
ParseRulesResults results = parseRules.getParses(component);
List parseTokens = results.getParseTokensList();
if (parseTokens.size() > 0) {
List parseWords = WordTools.splitIntoParseWords(parseTokens, component);
List firstParseWordTokens = parseWords.get(0).getParseTokens();
WordType firstWordType = OpsinTools.determineWordType(firstParseWordTokens.get(0).getAnnotations());
for (int j = 1; j < firstParseWordTokens.size(); j++) {
if (!firstWordType.equals(OpsinTools.determineWordType(firstParseWordTokens.get(j).getAnnotations()))) {
throw new ParsingException(component + "can be interpreted in multiple ways. For the sake of precision OPSIN has decided not to process this as a CAS name");
}
}
if (parseWords.size() ==1){
if (firstWordType.equals(WordType.functionalTerm)) {
if (component.equalsIgnoreCase("ester")) {
if (seperateWordSubstituents.size() ==0){
throw new ParsingException("ester encountered but no substituents were specified in potential CAS name!");
}
if (esterEncountered) {
throw new ParsingException("ester formation was mentioned more than once in CAS name!");
}
parent = uninvertEster(parent);
esterEncountered = true;
} else {
functionalTerms.add(component);
}
} else if (firstWordType.equals(WordType.substituent)) {
seperateWordSubstituents.add(component);
} else if (firstWordType.equals(WordType.full)) {
if (StringTools.endsWithCaseInsensitive(component, "ate") || StringTools.endsWithCaseInsensitive(component, "ite")//e.g. Piperazinium, 1,1-dimethyl-, 2,2,2-trifluoroacetate hydrochloride
|| component.equalsIgnoreCase("hydrofluoride") || component.equalsIgnoreCase("hydrochloride") || component.equalsIgnoreCase("hydrobromide") || component.equalsIgnoreCase("hydroiodide")) {
functionalTerms.add(component);
} else {
throw new ParsingException("Unable to interpret: " + component + " (as part of a CAS index name)- A full word was encountered where a substituent or functionalTerm was expected");
}
}
}
else if (parseWords.size() == 2 && firstWordType.equals(WordType.substituent)) {
//could be something like O-methyloxime which is parsed as [O-methyl] [oxime]
List secondParseWordTokens = parseWords.get(1).getParseTokens();
WordType secondWordType = OpsinTools.determineWordType(secondParseWordTokens.get(0).getAnnotations());
for (int j = 1; j < secondParseWordTokens.size(); j++) {
if (!secondWordType.equals(OpsinTools.determineWordType(secondParseWordTokens.get(j).getAnnotations()))) {
throw new ParsingException(component + "can be interpreted in multiple ways. For the sake of precision OPSIN has decided not to process this as a CAS name");
}
}
if (secondWordType.equals(WordType.functionalTerm) &&
matchFunctionalTermAllowingSubstituentPrefix.matcher(parseWords.get(1).getWord()).matches()){
functionalTerms.add(component);
}
else{
throw new ParsingException("Unrecognised CAS index name form, could have a missing space?");
}
}
else {
throw new ParsingException("Unrecognised CAS index name form");
}
} else {
if (!matchCasCollectiveIndex.matcher(component).matches()) {//CAS collective index description should be ignored
throw new ParsingException("Unable to interpret: " + component + " (as part of a CAS index name)");
}
}
}
}
}
StringBuilder casName = new StringBuilder();
for (String prefixFunctionalTerm : seperateWordSubstituents) {
casName.append(prefixFunctionalTerm);
casName.append(" ");
}
for (String substituent : substituents) {
casName.append(substituent);
}
casName.append(parent);
for (String functionalTerm : functionalTerms) {
casName.append(" ");
casName.append(functionalTerm);
}
return casName.toString();
}
private static Character missingCloseBracketCharIfApplicable(String component) {
char[] characters = component.toCharArray();
int bracketLevel =0;
Character missingCloseBracket =null;
for (int i = 0; i < characters.length; i++) {
char character = characters[i];
if (character == '(' || character == '[' || character == '{') {
bracketLevel++;
if (bracketLevel ==1){
missingCloseBracket = character;
}
}
if (character == ')' || character == ']' || character == '}') {
bracketLevel--;
if (bracketLevel<0){
return null;
}
}
}
if (bracketLevel == 1){
if (missingCloseBracket == '('){
return ')';
}
if (missingCloseBracket == '['){
return ']';
}
if (missingCloseBracket == '{'){
return '}';
}
}
return null;
}
/**
* Modifies the name of the parent acid from ic to ate (or ous to ite)
* hence allowing the formation of the uninverted ester
* @param parent
* @return
* @throws ParsingException
*/
private static String uninvertEster(String parent) throws ParsingException {
int len = parent.length();
if (len == 0) {
throw new ParsingException("Failed to uninvert CAS ester");
}
char lastChar = parent.charAt(len - 1);
if (lastChar == ')') {
if (StringTools.endsWithCaseInsensitive(parent, "ic acid)")) {
parent = parent.substring(0, parent.length() - 8) + "ate)";
} else if (StringTools.endsWithCaseInsensitive(parent, "ous acid)")) {
parent = parent.substring(0, parent.length() - 9) + "ite)";
} else if (StringTools.endsWithCaseInsensitive(parent, "ine)")){//amino acid
parent = parent.substring(0, parent.length() - 2) + "ate)";
}
else{
throw new ParsingException("Failed to uninvert CAS ester");
}
} else {
if (StringTools.endsWithCaseInsensitive(parent, "ic acid")) {
parent = parent.substring(0, parent.length() - 7) + "ate";
} else if (StringTools.endsWithCaseInsensitive(parent, "ous acid")) {
parent = parent.substring(0, parent.length() - 8) + "ite";
} else if (StringTools.endsWithCaseInsensitive(parent, "ine")){//amino acid
parent = parent.substring(0, parent.length() - 1) + "ate";
}
else{
throw new ParsingException("Failed to uninvert CAS ester");
}
}
return parent;
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011216 L ustar 0000000 0000000 dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/CipOrderingException.java dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/CipOrderingException.jav0000644 0000000 0000000 00000001225 12172764765 031167 0 ustar 0000000 0000000 package uk.ac.cam.ch.wwmm.opsin;
/**Thrown if the ordering of ligands can now be determined by OPSIN's implementation of the CIP rules.
* This could be due to a limitation of the implementation or ligands actually being indistinguishable
*
* @author dl387
*
*/
public class CipOrderingException extends RuntimeException {
private static final long serialVersionUID = 1L;
CipOrderingException() {
super();
}
CipOrderingException(String message) {
super(message);
}
CipOrderingException(String message, Throwable cause) {
super(message, cause);
}
CipOrderingException(Throwable cause) {
super(cause);
}
}
dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/CipSequenceRules.java 0000644 0000000 0000000 00000044702 12172764765 030472 0 ustar 0000000 0000000 package uk.ac.cam.ch.wwmm.opsin;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
* An implementation of Rule 1 of the CIP rules i.e. constitutional differences excluding isotopes
* Cases that require rules 2-5 to distinguish result in an exception
*
* Phantom atoms are not added as I believe that the results of the program will still be the same even in their absence as everything beats a phantom and comparing phantoms to phantoms achieves nothing
* (higher ligancy beats lower ligancy when comparisons are performed)
* @author dl387
*
*/
class CipSequenceRules {
private final Atom chiralAtom;
CipSequenceRules(Atom chiralAtom) {
this.chiralAtom = chiralAtom;
}
/**
* Returns the chiral atom's neighbours in CIP order from lowest priority to highest priority
* @return
*/
List getNeighbouringAtomsInCIPOrder() throws CipOrderingException {
List neighbours = chiralAtom.getAtomNeighbours();
Collections.sort(neighbours, new SortByCIPOrder(chiralAtom));
return neighbours;
}
/**
* Returns the chiral atom's neighbours, with the exception of the given atom, in CIP order from lowest priority to highest priority
* @param neighbourToIgnore
* @return
*/
List getNeighbouringAtomsInCIPOrderIgnoringGivenNeighbour(Atom neighbourToIgnore) throws CipOrderingException {
List neighbours = chiralAtom.getAtomNeighbours();
if (!neighbours.remove(neighbourToIgnore)){
throw new IllegalArgumentException("OPSIN bug: " + neighbourToIgnore.toCMLAtom().toXML() +" was not a neighbour of the given stereogenic atom");
}
Collections.sort(neighbours, new SortByCIPOrder(chiralAtom));
return neighbours;
}
/**
* Holds information about what atoms to try next next and how those atoms were reached (to prevent immediate back tracking and to detect cycles)
* @author dl387
*
*/
private static class CipState{
CipState(List nextAtoms1, List nextAtoms2) {
this.nextAtoms1 = nextAtoms1;
this.nextAtoms2 = nextAtoms2;
}
final List nextAtoms1;
final List nextAtoms2;
}
/**
* Holds an atom with associated visited atoms
* @author dl387
*
*/
private static class AtomWithHistory{
AtomWithHistory(Atom atom, List visitedAtoms, Integer indexOfOriginalFromRoot) {
this.atom = atom;
this.visitedAtoms = visitedAtoms;
this.indexOfOriginalFromRoot = indexOfOriginalFromRoot;
}
final Atom atom;
final List visitedAtoms;
final Integer indexOfOriginalFromRoot;
}
/**
* Sorts atoms by their CIP order, low to high
* @author dl387
*
*/
private class SortByCIPOrder implements Comparator {
private final Atom chiralAtom;
private final AtomListCIPComparator atomListCIPComparator = new AtomListCIPComparator();
private final ListOfAtomListsCIPComparator listOfAtomListsCIPComparator = new ListOfAtomListsCIPComparator();
private final CIPComparator cipComparator = new CIPComparator();
private int rule = 0;
SortByCIPOrder(Atom chiralAtom) {
this.chiralAtom = chiralAtom;
}
public int compare(Atom a, Atom b){
/*
* rule = 0 --> Rule 1a Higher atomic number precedes lower
* rule = 1 --> Rule 1b A duplicated atom, with its predecessor node having the same label closer to the root, ranks higher than a duplicated atom, with its predecessor node having the same label farther from the root, which ranks higher than any non-duplicated atom node
* rule = 2 --> Rule 2 Higher atomic mass number precedes lower
*/
for (rule = 0; rule <= 2; rule++) {
List atomsVisted = new ArrayList();
atomsVisted.add(chiralAtom);
AtomWithHistory aWithHistory = new AtomWithHistory(a, atomsVisted, null);
AtomWithHistory bWithHistory = new AtomWithHistory(b, new ArrayList(atomsVisted), null);
int compare = compareByCipRules(aWithHistory, bWithHistory);
if (compare != 0){
return compare;
}
List nextAtoms1 = new ArrayList();
nextAtoms1.add(aWithHistory);
List nextAtoms2 = new ArrayList();
nextAtoms2.add(bWithHistory);
CipState startingState = new CipState(nextAtoms1, nextAtoms2);
Queue cipStateQueue = new LinkedList();
cipStateQueue.add(startingState);
/* Go through CIP states in a breadth-first manner:
* Neighbours of the given atom/s (if multiple atoms this is because so far the two paths leading to them have been equivalent) are evaluated for both a and b
* Neighbours are sorted by CIP priority
* Comparisons performed between neighbours of a and neighbours of b (will break if compare!=0)
* Degenerate neighbours grouped together
* CIP state formed for each list of neighbours and added to queue in order of priority
*
*/
while(!cipStateQueue.isEmpty()){
CipState currentState = cipStateQueue.remove();
compare = compareAtNextLevel(currentState, cipStateQueue);
if (compare != 0){
return compare;
}
}
}
throw new CipOrderingException("Failed to assign CIP stereochemistry, this indicates a bug in OPSIN or a limitation in OPSIN's implementation of the sequence rules");
}
/**
* Compares the neighbours of the atoms specified in nextAtom1/2 in cipstate.
* Returns the result of the comparison between these neighbours
* If the comparison returned 0 adds new cipstates to the queue
* @param cipState
* @param queue
* @return
*/
private int compareAtNextLevel(CipState cipState, Queue queue) {
List>> newNeighbours1 = getNextLevelNeighbours(cipState.nextAtoms1);
List>> newNeighbours2 = getNextLevelNeighbours(cipState.nextAtoms2);
int compare = compareNeighboursByCIPpriorityRules(newNeighbours1, newNeighbours2);
if (compare!=0){
return compare;
}
List>> prioritisedNeighbours1 = formListsWithSamePriority(newNeighbours1);
List>> prioritisedNeighbours2 = formListsWithSamePriority(newNeighbours2);
for (int i = 1; i <= prioritisedNeighbours1.size(); i++) {
List> nextNeighbourLists1 = prioritisedNeighbours1.get(prioritisedNeighbours1.size() -i);
List> nextNeighbourLists2 = prioritisedNeighbours2.get(prioritisedNeighbours2.size() -i);
for (int j = 1; j <= nextNeighbourLists1.size(); j++) {
List nextNeighbours1 = nextNeighbourLists1.get(nextNeighbourLists1.size() -j);
List nextNeighbours2 = nextNeighbourLists2.get(nextNeighbourLists2.size() -j);
CipState newCIPstate = new CipState(nextNeighbours1, nextNeighbours2);
queue.add(newCIPstate);
}
}
return 0;
}
private int compareNeighboursByCIPpriorityRules(List>> neighbours1, List>> neighbours2){
int neighbours1Size = neighbours1.size();
int neighbours2Size = neighbours2.size();
int differenceInSize = neighbours1Size - neighbours2Size;
int maxCommonSize = neighbours1Size > neighbours2Size ? neighbours2Size : neighbours1Size;
for (int i = 1; i <= maxCommonSize; i++) {
int difference = listOfAtomListsCIPComparator.compare(neighbours1.get(neighbours1Size -i), neighbours2.get(neighbours2Size -i));
if (difference >0){
return 1;
}
if (difference < 0){
return -1;
}
}
if (differenceInSize >0){
return 1;
}
if (differenceInSize <0){
return -1;
}
return 0;
}
private List>> getNextLevelNeighbours(List nextAtoms) {
List>> neighbours = getNextAtomsWithAppropriateGhostAtoms(nextAtoms);
for (List> list : neighbours) {
Collections.sort(list, atomListCIPComparator);
}
Collections.sort(neighbours, listOfAtomListsCIPComparator);
return neighbours;
}
/**
* If given say [H,C,C] this becomes [H] [C,C]
* If given say [H,C,C] [H,C,C] this becomes [H,H] [C,C,C,C]
* If given say [H,C,C] [H,C,F] this becomes [H],[C,C][H][C][F]
* as [H,C,F] is higher priority than [H,C,C] so all its atoms must be evaluated first
* The original neighbours list is assumed to have been presorted.
* @param neighbours
*/
private List>> formListsWithSamePriority(List>> neighbours) {
List>> updatedNeighbours = new LinkedList>>();
List> listsToRemove = new ArrayList>();
for (List> neighbourLists : neighbours) {
List> updatedNeighbourLists = new LinkedList>();
for (int i = 0; i < neighbourLists.size(); i++) {
List> neighbourListsToCombine = new ArrayList>();
List primaryAtomList = neighbourLists.get(i);
for (int j = i +1; j < neighbourLists.size(); j++) {
if (atomListCIPComparator.compare(neighbourLists.get(i), neighbourLists.get(j))==0){
neighbourListsToCombine.add(neighbourLists.get(j));
}
}
for (List neighbourList: neighbourListsToCombine) {
listsToRemove.add(neighbourList);
primaryAtomList.addAll(neighbourList);
}
}
for (List list : listsToRemove) {
neighbourLists.remove(list);
}
//lists of same priority have been combined e.g. [H,C,C] [H,C,C] -->[H,C,C,H,C,C]
for (int i = neighbourLists.size()-1; i >=0; i--) {
List neighbourList = neighbourLists.get(i);
Collections.sort(neighbourList, cipComparator);
AtomWithHistory lastAtom = null;
List currentAtomList = new ArrayList();
for (int j = neighbourList.size() -1; j >=0; j--) {
AtomWithHistory a = neighbourList.get(j);
if (lastAtom !=null && compareByCipRules(lastAtom, a) !=0){
if (!currentAtomList.isEmpty()){
updatedNeighbourLists.add(0, currentAtomList);
}
currentAtomList =new ArrayList();
currentAtomList.add(a);
}
else{
currentAtomList.add(a);
}
lastAtom = a;
}
if (!currentAtomList.isEmpty()){
updatedNeighbourLists.add(0, currentAtomList);
}
}
updatedNeighbours.add(updatedNeighbourLists);
}
return updatedNeighbours;
}
/**
* Sorts atoms by their atomic number, low to high
* @author dl387
*
*/
private class CIPComparator implements Comparator {
public int compare(AtomWithHistory a, AtomWithHistory b){
return compareByCipRules(a, b);
}
}
/**
* Sorts atomLists by CIP rules, low to high
* @author dl387
*
*/
private class AtomListCIPComparator implements Comparator> {
public int compare(List a, List b){
int aSize = a.size();
int bSize = b.size();
int differenceInSize = aSize - bSize;
int maxCommonSize = aSize > bSize ? bSize : aSize;
for (int i = 1; i <= maxCommonSize; i++) {
int difference = compareByCipRules(a.get(aSize -i), b.get(bSize -i));
if (difference >0){
return 1;
}
if (difference < 0){
return -1;
}
}
if (differenceInSize >0){
return 1;
}
if (differenceInSize <0){
return -1;
}
return 0;
}
}
/**
* Sorts lists of atomLists by CIP rules, low to high
* @author dl387
*
*/
private class ListOfAtomListsCIPComparator implements Comparator>> {
public int compare(List> a, List> b){
int aSize = a.size();
int bSize = b.size();
int differenceInSize = aSize - bSize;
int maxCommonSize = aSize > bSize ? bSize : aSize;
for (int i = 1; i <= maxCommonSize; i++) {
List aprime = a.get(aSize -i);
List bprime = b.get(bSize -i);
int aprimeSize = aprime.size();
int bprimeSize = bprime.size();
int differenceInSizeprime = aprimeSize - bprimeSize;
int maxCommonSizeprime = aprimeSize > bprimeSize ? bprimeSize : aprimeSize;
for (int j = 1; j <= maxCommonSizeprime; j++) {
int difference = compareByCipRules(aprime.get(aprimeSize -j), bprime.get(bprimeSize -j));
if (difference >0){
return 1;
}
if (difference < 0){
return -1;
}
}
if (differenceInSizeprime >0){
return 1;
}
if (differenceInSizeprime <0){
return -1;
}
}
if (differenceInSize >0){
return 1;
}
if (differenceInSize <0){
return -1;
}
return 0;
}
}
/**
* Gets the neighbouring atoms bar the previous atoms
* If the neighbouring atom has already been visited it is replaced with a ghost atom
* Multiple bonds including those to previous atoms yield ghost atoms unless the bond goes to the chiral atom e.g. in a sulfoxide
* @param atoms
* @return
*/
private List>> getNextAtomsWithAppropriateGhostAtoms(List atoms) {
List>> allNeighbours = new ArrayList>>();
int counter =0;
Atom lastPreviousAtom = null;
for (int i = 0; i < atoms.size(); i++) {
AtomWithHistory atomWithHistory = atoms.get(i);
Atom atom = atomWithHistory.atom;
List visitedAtoms = atomWithHistory.visitedAtoms;
Atom previousAtom = visitedAtoms.get(visitedAtoms.size()-1);
List visitedAtomsIncludingCurrentAtom = new ArrayList(visitedAtoms);
visitedAtomsIncludingCurrentAtom.add(atom);
List neighboursWithHistory = new ArrayList();
for(Bond b : atom.getBonds()) {
Atom atomBondConnectsTo = b.getOtherAtom(atom);
if (!atomBondConnectsTo.equals(chiralAtom)){//P-91.1.4.2.4 (higher order bonds to chiral centre do not involve duplication of atoms)
for (int j = b.getOrder(); j >1; j--) {//add ghost atoms to represent higher order bonds
Atom ghost = new Atom(atomBondConnectsTo.getElement());
if (rule > 0){
int indexOfOriginalAtom = visitedAtoms.indexOf(atomBondConnectsTo);
if (indexOfOriginalAtom != -1){
neighboursWithHistory.add(new AtomWithHistory(ghost, visitedAtomsIncludingCurrentAtom, indexOfOriginalAtom));
}
else{
neighboursWithHistory.add(new AtomWithHistory(ghost, visitedAtomsIncludingCurrentAtom, visitedAtoms.size() + 1));
}
}
else{
neighboursWithHistory.add(new AtomWithHistory(ghost, visitedAtomsIncludingCurrentAtom, null));
}
}
}
if (!atomBondConnectsTo.equals(previousAtom)){
if (visitedAtoms.contains(atomBondConnectsTo)){//cycle detected, add ghost atom instead
Atom ghost = new Atom(atomBondConnectsTo.getElement());
if (rule > 0){
neighboursWithHistory.add(new AtomWithHistory(ghost, visitedAtomsIncludingCurrentAtom, visitedAtoms.indexOf(atomBondConnectsTo)));
}
else{
neighboursWithHistory.add(new AtomWithHistory(ghost, visitedAtomsIncludingCurrentAtom, null));
}
}
else{
neighboursWithHistory.add(new AtomWithHistory(atomBondConnectsTo, visitedAtomsIncludingCurrentAtom, null));
}
}
}
Collections.sort(neighboursWithHistory, cipComparator);
if (lastPreviousAtom==null){
lastPreviousAtom = previousAtom;
}
else if (lastPreviousAtom !=previousAtom){
lastPreviousAtom = previousAtom;
counter++;
}
if (allNeighbours.size() <= counter){
allNeighbours.add(new ArrayList>());
}
allNeighbours.get(counter).add(neighboursWithHistory);
}
return allNeighbours;
}
/**
* Greater than 0 means a is preferred over b (vice versa for less than 1)
* @param a
* @param b
* @return
*/
private int compareByCipRules(AtomWithHistory a, AtomWithHistory b){
//rule 1a
//prefer higher atomic number
int atomicNumber1 = AtomProperties.elementToAtomicNumber.get(a.atom.getElement());
int atomicNumber2 = AtomProperties.elementToAtomicNumber.get(b.atom.getElement());
if (atomicNumber1 > atomicNumber2){
return 1;
}
else if (atomicNumber1 < atomicNumber2){
return -1;
}
if (rule > 0){
//rule 1b
//prefer duplicate to non-duplicate
Integer indexFromRoot1 = a.indexOfOriginalFromRoot;
Integer indexFromRoot2 = b.indexOfOriginalFromRoot;
if (indexFromRoot1 != null && indexFromRoot2 == null){
return 1;
}
if (indexFromRoot1 == null && indexFromRoot2 != null){
return -1;
}
//prefer duplicate of node closer to root
if (indexFromRoot1 != null && indexFromRoot2 != null){
if (indexFromRoot1 < indexFromRoot2 ){
return 1;
}
if (indexFromRoot1 > indexFromRoot2 ){
return -1;
}
}
if (rule > 1){
//rule 2
//prefer higher atomic mass
Integer atomicMass1 = a.atom.getIsotope();
Integer atomicMass2 = b.atom.getIsotope();
if (atomicMass1 != null && atomicMass2 == null){
return 1;
}
else if (atomicMass1 == null && atomicMass2 != null){
return -1;
}
else if (atomicMass1 != null && atomicMass2 != null){
if (atomicMass1 > atomicMass2){
return 1;
}
else if (atomicMass1 < atomicMass2){
return -1;
}
}
}
}
return 0;
}
}
}
././@LongLink 0000000 0000000 0000000 00000000156 00000000000 011217 L ustar 0000000 0000000 dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/ComponentGenerationException.java dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/ComponentGenerationExcep0000644 0000000 0000000 00000001223 12172764765 031265 0 ustar 0000000 0000000 package uk.ac.cam.ch.wwmm.opsin;
/**Thrown during component generation.
*
* @author ptc24
*
*/
class ComponentGenerationException extends Exception {
private static final long serialVersionUID = 1L;
ComponentGenerationException() {
super();
// TODO Auto-generated constructor stub
}
ComponentGenerationException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
ComponentGenerationException(String message, Throwable cause) {
super(message, cause);
// TODO Auto-generated constructor stub
}
ComponentGenerationException(Throwable cause) {
super(cause);
// TODO Auto-generated constructor stub
}
}
dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/ComponentGenerator.java 0000644 0000000 0000000 00000334307 12172764765 031067 0 ustar 0000000 0000000 package uk.ac.cam.ch.wwmm.opsin;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static uk.ac.cam.ch.wwmm.opsin.XmlDeclarations.*;
import static uk.ac.cam.ch.wwmm.opsin.OpsinTools.*;
import nu.xom.Attribute;
import nu.xom.Element;
import nu.xom.Elements;
import nu.xom.Node;
/**Does destructive procedural parsing on parser results.
*
* @author ptc24
* @author dl387
*
*/
class ComponentGenerator {
/**
* Sort bridges such as the highest priority secondary bridges come first
* e.g. 1^(6,3).1^(15,13)
* rearranged to 1^(15,13).1^(6,3)
* @author dl387
*
*/
private static class VonBaeyerSecondaryBridgeSort implements Comparator> {
public int compare(HashMap bridge1, HashMap bridge2){
//first we compare the larger coordinate, due to an earlier potential swapping of coordinates this is always in "AtomId_Larger"
int largerCoordinate1 = bridge1.get("AtomId_Larger");
int largerCoordinate2 = bridge2.get("AtomId_Larger");
if (largerCoordinate1 >largerCoordinate2) {
return -1;
}
else if (largerCoordinate2 >largerCoordinate1) {
return 1;
}
//tie
int smallerCoordinate1 = bridge1.get("AtomId_Smaller");
int smallerCoordinate2 = bridge2.get("AtomId_Smaller");
if (smallerCoordinate1 >smallerCoordinate2) {
return -1;
}
else if (smallerCoordinate2 >smallerCoordinate1) {
return 1;
}
//tie
int bridgelength1 = bridge1.get("Bridge Length");
int bridgelength2 = bridge2.get("Bridge Length");
if (bridgelength1 >bridgelength2) {
return -1;
}
else if (bridgelength2 >bridgelength1) {
return 1;
}
else{
return 0;
}
}
}
//match a fusion bracket with only numerical locants. If this is followed by a HW group it probably wasn't a fusion bracket
private final static Pattern matchNumberLocantsOnlyFusionBracket = Pattern.compile("\\[\\d+(,\\d+)*\\]");
private final static Pattern matchCommaOrDot =Pattern.compile("[\\.,]");
private final static Pattern matchAnnulene = Pattern.compile("[\\[\\(\\{]([1-9]\\d*)[\\]\\)\\}]annulen");
private final static String elementSymbols ="(?:He|Li|Be|B|C|N|O|F|Ne|Na|Mg|Al|Si|P|S|Cl|Ar|K|Ca|Sc|Ti|V|Cr|Mn|Fe|Co|Ni|Cu|Zn|Ga|Ge|As|Se|Br|Kr|Rb|Sr|Y|Zr|Nb|Mo|Tc|Ru|Rh|Pd|Ag|Cd|In|Sn|Sb|Te|I|Xe|Cs|Ba|La|Ce|Pr|Nd|Pm|Sm|Eu|Gd|Tb|Dy|Ho|Er|Tm|Yb|Lu|Hf|Ta|W|Re|Os|Ir|Pt|Au|Hg|Tl|Pb|Po|At|Rn|Fr|Ra|Ac|Th|Pa|U|Np|Pu|Am|Cm|Bk|Cf|Es|Fm|Md|No|Lr|Rf|Db|Sg|Bh|Hs|Mt|Ds)";
private final static Pattern matchStereochemistry = Pattern.compile("(.*?)(SR|RS|[RSEZrsezabx]|[cC][iI][sS]|[tT][rR][aA][nN][sS]|[aA][lL][pP][hH][aA]|[bB][eE][tT][aA]|[xX][iI])");
private final static Pattern matchStar = Pattern.compile("\\^?\\*");
private final static Pattern matchRS = Pattern.compile("[RSrs]");
private final static Pattern matchEZ = Pattern.compile("[EZez]");
private final static Pattern matchAlphaBetaStereochem = Pattern.compile("a|b|x|[aA][lL][pP][hH][aA]|[bB][eE][tT][aA]|[xX][iI]");
private final static Pattern matchCisTrans = Pattern.compile("[cC][iI][sS]|[tT][rR][aA][nN][sS]");
private final static Pattern matchLambdaConvention = Pattern.compile("(\\S+)?lambda\\D*(\\d+)\\D*", Pattern.CASE_INSENSITIVE);
private final static Pattern matchCommaOrDash =Pattern.compile("[,-]");
private final static Pattern matchHdigit =Pattern.compile("H\\d");
private final static Pattern matchDigit =Pattern.compile("\\d+");
private final static Pattern matchNonDigit =Pattern.compile("\\D+");
private final static Pattern matchSuperscriptedLocant = Pattern.compile("(" + elementSymbols +"'*)[\\^\\[\\(\\{~]*(?:[sS][uU][pP][ ]?)?([^\\^\\[\\(\\{~\\]\\)\\}]+)[^\\[\\(\\{]*");
private final static Pattern matchIUPAC2004ElementLocant = Pattern.compile("(\\d+'*)-(" + elementSymbols +"'*)(.*)");
private final static Pattern matchBracketAtEndOfLocant = Pattern.compile("-?[\\[\\(\\{](.*)[\\]\\)\\}]$");
private final static Pattern matchGreek = Pattern.compile("alpha|beta|gamma|delta|epsilon|zeta|eta|omega", Pattern.CASE_INSENSITIVE);
private final static Pattern matchInlineSuffixesThatAreAlsoGroups = Pattern.compile("carbonyl|oxy|sulfenyl|sulfinyl|sulfonyl|selenenyl|seleninyl|selenonyl|tellurenyl|tellurinyl|telluronyl");
private final NameToStructureConfig n2sConfig;
private final Element parse;
public ComponentGenerator(NameToStructureConfig n2sConfig, Element parse) {
this.n2sConfig = n2sConfig;
this.parse = parse;
}
/**
* Processes a parse result destructively adding semantic information by processing the various micro syntaxes.
* @throws ComponentGenerationException
*/
void processParse() throws ComponentGenerationException {
List substituentsAndRoot = XOMTools.getDescendantElementsWithTagNames(parse, new String[]{SUBSTITUENT_EL, ROOT_EL});
for (Element subOrRoot: substituentsAndRoot) {
/* Throws exceptions for occurrences that are ambiguous and this parse has picked the incorrect interpretation */
resolveAmbiguities(subOrRoot);
processLocants(subOrRoot);
convertOrthoMetaParaToLocants(subOrRoot);
formAlkaneStemsFromComponents(subOrRoot);
processAlkaneStemModifications(subOrRoot);//e.g. tert-butyl
processHeterogenousHydrides(subOrRoot);//e.g. tetraphosphane, disiloxane
processIndicatedHydrogens(subOrRoot);
processStereochemistry(subOrRoot);
processInfixes(subOrRoot);
processSuffixPrefixes(subOrRoot);
processLambdaConvention(subOrRoot);
}
List groups = XOMTools.getDescendantElementsWithTagName(parse, GROUP_EL);
/* Converts open/close bracket elements to bracket elements and
* places the elements inbetween within the newly created bracket */
while(findAndStructureBrackets(substituentsAndRoot));
for (Element subOrRoot: substituentsAndRoot) {
processHydroCarbonRings(subOrRoot);
handleSuffixIrregularities(subOrRoot);//handles quinone -->dioxo
}
for (Element group : groups) {
detectAlkaneFusedRingBridges(group);
processRings(group);//processes cyclo, von baeyer and spiro tokens
handleGroupIrregularities(group);//handles benzyl, diethylene glycol, phenanthrone and other awkward bits of nomenclature
}
}
/**
* Resolves common ambiguities e.g. tetradeca being 4x10carbon chain rather than 14carbon chain
* @param subOrRoot
* @throws ComponentGenerationException
*/
static void resolveAmbiguities(Element subOrRoot) throws ComponentGenerationException {
List multipliers = XOMTools.getChildElementsWithTagName(subOrRoot, MULTIPLIER_EL);
for (Element apparentMultiplier : multipliers) {
if (!BASIC_TYPE_VAL.equals(apparentMultiplier.getAttributeValue(TYPE_ATR)) && !VONBAEYER_TYPE_VAL.equals(apparentMultiplier.getAttributeValue(TYPE_ATR))){
continue;
}
int multiplierNum = Integer.parseInt(apparentMultiplier.getAttributeValue(VALUE_ATR));
Element nextEl = (Element)XOMTools.getNextSibling(apparentMultiplier);
if (multiplierNum >=3){//detects ambiguous use of things like tetradeca
if(nextEl !=null){
if (nextEl.getLocalName().equals(ALKANESTEMCOMPONENT)){//can ignore the trivial alkanes as ambiguity does not exist for them
int alkaneChainLength = Integer.parseInt(nextEl.getAttributeValue(VALUE_ATR));
if (alkaneChainLength >=10 && alkaneChainLength > multiplierNum){
Element isThisALocant =(Element)XOMTools.getPreviousSibling(apparentMultiplier);
if (isThisALocant == null ||
!isThisALocant.getLocalName().equals(LOCANT_EL) ||
MATCH_COMMA.split(isThisALocant.getValue()).length != multiplierNum){
throw new ComponentGenerationException(apparentMultiplier.getValue() + nextEl.getValue() +" should not have been lexed as two tokens!");
}
}
}
}
}
if (multiplierNum >=4 && nextEl !=null && nextEl.getLocalName().equals(HYDROCARBONFUSEDRINGSYSTEM_EL) && nextEl.getValue().equals("phen") && !"e".equals(nextEl.getAttributeValue(SUBSEQUENTUNSEMANTICTOKEN_ATR))){//deals with tetra phenyl vs tetraphen yl
Element possibleLocantOrMultiplierOrSuffix = (Element) XOMTools.getNextSibling(nextEl);
if (possibleLocantOrMultiplierOrSuffix!=null){//null if not used as substituent
if (possibleLocantOrMultiplierOrSuffix.getLocalName().equals(SUFFIX_EL)){//for phen the aryl substituent, expect an adjacent suffix e.g. phenyl, phenoxy
Element isThisALocant =(Element)XOMTools.getPreviousSibling(apparentMultiplier);
if (isThisALocant == null || !isThisALocant.getLocalName().equals(LOCANT_EL) || MATCH_COMMA.split(isThisALocant.getValue()).length != 1){
String multiplierAndGroup =apparentMultiplier.getValue() + nextEl.getValue();
throw new ComponentGenerationException(multiplierAndGroup +" should not have been lexed as one token!");
}
}
}
}
if (multiplierNum > 4 && !apparentMultiplier.getValue().endsWith("a")){//disambiguate pent oxy and the like. Assume it means pentanoxy rather than 5 oxys
if (nextEl !=null && nextEl.getLocalName().equals(GROUP_EL)&& matchInlineSuffixesThatAreAlsoGroups.matcher(nextEl.getValue()).matches()){
throw new ComponentGenerationException(apparentMultiplier.getValue() + nextEl.getValue() +" should have been lexed as [alkane stem, inline suffix], not [multiplier, group]!");
}
}
}
List fusions = XOMTools.getChildElementsWithTagName(subOrRoot, FUSION_EL);
for (Element fusion : fusions) {
String fusionText = fusion.getValue();
if (matchNumberLocantsOnlyFusionBracket.matcher(fusionText).matches()){
Element possibleHWRing = XOMTools.getNextSiblingIgnoringCertainElements(fusion, new String[]{MULTIPLIER_EL, HETEROATOM_EL});
if (possibleHWRing !=null && HANTZSCHWIDMAN_SUBTYPE_VAL.equals(possibleHWRing.getAttributeValue(SUBTYPE_ATR))){
int heteroCount = 0;
int multiplierValue = 1;
Element currentElem = (Element) XOMTools.getNextSibling(fusion);
while(currentElem != null && !currentElem.getLocalName().equals(GROUP_EL)){
if(currentElem.getLocalName().equals(HETEROATOM_EL)) {
heteroCount+=multiplierValue;
multiplierValue =1;
} else if (currentElem.getLocalName().equals(MULTIPLIER_EL)){
multiplierValue = Integer.parseInt(currentElem.getAttributeValue(VALUE_ATR));
}
currentElem = (Element)XOMTools.getNextSibling(currentElem);
}
String[] locants = MATCH_COMMA.split(fusionText.substring(1, fusionText.length()-1));
if (locants.length == heteroCount){
boolean foundLocantNotInHwSystem =false;
for (String locant : locants) {
if (Integer.parseInt(locant) > (possibleHWRing.getAttributeValue(VALUE_ATR).length()-2)){
foundLocantNotInHwSystem =true;
}
}
if (!foundLocantNotInHwSystem){
throw new ComponentGenerationException("This fusion bracket is in fact more likely to be a description of the locants of a HW ring");
}
}
}
}
}
}
/**
* Removes hyphens from the end of locants if present
* Looks for locants of the form number-letter and converts them to letternumber
* e.g. 1-N becomes N1. 1-N is the IUPAC 2004 recommendation, N1 is the previous recommendation
* Strips indication of superscript
* Strips added hydrogen out of locants
* Strips stereochemistry out of locants
* Normalises case on greeks to lower case
*
* @param subOrRoot
* @throws ComponentGenerationException
*/
static void processLocants(Element subOrRoot) throws ComponentGenerationException {
List locants = XOMTools.getChildElementsWithTagName(subOrRoot, LOCANT_EL);
for (Element locant : locants) {
List individualLocants = splitIntoIndividualLocants(StringTools.removeDashIfPresent(locant.getValue()));
for (int i = 0; i < individualLocants.size(); i++) {
String locantText =individualLocants.get(i);
if (locantText.contains("-")){//avoids this regex being invoked typically
//rearranges locant to the older equivalent form
Matcher m= matchIUPAC2004ElementLocant.matcher(locantText);
if (m.matches()){
locantText = m.group(2) + m.group(1) + m.group(3);
}
}
if (Character.isLetter(locantText.charAt(0))){
//remove indications of superscript as the fact a locant is superscripted can be determined from context e.g. N~1~ ->N1
Matcher m = matchSuperscriptedLocant.matcher(locantText);
if (m.lookingAt()){
String replacementString = m.group(1) +m.group(2);
locantText = m.replaceFirst(replacementString);
}
if (locantText.length()>=3){
//convert greeks to lower case
m = matchGreek.matcher(locantText);
while (m.find()) {
locantText = locantText.substring(0, m.start()) + m.group().toLowerCase() + locantText.substring(m.end());
}
}
}
char lastChar = locantText.charAt(locantText.length()-1);
if(lastChar == ')' || lastChar == ']' || lastChar == '}') {
//stereochemistry or added hydrogen that result from the application of this locant as a locant for a substituent may be included in brackets after the locant
Matcher m = matchBracketAtEndOfLocant.matcher(locantText);
if (m.find()){
String brackettedText = m.group(1);
if (StringTools.endsWithCaseInsensitive(brackettedText, "H")){
locantText = m.replaceFirst("");//strip the bracket from the locantText
//create individual tags for added hydrogen. Examples of bracketed text include "9H" or "2H,7H"
String[] addedHydrogens = MATCH_COMMA.split(brackettedText);
for (String addedHydrogen : addedHydrogens) {
Element addedHydrogenElement=new Element(ADDEDHYDROGEN_EL);
addedHydrogenElement.addAttribute(new Attribute(LOCANT_ATR, addedHydrogen.substring(0, addedHydrogen.length()-1)));
XOMTools.insertBefore(locant, addedHydrogenElement);
}
if (locant.getAttribute(TYPE_ATR)==null){
locant.addAttribute(new Attribute(TYPE_ATR, ADDEDHYDROGENLOCANT_TYPE_VAL));//this locant must not be used as an indirect locant
}
}
else if (StringTools.endsWithCaseInsensitive(brackettedText, "R") || StringTools.endsWithCaseInsensitive(brackettedText, "S")){
locantText = m.replaceFirst("");//strip the bracket from the locantText
String rs = brackettedText;
Element newStereoChemEl = new Element(STEREOCHEMISTRY_EL);
newStereoChemEl.appendChild("(" + locantText +rs+")");
newStereoChemEl.addAttribute(new Attribute(TYPE_ATR, STEREOCHEMISTRYBRACKET_TYPE_VAL));
XOMTools.insertBefore(locant, newStereoChemEl);
}
else if (matchDigit.matcher(brackettedText).matches()){
//compounds locant e.g. 1(10). Leave as is, it will be handled by the function that handles unsaturation
}
else{
throw new ComponentGenerationException("OPSIN bug: malformed locant text");
}
}
else{
throw new ComponentGenerationException("OPSIN bug: malformed locant text");
}
}
individualLocants.set(i, locantText);
}
XOMTools.setTextChild(locant, StringTools.stringListToString(individualLocants, ","));
Element afterLocants = (Element)XOMTools.getNextSibling(locant);
if(afterLocants == null){
throw new ComponentGenerationException("Nothing after locant tag: " + locant.toXML());
}
if (individualLocants.size()==1){
ifCarbohydrateLocantConvertToAminoAcidStyleLocant(locant);
}
}
}
/**
* Looks for locants of the form ()?
* and converts them to
* e.g. 2,4,6 tri O- -->O2,O4,O6 tri
* @param locant
*/
private static void ifCarbohydrateLocantConvertToAminoAcidStyleLocant(Element locant) {
if (MATCH_ELEMENT_SYMBOL.matcher(locant.getValue()).matches()){
Element possibleMultiplier = (Element) XOMTools.getPreviousSibling(locant);
if (possibleMultiplier!=null && possibleMultiplier.getLocalName().equals(MULTIPLIER_EL)){
int multiplierValue = Integer.parseInt(possibleMultiplier.getAttributeValue(VALUE_ATR));
Element possibleOtherLocant = (Element) XOMTools.getPreviousSibling(possibleMultiplier);
if (possibleOtherLocant!=null){
String[] locantValues = MATCH_COMMA.split(possibleOtherLocant.getValue());
if (locantValues.length == Integer.parseInt(possibleMultiplier.getAttributeValue(VALUE_ATR))){
for (int i = 0; i < locantValues.length; i++) {
locantValues[i] = locant.getValue() + locantValues[i];
}
XOMTools.setTextChild(possibleOtherLocant, StringTools.arrayToString(locantValues, ","));
locant.detach();
}
}
else{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < multiplierValue-1; i++) {
sb.append(locant.getValue());
sb.append(StringTools.multiplyString("'", i));
sb.append(',');
}
sb.append(locant.getValue());
sb.append(StringTools.multiplyString("'", multiplierValue-1));
Element newLocant = new Element(LOCANT_EL);
newLocant.appendChild(sb.toString());
XOMTools.insertBefore(possibleMultiplier, newLocant);
locant.detach();
}
}
}
}
/**
* Takes a string of locants and splits on commas, but taking into account brackets
* e.g. 1,2(1H,2H),3 becomes [1][2(1H,2H)][3]
* @param locantString
* @return
*/
private static List splitIntoIndividualLocants(String locantString) {
List individualLocants = new ArrayList();
char[] charArray = locantString.toCharArray();
boolean inBracket =false;
int indiceOfLastMatch =0;
for (int i = 0; i < charArray.length; i++) {
char c = charArray[i];
if (c==','){
if (!inBracket){
individualLocants.add(locantString.substring(indiceOfLastMatch, i));
indiceOfLastMatch = i+1;
}
}
else if (c == '(' || c == '[' || c == '{') {
inBracket =true;
}
else if(c == ')' || c == ']' || c == '}') {
inBracket =false;
}
}
individualLocants.add(locantString.substring(indiceOfLastMatch, charArray.length));
return individualLocants;
}
/**Converts ortho/meta/para into locants
* Depending on context para, for example, will either become para or 1,para
*
* @param subOrRoot
* @throws ComponentGenerationException
*/
private void convertOrthoMetaParaToLocants(Element subOrRoot) throws ComponentGenerationException{
List ompLocants = XOMTools.getChildElementsWithTagName(subOrRoot, ORTHOMETAPARA_EL);
for (Element ompLocant : ompLocants) {
String locantText = ompLocant.getValue();
String firstChar = locantText.substring(0, 1);
Element afterOmpLocant = (Element)XOMTools.getNextSibling(ompLocant);
ompLocant.setLocalName(LOCANT_EL);
ompLocant.removeChildren();
ompLocant.addAttribute(new Attribute(TYPE_ATR, ORTHOMETAPARA_TYPE_VAL));
if(afterOmpLocant.getLocalName().equals(MULTIPLIER_EL) && afterOmpLocant.getAttributeValue(VALUE_ATR).equals("2") ||
(afterOmpLocant.getAttribute(OUTIDS_ATR)!=null && MATCH_COMMA.split(afterOmpLocant.getAttributeValue(OUTIDS_ATR)).length>1) ) {
if ("o".equalsIgnoreCase(firstChar)){
ompLocant.appendChild("1,ortho");
}
else if ("m".equalsIgnoreCase(firstChar)){
ompLocant.appendChild("1,meta");
}
else if ("p".equalsIgnoreCase(firstChar)){
ompLocant.appendChild("1,para");
}
else{
throw new ComponentGenerationException(locantText + " was not identified as being either ortho, meta or para but according to the chemical grammar it should of been");
}
}
else{
if ("o".equalsIgnoreCase(firstChar)){
ompLocant.appendChild("ortho");
}
else if ("m".equalsIgnoreCase(firstChar)){
ompLocant.appendChild("meta");
}
else if ("p".equalsIgnoreCase(firstChar)){
ompLocant.appendChild("para");
}
else{
throw new ComponentGenerationException(locantText + " was not identified as being either ortho, meta or para but according to the chemical grammar it should of been");
}
}
}
}
/**
* Processes adjacent alkane stem component elements into a single alkaneStem group element with the appropriate SMILES
* e.g. dodecane would be "do" value=2 and "dec" value=10 -->alkaneStem with 12 carbons
*
* @param subOrRoot
*/
private void formAlkaneStemsFromComponents(Element subOrRoot) {
LinkedList alkaneStemComponents =new LinkedList(XOMTools.getChildElementsWithTagName(subOrRoot, ALKANESTEMCOMPONENT));
while(!alkaneStemComponents.isEmpty()){
Element alkaneStemComponent = alkaneStemComponents.removeFirst();
int alkaneChainLength =0;
StringBuilder alkaneName = new StringBuilder();
alkaneChainLength += Integer.parseInt(alkaneStemComponent.getAttributeValue(VALUE_ATR));
alkaneName.append(alkaneStemComponent.getValue());
while (!alkaneStemComponents.isEmpty() && XOMTools.getNextSibling(alkaneStemComponent)==alkaneStemComponents.get(0)) {
alkaneStemComponent.detach();
alkaneStemComponent = alkaneStemComponents.removeFirst();
alkaneChainLength += Integer.parseInt(alkaneStemComponent.getAttributeValue(VALUE_ATR));
alkaneName.append(alkaneStemComponent.getValue());
}
Element alkaneStem = new Element(GROUP_EL);
alkaneStem.appendChild(alkaneName.toString());
alkaneStem.addAttribute(new Attribute(TYPE_ATR, CHAIN_TYPE_VAL));
alkaneStem.addAttribute(new Attribute(SUBTYPE_ATR, ALKANESTEM_SUBTYPE_VAL));
alkaneStem.addAttribute(new Attribute(VALTYPE_ATR, SMILES_VALTYPE_VAL));
alkaneStem.addAttribute(new Attribute(VALUE_ATR, StringTools.multiplyString("C", alkaneChainLength)));
alkaneStem.addAttribute(new Attribute(USABLEASJOINER_ATR, "yes"));
StringBuilder labels = new StringBuilder();
for (int i=1; i8){
throw new ComponentGenerationException("Interpretation of tert on an alkane chain of length: " + chainLength +" is ambiguous");
}
if (chainLength ==8){
smiles = "C(C)(C)CC(C)(C)C";
}
else{
smiles ="C(C)(C)C" + StringTools.multiplyString("C", chainLength-4);
}
}
else if (type.equals("iso")){
if (chainLength <3){
throw new ComponentGenerationException("ChainLength to small for iso modifier, required minLength 3. Found: " +chainLength);
}
boolean suffixPresent = subOrRoot.getChildElements(SUFFIX_EL).size() > 0;
if (chainLength==3 && !suffixPresent){
throw new ComponentGenerationException("iso has no meaning without a suffix on an alkane chain of length 3");
}
smiles =StringTools.multiplyString("C", chainLength-3) +"C(C)C";
StringBuilder sb = new StringBuilder();
for (int c = 1; c <= chainLength - 2; c++) {
sb.append(c);
sb.append('/');
}
sb.append('/');
labels = sb.toString();
}
else if (type.equals("sec")){
if (chainLength <3){
throw new ComponentGenerationException("ChainLength to small for sec modifier, required minLength 3. Found: " +chainLength);
}
boolean suffixPresent = subOrRoot.getChildElements(SUFFIX_EL).size() > 0;
if (!suffixPresent){
throw new ComponentGenerationException("sec has no meaning without a suffix on an alkane chain");
}
smiles ="C(C)C" + StringTools.multiplyString("C", chainLength-3);
}
else if (type.equals("neo")){
if (chainLength <5){
throw new ComponentGenerationException("ChainLength to small for neo modifier, required minLength 5. Found: " +chainLength);
}
smiles = StringTools.multiplyString("C", chainLength-5) + "CC(C)(C)C";
}
else{
throw new ComponentGenerationException("Unrecognised alkaneStem modifier");
}
alkane.getAttribute(VALUE_ATR).setValue(smiles);
alkane.removeAttribute(alkane.getAttribute(USABLEASJOINER_ATR));
alkane.getAttribute(LABELS_ATR).setValue(labels);
}
}
/**Form heterogeneous hydrides/substituents
* These are chains of one heteroatom or alternating heteroatoms and are expressed using SMILES
* They are typically treated in an analogous way to alkanes
* @param subOrRoot The root/substituents
* @throws ComponentGenerationException
*/
private void processHeterogenousHydrides(Element subOrRoot) throws ComponentGenerationException {
List multipliers = XOMTools.getChildElementsWithTagName(subOrRoot, MULTIPLIER_EL);
for (int i = 0; i < multipliers.size(); i++) {
Element m = multipliers.get(i);
if (m.getAttributeValue(TYPE_ATR).equals(GROUP_TYPE_VAL)){
continue;
}
Element multipliedElem = (Element)XOMTools.getNextSibling(m);
if(multipliedElem.getLocalName().equals(GROUP_EL) &&
multipliedElem.getAttribute(SUBTYPE_ATR)!=null &&
multipliedElem.getAttributeValue(SUBTYPE_ATR).equals(HETEROSTEM_SUBTYPE_VAL)) {
int mvalue = Integer.parseInt(m.getAttributeValue(VALUE_ATR));
Element possiblyALocant = (Element)XOMTools.getPreviousSibling(m);//detect rare case where multiplier does not mean form a chain of heteroatoms e.g. something like 1,2-disulfanylpropane
if(possiblyALocant !=null && possiblyALocant.getLocalName().equals(LOCANT_EL)&& mvalue==MATCH_COMMA.split(possiblyALocant.getValue()).length){
Element suffix =(Element) XOMTools.getNextSibling(multipliedElem, SUFFIX_EL);
if (suffix !=null && suffix.getAttributeValue(TYPE_ATR).equals(INLINE_TYPE_VAL)){
Element possibleMultiplier = (Element) XOMTools.getPreviousSibling(suffix);
if (!possibleMultiplier.getLocalName().equals(MULTIPLIER_EL)){//NOT something like 3,3'-diselane-1,2-diyl
continue;
}
}
}
//chain of heteroatoms
String heteroatomSmiles=multipliedElem.getAttributeValue(VALUE_ATR);
if (heteroatomSmiles.equals("B") && XOMTools.getPreviousSibling(m)==null){
Element possibleUnsaturator = (Element) XOMTools.getNextSibling(multipliedElem);
if (possibleUnsaturator !=null && possibleUnsaturator.getLocalName().equals(UNSATURATOR_EL) && possibleUnsaturator.getAttributeValue(VALUE_ATR).equals("1")){
throw new ComponentGenerationException("Polyboranes are not currently supported");
}
}
String smiles = StringTools.multiplyString(heteroatomSmiles, mvalue);
multipliedElem.getAttribute(VALUE_ATR).setValue(smiles);
m.detach();
multipliers.remove(i--);
}
}
for (Element m : multipliers) {
if (m.getAttributeValue(TYPE_ATR).equals(GROUP_TYPE_VAL)){
continue;
}
Element multipliedElem = (Element)XOMTools.getNextSibling(m);
if(multipliedElem.getLocalName().equals(HETEROATOM_EL)){
Element possiblyAnotherHeteroAtom = (Element)XOMTools.getNextSibling(multipliedElem);
if (possiblyAnotherHeteroAtom !=null && possiblyAnotherHeteroAtom.getLocalName().equals(HETEROATOM_EL)){
Element possiblyAnUnsaturator = XOMTools.getNextSiblingIgnoringCertainElements(possiblyAnotherHeteroAtom, new String[]{LOCANT_EL, MULTIPLIER_EL});//typically ane but can be ene or yne e.g. triphosphaza-1,3-diene
if (possiblyAnUnsaturator !=null && possiblyAnUnsaturator.getLocalName().equals(UNSATURATOR_EL)){
//chain of alternating heteroatoms
if (possiblyAnUnsaturator.getAttributeValue(VALUE_ATR).equals("1")){
checkForAmbiguityWithHWring(multipliedElem.getAttributeValue(VALUE_ATR), possiblyAnotherHeteroAtom.getAttributeValue(VALUE_ATR));
}
int mvalue = Integer.parseInt(m.getAttributeValue(VALUE_ATR));
StringBuilder smilesSB= new StringBuilder();
Element possiblyARingFormingEl = (Element)XOMTools.getPreviousSibling(m);
boolean heteroatomChainWillFormARing =false;
if (possiblyARingFormingEl!=null && (possiblyARingFormingEl.getLocalName().equals(CYCLO_EL) || possiblyARingFormingEl.getLocalName().equals(VONBAEYER_EL) || possiblyARingFormingEl.getLocalName().equals(SPIRO_EL))){
heteroatomChainWillFormARing=true;
//will be cyclised later.
for (int j = 0; j < mvalue; j++) {
smilesSB.append(possiblyAnotherHeteroAtom.getAttributeValue(VALUE_ATR));
smilesSB.append(multipliedElem.getAttributeValue(VALUE_ATR));
}
}
else{
for (int j = 0; j < mvalue -1; j++) {
smilesSB.append(multipliedElem.getAttributeValue(VALUE_ATR));
smilesSB.append(possiblyAnotherHeteroAtom.getAttributeValue(VALUE_ATR));
}
smilesSB.append(multipliedElem.getAttributeValue(VALUE_ATR));
}
String smiles =smilesSB.toString();
smiles = matchHdigit.matcher(smiles).replaceAll("H?");//hydrogen count will be determined by standard valency
multipliedElem.detach();
Element addedGroup=new Element(GROUP_EL);
addedGroup.addAttribute(new Attribute(VALUE_ATR, smiles));
addedGroup.addAttribute(new Attribute(VALTYPE_ATR, SMILES_VALTYPE_VAL));
addedGroup.addAttribute(new Attribute(TYPE_ATR, CHAIN_TYPE_VAL));
addedGroup.addAttribute(new Attribute(SUBTYPE_ATR, HETEROSTEM_SUBTYPE_VAL));
if (!heteroatomChainWillFormARing){
addedGroup.addAttribute(new Attribute(USABLEASJOINER_ATR, "yes"));
}
addedGroup.appendChild(smiles);
XOMTools.insertAfter(possiblyAnotherHeteroAtom, addedGroup);
possiblyAnotherHeteroAtom.detach();
m.detach();
}
else if (possiblyAnUnsaturator!=null && possiblyAnUnsaturator.getValue().equals("an") && HANTZSCHWIDMAN_SUBTYPE_VAL.equals(possiblyAnUnsaturator.getAttributeValue(SUBTYPE_ATR))){
//check for HWring that should be interpreted as a heterogenous hydride
boolean foundLocantIndicatingHwRingHeteroatomPositions =false;//allow formally incorrect HW ring systems if they have locants
Element possibleLocant = (Element) XOMTools.getPreviousSibling(m);
if (possibleLocant !=null && possibleLocant.getLocalName().equals(LOCANT_EL)){
int expected = Integer.parseInt(m.getAttributeValue(VALUE_ATR)) + 1;
if (expected == MATCH_COMMA.split(possibleLocant.getValue()).length){
foundLocantIndicatingHwRingHeteroatomPositions = true;
}
}
if (!foundLocantIndicatingHwRingHeteroatomPositions){
checkForAmbiguityWithHeterogenousHydride(multipliedElem.getAttributeValue(VALUE_ATR), possiblyAnotherHeteroAtom.getAttributeValue(VALUE_ATR));
}
}
}
}
}
}
/**
* Throws an exception if the given heteroatoms could be part of a valid Hantzch-widman ring
* For this to be true the first heteroatom must be higher priority than the second
* and the second must be compatible with a HW ane stem
* @param firstHeteroAtomSMILES
* @param secondHeteroAtomSMILES
* @throws ComponentGenerationException
*/
private void checkForAmbiguityWithHWring(String firstHeteroAtomSMILES, String secondHeteroAtomSMILES) throws ComponentGenerationException {
Matcher m = MATCH_ELEMENT_SYMBOL.matcher(firstHeteroAtomSMILES);
if (!m.find()){
throw new ComponentGenerationException("Failed to extract element from heteroatom");
}
String atom1Element = m.group();
m = MATCH_ELEMENT_SYMBOL.matcher(secondHeteroAtomSMILES);
if (!m.find()){
throw new ComponentGenerationException("Failed to extract element from heteroatom");
}
String atom2Element = m.group();
if (AtomProperties.elementToHwPriority.get(atom1Element) > AtomProperties.elementToHwPriority.get(atom2Element)){
if (atom2Element.equals("O") || atom2Element.equals("S") || atom2Element.equals("Se") || atom2Element.equals("Te")
|| atom2Element.equals("Bi") || atom2Element.equals("Hg")){
if (!hasSiorGeorSnorPb(atom1Element, atom2Element)){
throw new ComponentGenerationException("Hantzch-widman ring misparsed as a heterogeneous hydride with alternating atoms");
}
}
}
}
/**
* Are either of the elements Si/Ge/Sn/Pb
* @param atom1Element
* @param atom2Element
* @return
*/
private boolean hasSiorGeorSnorPb(String atom1Element, String atom2Element) {
return (atom1Element.equals("Si") || atom1Element.equals("Ge") || atom1Element.equals("Sn") ||atom1Element.equals("Pb")
|| atom2Element.equals("Si") || atom2Element.equals("Ge") || atom2Element.equals("Sn") ||atom2Element.equals("Pb"));
}
/**
* Throws an exception if the given heteroatoms could be part of a heterogenous hydride
* For this to be true the second heteroatom must be higher priority than the first
* @param firstHeteroAtomSMILES
* @param secondHeteroAtomSMILES
* @throws ComponentGenerationException
*/
private void checkForAmbiguityWithHeterogenousHydride(String firstHeteroAtomSMILES, String secondHeteroAtomSMILES) throws ComponentGenerationException {
Matcher m = MATCH_ELEMENT_SYMBOL.matcher(firstHeteroAtomSMILES);
if (!m.find()){
throw new ComponentGenerationException("Failed to extract element from heteroatom");
}
String atom1Element = m.group();
m = MATCH_ELEMENT_SYMBOL.matcher(secondHeteroAtomSMILES);
if (!m.find()){
throw new ComponentGenerationException("Failed to extract element from heteroatom");
}
String atom2Element = m.group();
if (AtomProperties.elementToHwPriority.get(atom2Element) > AtomProperties.elementToHwPriority.get(atom1Element)){
throw new ComponentGenerationException("heterogeneous hydride with alternating atoms misparsed as a Hantzch-widman ring");
}
}
/** Handle indicated hydrogen e.g. 1H- in 1H-pyrrole
*
* @param subOrRoot The substituent/root to looks for indicated hydrogens in.
* @throws ComponentGenerationException
*/
private void processIndicatedHydrogens(Element subOrRoot) throws ComponentGenerationException {
List indicatedHydrogens = XOMTools.getChildElementsWithTagName(subOrRoot, INDICATEDHYDROGEN_EL);
for (Element indicatedHydrogenGroup : indicatedHydrogens) {
String txt = StringTools.removeDashIfPresent(indicatedHydrogenGroup.getValue());
if (!StringTools.endsWithCaseInsensitive(txt, "h")){//remove brackets if they are present
txt = txt.substring(1, txt.length()-1);
}
String[] hydrogenLocants =MATCH_COMMA.split(txt);
for (String hydrogenLocant : hydrogenLocants) {
if (StringTools.endsWithCaseInsensitive(hydrogenLocant, "h")) {
Element indicatedHydrogenEl = new Element(INDICATEDHYDROGEN_EL);
indicatedHydrogenEl.addAttribute(new Attribute(LOCANT_ATR, hydrogenLocant.substring(0, hydrogenLocant.length() - 1)));
XOMTools.insertBefore(indicatedHydrogenGroup, indicatedHydrogenEl);
}
else{
throw new ComponentGenerationException("OPSIN Bug: malformed indicated hydrogen element!");
}
}
indicatedHydrogenGroup.detach();
}
}
/** Handles stereoChemistry in brackets: R/Z/E/Z/a/alpha/b/beta and cis/trans
* Will assign a locant to a stereoChemistry element if one was specified/available
*
* @param subOrRoot The substituent/root to looks for stereoChemistry in.
* @throws ComponentGenerationException
*/
static void processStereochemistry(Element subOrRoot) throws ComponentGenerationException {
List stereoChemistryElements = XOMTools.getChildElementsWithTagName(subOrRoot, STEREOCHEMISTRY_EL);
for (Element stereoChemistryElement : stereoChemistryElements) {
if (stereoChemistryElement.getAttributeValue(TYPE_ATR).equals(STEREOCHEMISTRYBRACKET_TYPE_VAL)){
processStereochemistryBracket(stereoChemistryElement);
}
else if (stereoChemistryElement.getAttributeValue(TYPE_ATR).equals(CISORTRANS_TYPE_VAL)){
assignLocantUsingPreviousElementIfPresent(stereoChemistryElement);//assign a locant if one is directly before the cis/trans
}
else if (stereoChemistryElement.getAttributeValue(TYPE_ATR).equals(E_OR_Z_TYPE_VAL)){
stereoChemistryElement.addAttribute(new Attribute(VALUE_ATR, stereoChemistryElement.getValue().toUpperCase()));
assignLocantUsingPreviousElementIfPresent(stereoChemistryElement);//assign a locant if one is directly before the E/Z
}
else if (stereoChemistryElement.getAttributeValue(TYPE_ATR).equals(ALPHA_OR_BETA_TYPE_VAL)){
processUnbracketedAlphaBetaStereochemistry(stereoChemistryElement);
}
}
}
private static void processStereochemistryBracket(Element stereoChemistryElement) throws ComponentGenerationException {
String txt = StringTools.removeDashIfPresent(stereoChemistryElement.getValue());
if (txt.startsWith("rel-")){
txt = txt.substring(4);
}
Matcher starMatcher = matchStar.matcher(txt);
txt = starMatcher.replaceAll("");
if (!txt.startsWith("rac-")){
txt =txt.substring(1, txt.length()-1);//remove opening and closing bracket.
String[] stereoChemistryDescriptors = matchCommaOrDash.split(txt);
for (String stereoChemistryDescriptor : stereoChemistryDescriptors) {
Matcher m = matchStereochemistry.matcher(stereoChemistryDescriptor);
if (m.matches()){
if (!m.group(2).equals("RS") && !m.group(2).equals("SR")){
Element stereoChemEl = new Element(STEREOCHEMISTRY_EL);
if (m.group(1).length()!=0){
stereoChemEl.addAttribute(new Attribute(LOCANT_ATR, m.group(1)));
}
stereoChemEl.appendChild(stereoChemistryDescriptor);
XOMTools.insertBefore(stereoChemistryElement, stereoChemEl);
if (matchRS.matcher(m.group(2)).matches()) {
stereoChemEl.addAttribute(new Attribute(TYPE_ATR, R_OR_S_TYPE_VAL));
stereoChemEl.addAttribute(new Attribute(VALUE_ATR, m.group(2).toUpperCase()));
} else if (matchEZ.matcher(m.group(2)).matches()) {
stereoChemEl.addAttribute(new Attribute(TYPE_ATR, E_OR_Z_TYPE_VAL));
stereoChemEl.addAttribute(new Attribute(VALUE_ATR, m.group(2).toUpperCase()));
} else if (matchAlphaBetaStereochem.matcher(m.group(2)).matches()){
stereoChemEl.addAttribute(new Attribute(TYPE_ATR, ALPHA_OR_BETA_TYPE_VAL));
if (Character.toLowerCase(m.group(2).charAt(0)) == 'a'){
stereoChemEl.addAttribute(new Attribute(VALUE_ATR, "alpha"));
}
else if (Character.toLowerCase(m.group(2).charAt(0)) == 'b'){
stereoChemEl.addAttribute(new Attribute(VALUE_ATR, "beta"));
}
else if (Character.toLowerCase(m.group(2).charAt(0)) == 'x'){
stereoChemEl.addAttribute(new Attribute(VALUE_ATR, "xi"));
}
else{
throw new ComponentGenerationException("Malformed alpha/beta stereochemistry element: " + stereoChemistryElement.getValue());
}
} else if (matchCisTrans.matcher(m.group(2)).matches()) {
stereoChemEl.addAttribute(new Attribute(TYPE_ATR, CISORTRANS_TYPE_VAL));
stereoChemEl.addAttribute(new Attribute(VALUE_ATR, m.group(2).toLowerCase()));
} else {
throw new ComponentGenerationException("Malformed stereochemistry element: " + stereoChemistryElement.getValue());
}
}
} else {
throw new ComponentGenerationException("Malformed stereochemistry element: " + stereoChemistryElement.getValue());
}
}
}
stereoChemistryElement.detach();
}
private static void assignLocantUsingPreviousElementIfPresent(Element stereoChemistryElement) {
Element possibleLocant = (Element) XOMTools.getPrevious(stereoChemistryElement);
if (possibleLocant !=null && possibleLocant.getLocalName().equals(LOCANT_EL) && MATCH_COMMA.split(possibleLocant.getValue()).length==1){
stereoChemistryElement.addAttribute(new Attribute(LOCANT_ATR, possibleLocant.getValue()));
possibleLocant.detach();
}
}
private static void processUnbracketedAlphaBetaStereochemistry(Element stereoChemistryElement) throws ComponentGenerationException {
String txt = StringTools.removeDashIfPresent(stereoChemistryElement.getValue());
String[] stereoChemistryDescriptors = MATCH_COMMA.split(txt);
List locants = new ArrayList();
boolean createLocantsEl =false;
for (String stereoChemistryDescriptor : stereoChemistryDescriptors) {
Matcher digitMatcher = matchDigit.matcher(stereoChemistryDescriptor);
if (digitMatcher.lookingAt()){
String locant = digitMatcher.group();
String possibleAlphaBeta = digitMatcher.replaceAll("");
locants.add(locant);
Matcher alphaBetaMatcher = matchAlphaBetaStereochem.matcher(possibleAlphaBeta);
if (alphaBetaMatcher.matches()){
Element stereoChemEl = new Element(STEREOCHEMISTRY_EL);
stereoChemEl.addAttribute(new Attribute(LOCANT_ATR, locant));
stereoChemEl.appendChild(stereoChemistryDescriptor);
XOMTools.insertBefore(stereoChemistryElement, stereoChemEl);
stereoChemEl.addAttribute(new Attribute(TYPE_ATR, ALPHA_OR_BETA_TYPE_VAL));
if (Character.toLowerCase(possibleAlphaBeta.charAt(0)) == 'a'){
stereoChemEl.addAttribute(new Attribute(VALUE_ATR, "alpha"));
}
else if (Character.toLowerCase(possibleAlphaBeta.charAt(0)) == 'b'){
stereoChemEl.addAttribute(new Attribute(VALUE_ATR, "beta"));
}
else if (Character.toLowerCase(possibleAlphaBeta.charAt(0)) == 'x'){
stereoChemEl.addAttribute(new Attribute(VALUE_ATR, "xi"));
}
else{
throw new ComponentGenerationException("Malformed alpha/beta stereochemistry element: " + stereoChemistryElement.getValue());
}
}
else{
createLocantsEl =true;
}
}
}
if (!createLocantsEl){
//create locants unless a group supporting alpha/beta stereochem is within this substituent/root
createLocantsEl =true;
List groups = XOMTools.getNextSiblingsOfType(stereoChemistryElement, GROUP_EL);
for (Element group : groups) {
if (group.getAttributeValue(ALPHABETACLOCKWISEATOMORDERING_ATR)!=null){
createLocantsEl=false;
break;
}
}
}
if (createLocantsEl){
Element newLocantEl = new Element(LOCANT_EL);
newLocantEl.appendChild(StringTools.stringListToString(locants, ","));
XOMTools.insertAfter(stereoChemistryElement, newLocantEl);
}
stereoChemistryElement.detach();
}
/**
* Looks for "suffixPrefix" and assigns their value them as an attribute of an adjacent suffix
* @param subOrRoot
* @throws ComponentGenerationException
*/
private void processSuffixPrefixes(Element subOrRoot) throws ComponentGenerationException {
List suffixPrefixes = XOMTools.getChildElementsWithTagName(subOrRoot, SUFFIXPREFIX_EL);
for (Element suffixPrefix : suffixPrefixes) {
Element suffix = (Element) XOMTools.getNextSibling(suffixPrefix);
if (suffix==null || ! suffix.getLocalName().equals(SUFFIX_EL)){
throw new ComponentGenerationException("OPSIN bug: suffix not found after suffixPrefix: " + suffixPrefix.getValue());
}
suffix.addAttribute(new Attribute(SUFFIXPREFIX_ATR, suffixPrefix.getAttributeValue(VALUE_ATR)));
suffixPrefix.detach();
}
}
/**
* Looks for infixes and assigns them to the next suffix using a semicolon delimited infix attribute
* If the infix/suffix block has been bracketed e.g (dithioate) then the infix is multiplied out
* If preceded by a suffixPrefix e.g. sulfono infixes are also multiplied out
* If a multiplier is present and neither of these cases are met then it is ambiguous as to whether the multiplier is referring to the infix or the infixed suffix
* This ambiguity is resolved in processInfixFunctionalReplacementNomenclature by looking at the structure of the suffix to be modified
* @param subOrRoot
* @throws ComponentGenerationException
*/
private void processInfixes(Element subOrRoot) throws ComponentGenerationException {
List infixes = XOMTools.getChildElementsWithTagName(subOrRoot, INFIX_EL);
for (Element infix : infixes) {
Element suffix = XOMTools.getNextSiblingIgnoringCertainElements(infix, new String[]{INFIX_EL, SUFFIXPREFIX_EL, MULTIPLIER_EL});
if (suffix ==null || !suffix.getLocalName().equals(SUFFIX_EL)){
throw new ComponentGenerationException("No suffix found next next to infix: "+ infix.getValue());
}
List currentInfixInformation;
if (suffix.getAttribute(INFIX_ATR)==null){
suffix.addAttribute(new Attribute(INFIX_ATR, ""));
currentInfixInformation = new ArrayList();
}
else{
currentInfixInformation = StringTools.arrayToList(MATCH_SEMICOLON.split(suffix.getAttributeValue(INFIX_ATR)));
}
String infixValue =infix.getAttributeValue(VALUE_ATR);
currentInfixInformation.add(infixValue);
Element possibleMultiplier = (Element) XOMTools.getPreviousSibling(infix);
Element possibleBracket;
boolean multiplierKnownToIndicateInfixMultiplicationPresent =false;
if (possibleMultiplier.getLocalName().equals(MULTIPLIER_EL)){
//suffix prefix present so multiplier must indicate infix replacement
Element possibleSuffixPrefix = XOMTools.getPreviousSiblingIgnoringCertainElements(infix, new String[]{MULTIPLIER_EL, INFIX_EL});
if (possibleSuffixPrefix!=null && possibleSuffixPrefix.getLocalName().equals(SUFFIXPREFIX_EL)){
multiplierKnownToIndicateInfixMultiplicationPresent =true;
}
Element elementBeforeMultiplier = (Element) XOMTools.getPreviousSibling(possibleMultiplier);
//double multiplier indicates multiple suffixes which all have their infix multiplied
//if currentInfixInformation contains more than 1 entry it contains information from an infix from before the multiplier so the interpretation of the multiplier as a suffix multiplier is impossible
if (elementBeforeMultiplier.getLocalName().equals(MULTIPLIER_EL) || currentInfixInformation.size() > 1){
multiplierKnownToIndicateInfixMultiplicationPresent =true;
}
possibleBracket = elementBeforeMultiplier;
}
else{
possibleBracket=possibleMultiplier;
possibleMultiplier=null;
infix.detach();
}
if (possibleBracket.getLocalName().equals(STRUCTURALOPENBRACKET_EL)){
Element bracket = (Element) XOMTools.getNextSibling(suffix);
if (!bracket.getLocalName().equals(STRUCTURALCLOSEBRACKET_EL)){
throw new ComponentGenerationException("Matching closing bracket not found around infix/suffix block");
}
if (possibleMultiplier!=null){
int multiplierVal = Integer.parseInt(possibleMultiplier.getAttributeValue(VALUE_ATR));
for (int i = 1; i < multiplierVal; i++) {
currentInfixInformation.add(infixValue);
}
possibleMultiplier.detach();
infix.detach();
}
possibleBracket.detach();
bracket.detach();
}
else if (multiplierKnownToIndicateInfixMultiplicationPresent){//multiplier unambiguously means multiplication of the infix
int multiplierVal = Integer.parseInt(possibleMultiplier.getAttributeValue(VALUE_ATR));
for (int i = 1; i < multiplierVal; i++) {
currentInfixInformation.add(infixValue);
}
possibleMultiplier.detach();
infix.detach();
}
else if (possibleMultiplier!=null && GROUP_TYPE_VAL.equals(possibleMultiplier.getAttributeValue(TYPE_ATR))){//e.g. ethanbisthioic acid == ethanbis(thioic acid)
infix.detach();
}
suffix.getAttribute(INFIX_ATR).setValue(StringTools.stringListToString(currentInfixInformation, ";"));
}
}
/**
* Identifies lambdaConvention elements.
* The elementsValue is expected to be a comma seperated lambda values and 0 or more locants. Where a lambda value has the following form:
* optional locant, the word lambda and then a number which is the valency specified (with possibly some attempt to indicate this number is superscripted)
* If the element is followed by heteroatoms (possibly multiplied) they are multiplied and the locant/lambda assigned to them
* Otherwise a new lambdaConvention element is created with the valency specified by the lambda convention taking the attribute "lambda"
* In the case where heteroatoms belong to a fused ring system a new lambdaConvention element is also created. The original locants are retained in the benzo specific fused ring nomenclature:
* 2H-5lambda^5-phosphinino[3,2-b]pyran --> 2H 5lambda^5 phosphinino[3,2-b]pyran BUT
* 1lambda^4,5-Benzodithiepin --> 1lambda^4 1,5-Benzodithiepin
* @param subOrRoot
* @throws ComponentGenerationException
*/
private void processLambdaConvention(Element subOrRoot) throws ComponentGenerationException {
List lambdaConventionEls = XOMTools.getChildElementsWithTagName(subOrRoot, LAMBDACONVENTION_EL);
boolean fusedRingPresent = false;
if (lambdaConventionEls.size()>0){
if (subOrRoot.getChildElements(GROUP_EL).size()>1){
fusedRingPresent = true;
}
}
for (Element lambdaConventionEl : lambdaConventionEls) {
boolean frontLocantsExpected =false;//Is the lambdaConvention el followed by benz/benzo of a fused ring system (these have front locants which correspond to the final fused rings numbering) or by a polycylicspiro system
String[] lambdaValues = MATCH_COMMA.split(StringTools.removeDashIfPresent(lambdaConventionEl.getValue()));
Element possibleHeteroatomOrMultiplier = (Element) XOMTools.getNextSibling(lambdaConventionEl);
int heteroCount = 0;
int multiplierValue = 1;
while(possibleHeteroatomOrMultiplier != null){
if(possibleHeteroatomOrMultiplier.getLocalName().equals(HETEROATOM_EL)) {
heteroCount+=multiplierValue;
multiplierValue =1;
} else if (possibleHeteroatomOrMultiplier.getLocalName().equals(MULTIPLIER_EL)){
multiplierValue = Integer.parseInt(possibleHeteroatomOrMultiplier.getAttributeValue(VALUE_ATR));
}
else{
break;
}
possibleHeteroatomOrMultiplier = (Element)XOMTools.getNextSibling(possibleHeteroatomOrMultiplier);
}
boolean assignLambdasToHeteroAtoms =false;
if (lambdaValues.length==heteroCount){//heteroatom and number of locants +lambdas must match
if (fusedRingPresent && possibleHeteroatomOrMultiplier!=null && possibleHeteroatomOrMultiplier.getLocalName().equals(GROUP_EL) && possibleHeteroatomOrMultiplier.getAttributeValue(SUBTYPE_ATR).equals(HANTZSCHWIDMAN_SUBTYPE_VAL)){
//You must not set the locants of a HW system which forms a component of a fused ring system. The locant specified corresponds to the complete fused ring system.
}
else{
assignLambdasToHeteroAtoms =true;
}
}
else if (possibleHeteroatomOrMultiplier!=null && ((heteroCount==0 && XOMTools.getNextSibling(lambdaConventionEl).equals(possibleHeteroatomOrMultiplier) &&
fusedRingPresent && possibleHeteroatomOrMultiplier.getLocalName().equals(GROUP_EL) &&
(possibleHeteroatomOrMultiplier.getValue().equals("benzo") || possibleHeteroatomOrMultiplier.getValue().equals("benz"))
&& !((Element)XOMTools.getNextSibling(possibleHeteroatomOrMultiplier)).getLocalName().equals(FUSION_EL)
&& !((Element)XOMTools.getNextSibling(possibleHeteroatomOrMultiplier)).getLocalName().equals(LOCANT_EL))
|| (possibleHeteroatomOrMultiplier.getLocalName().equals(POLYCYCLICSPIRO_EL) &&
(possibleHeteroatomOrMultiplier.getAttributeValue(VALUE_ATR).equals("spirobi")|| possibleHeteroatomOrMultiplier.getAttributeValue(VALUE_ATR).equals("spiroter"))))){
frontLocantsExpected = true;//a benzo fused ring e.g. 1lambda4,3-benzothiazole or a symmetrical poly cyclic spiro system
}
List heteroAtoms = new ArrayList();//contains the heteroatoms to apply the lambda values too. Can be empty if the values are applied to a group directly rather than to a heteroatom
if (assignLambdasToHeteroAtoms){//populate heteroAtoms, multiplied heteroatoms are multiplied out
Element multiplier = null;
Element heteroatomOrMultiplier = (Element) XOMTools.getNextSibling(lambdaConventionEl);
while(heteroatomOrMultiplier != null){
if(heteroatomOrMultiplier.getLocalName().equals(HETEROATOM_EL)) {
heteroAtoms.add(heteroatomOrMultiplier);
if (multiplier!=null){
for (int i = 1; i < Integer.parseInt(multiplier.getAttributeValue(VALUE_ATR)); i++) {
Element newHeteroAtom = new Element(heteroatomOrMultiplier);
XOMTools.insertBefore(heteroatomOrMultiplier, newHeteroAtom);
heteroAtoms.add(newHeteroAtom);
}
multiplier.detach();
multiplier=null;
}
} else if (heteroatomOrMultiplier.getLocalName().equals(MULTIPLIER_EL)){
if (multiplier !=null){
break;
}
else{
multiplier = heteroatomOrMultiplier;
}
}
else{
break;
}
heteroatomOrMultiplier = (Element)XOMTools.getNextSibling(heteroatomOrMultiplier);
}
}
for (int i = 0; i < lambdaValues.length; i++) {//assign all the lambdas to heteroatoms or to newly created lambdaConvention elements
String lambdaValue = lambdaValues[i];
Matcher m = matchLambdaConvention.matcher(lambdaValue);
if (m.matches()){//a lambda
Attribute valencyChange = new Attribute(LAMBDA_ATR, m.group(2));
Attribute locantAtr = null;
if (m.group(1)!=null){
locantAtr = new Attribute(LOCANT_ATR, m.group(1));
}
if (frontLocantsExpected){
if (m.group(1)==null){
throw new ComponentGenerationException("Locant not found for lambda convention before a benzo fused ring system");
}
lambdaValues[i] = m.group(1);
}
if (assignLambdasToHeteroAtoms){
Element heteroAtom = heteroAtoms.get(i);
heteroAtom.addAttribute(valencyChange);
if (locantAtr!=null){
heteroAtom.addAttribute(locantAtr);
}
}
else{
Element newLambda = new Element(LAMBDACONVENTION_EL);
newLambda.addAttribute(valencyChange);
if (locantAtr!=null){
newLambda.addAttribute(locantAtr);
}
XOMTools.insertBefore(lambdaConventionEl, newLambda);
}
}
else{//just a locant e.g 1,3lambda5
if (!assignLambdasToHeteroAtoms){
if (!frontLocantsExpected){
throw new ComponentGenerationException("Lambda convention not specified for locant: " + lambdaValue);
}
}
else{
Element heteroAtom = heteroAtoms.get(i);
heteroAtom.addAttribute(new Attribute(LOCANT_ATR, lambdaValue));
}
}
}
if (!frontLocantsExpected){
lambdaConventionEl.detach();
}
else{
lambdaConventionEl.setLocalName(LOCANT_EL);
XOMTools.setTextChild(lambdaConventionEl, StringTools.arrayToString(lambdaValues, ","));
}
}
}
/**Finds matching open and close brackets, and places the
* elements contained within in a big <bracket> element.
*
* @param substituentsAndRoot: The substituent/root elements at the current level of the tree
* @return Whether the method did something, and so needs to be called again.
* @throws ComponentGenerationException
*/
private boolean findAndStructureBrackets(List substituentsAndRoot) throws ComponentGenerationException {
int blevel = 0;
Element openBracket = null;
Element closeBracket = null;
for (Element sub : substituentsAndRoot) {
Elements children = sub.getChildElements();
for(int i=0; i annulens = XOMTools.getChildElementsWithTagName(subOrRoot, ANNULEN_EL);
for (Element annulen : annulens) {
String annulenValue =annulen.getValue();
Matcher match = matchAnnulene.matcher(annulenValue);
match.matches();
if (match.groupCount() !=1){
throw new ComponentGenerationException("Invalid annulen tag");
}
int annulenSize=Integer.valueOf(match.group(1));
if (annulenSize <3){
throw new ComponentGenerationException("Invalid annulen tag");
}
//build [annulenSize]annulene ring as SMILES
String SMILES = "c1" +StringTools.multiplyString("c", annulenSize -1);
SMILES += "1";
Element group =new Element(GROUP_EL);
group.addAttribute(new Attribute(VALUE_ATR, SMILES));
group.addAttribute(new Attribute(VALTYPE_ATR, SMILES_VALTYPE_VAL));
group.addAttribute(new Attribute(TYPE_ATR, RING_TYPE_VAL));
group.addAttribute(new Attribute(SUBTYPE_ATR, ARYLGROUP_SUBTYPE_VAL));
group.appendChild(annulenValue);
annulen.getParent().replaceChild(annulen, group);
}
List hydrocarbonFRSystems = XOMTools.getChildElementsWithTagName(subOrRoot, HYDROCARBONFUSEDRINGSYSTEM_EL);
for (Element hydrocarbonFRSystem : hydrocarbonFRSystems) {
Element multiplier = (Element)XOMTools.getPreviousSibling(hydrocarbonFRSystem);
if(multiplier != null && multiplier.getLocalName().equals(MULTIPLIER_EL)) {
int multiplierValue =Integer.parseInt(multiplier.getAttributeValue(VALUE_ATR));
String classOfHydrocarbonFRSystem =hydrocarbonFRSystem.getAttributeValue(VALUE_ATR);
Element newGroup =new Element(GROUP_EL);
StringBuilder smilesSB= new StringBuilder();
if (classOfHydrocarbonFRSystem.equals("polyacene")){
if (multiplierValue <=3){
throw new ComponentGenerationException("Invalid polyacene");
}
smilesSB.append("c1ccc");
for (int j = 2; j <= multiplierValue; j++) {
smilesSB.append("c");
smilesSB.append(ringClosure(j));
smilesSB.append("c");
}
smilesSB.append("ccc");
for (int j = multiplierValue; j >2; j--) {
smilesSB.append("c");
smilesSB.append(ringClosure(j));
smilesSB.append("c");
}
smilesSB.append("c12");
}else if (classOfHydrocarbonFRSystem.equals("polyaphene")){
if (multiplierValue <=3){
throw new ComponentGenerationException("Invalid polyaphene");
}
smilesSB.append("c1ccc");
int ringsAbovePlane;
int ringsOnPlane;
int ringOpeningCounter=2;
if (multiplierValue %2==0){
ringsAbovePlane =(multiplierValue-2)/2;
ringsOnPlane =ringsAbovePlane +1;
}
else{
ringsAbovePlane =(multiplierValue-1)/2;
ringsOnPlane =ringsAbovePlane;
}
for (int j = 1; j <= ringsAbovePlane; j++) {
smilesSB.append("c");
smilesSB.append(ringClosure(ringOpeningCounter++));
smilesSB.append("c");
}
for (int j = 1; j <= ringsOnPlane; j++) {
smilesSB.append("cc");
smilesSB.append(ringClosure(ringOpeningCounter++));
}
smilesSB.append("ccc");
ringOpeningCounter--;
for (int j = 1; j <= ringsOnPlane; j++) {
smilesSB.append("cc");
smilesSB.append(ringClosure(ringOpeningCounter--));
}
for (int j = 1; j < ringsAbovePlane; j++) {
smilesSB.append("c");
smilesSB.append(ringClosure(ringOpeningCounter--));
smilesSB.append("c");
}
smilesSB.append("c12");
} else if (classOfHydrocarbonFRSystem.equals("polyalene")){
if (multiplierValue <5){
throw new ComponentGenerationException("Invalid polyalene");
}
smilesSB.append("c1");
for (int j = 3; j < multiplierValue; j++) {
smilesSB.append("c");
}
smilesSB.append("c2");
for (int j = 3; j <= multiplierValue; j++) {
smilesSB.append("c");
}
smilesSB.append("c12");
} else if (classOfHydrocarbonFRSystem.equals("polyphenylene")){
if (multiplierValue <2){
throw new ComponentGenerationException("Invalid polyphenylene");
}
smilesSB.append("c1cccc2");
for (int j = 1; j < multiplierValue; j++) {
smilesSB.append("c3ccccc3");
}
smilesSB.append("c12");
} else if (classOfHydrocarbonFRSystem.equals("polynaphthylene")){
if (multiplierValue <3){
throw new ComponentGenerationException("Invalid polynaphthylene");
}
smilesSB.append("c1cccc2cc3");
for (int j = 1; j < multiplierValue; j++) {
smilesSB.append("c4cc5ccccc5cc4");
}
smilesSB.append("c3cc12");
} else if (classOfHydrocarbonFRSystem.equals("polyhelicene")){
if (multiplierValue <4){
throw new ComponentGenerationException("Invalid polyhelicene");
}
smilesSB.append("c1c");
int ringOpeningCounter=2;
for (int j = 1; j < multiplierValue; j++) {
smilesSB.append("ccc");
smilesSB.append(ringClosure(ringOpeningCounter++));
}
smilesSB.append("cccc");
ringOpeningCounter--;
for (int j = 2; j < multiplierValue; j++) {
smilesSB.append("c");
smilesSB.append(ringClosure(ringOpeningCounter--));
}
smilesSB.append("c12");
}
else{
throw new ComponentGenerationException("Unknown semi-trivially named hydrocarbon fused ring system");
}
newGroup.addAttribute(new Attribute(VALUE_ATR, smilesSB.toString()));
newGroup.addAttribute(new Attribute(VALTYPE_ATR, SMILES_VALTYPE_VAL));
newGroup.addAttribute(new Attribute(LABELS_ATR, FUSEDRING_LABELS_VAL));
newGroup.addAttribute(new Attribute(TYPE_ATR, RING_TYPE_VAL));
newGroup.addAttribute(new Attribute(SUBTYPE_ATR, HYDROCARBONFUSEDRINGSYSTEM_EL));
newGroup.appendChild(multiplier.getValue() + hydrocarbonFRSystem.getValue());
hydrocarbonFRSystem.getParent().replaceChild(hydrocarbonFRSystem, newGroup);
multiplier.detach();
}
else{
throw new ComponentGenerationException("Invalid semi-trivially named hydrocarbon fused ring system");
}
}
}
/**
* Handles irregular suffixes. e.g. Quinone and ylene
* @param subOrRoot
* @throws ComponentGenerationException
*/
private void handleSuffixIrregularities(Element subOrRoot) throws ComponentGenerationException {
List suffixes = XOMTools.getChildElementsWithTagName(subOrRoot, SUFFIX_EL);
for (Element suffix : suffixes) {
String suffixValue = suffix.getValue();
if (suffixValue.equals("ic") || suffixValue.equals("ous")){
if (!n2sConfig.allowInterpretationOfAcidsWithoutTheWordAcid()) {
Node next = XOMTools.getNext(suffix);
if (next == null){
throw new ComponentGenerationException("\"acid\" not found after " +suffixValue);
}
}
}
// convert quinone to dione
else if (suffixValue.equals("quinone") || suffixValue.equals("quinon")){
suffix.removeAttribute(suffix.getAttribute(ADDITIONALVALUE_ATR));
XOMTools.setTextChild(suffix, "one");
Element multiplier = (Element) XOMTools.getPreviousSibling(suffix);
if (multiplier.getLocalName().equals(MULTIPLIER_EL)){
Attribute multVal = multiplier.getAttribute(VALUE_ATR);
int newMultiplier = Integer.parseInt(multVal.getValue()) * 2;
multVal.setValue(String.valueOf(newMultiplier));
}
else{
multiplier = new Element(MULTIPLIER_EL);
multiplier.addAttribute(new Attribute(VALUE_ATR, "2"));
multiplier.appendChild("di");
XOMTools.insertBefore(suffix, multiplier);
}
}
else if (suffixValue.equals("ylene") || suffixValue.equals("ylen")){
suffix.removeAttribute(suffix.getAttribute(ADDITIONALVALUE_ATR));
XOMTools.setTextChild(suffix, "yl");
Element alk = (Element) XOMTools.getPreviousSibling(suffix, GROUP_EL);
if (alk.getAttribute(USABLEASJOINER_ATR)!=null){
alk.getAttribute(USABLEASJOINER_ATR).detach();
}
Element multiplier = new Element(MULTIPLIER_EL);
multiplier.addAttribute(new Attribute(VALUE_ATR, "2"));
multiplier.appendChild("di");
XOMTools.insertBefore(suffix, multiplier);
}
else if (suffixValue.equals("ylium") &&//disambiguate between ylium the charge modifying suffix and ylium the acylium suffix
"acylium".equals(suffix.getAttributeValue(VALUE_ATR)) &&
suffix.getAttribute(SUFFIXPREFIX_ATR)==null &&
suffix.getAttribute(INFIX_ATR)==null){
Element group = (Element) XOMTools.getPreviousSibling(suffix, GROUP_EL);
if (group==null || (!ACIDSTEM_TYPE_VAL.equals(group.getAttributeValue(TYPE_ATR)) &&
!CHALCOGENACIDSTEM_TYPE_VAL.equals(group.getAttributeValue(TYPE_ATR)) &&
!NONCARBOXYLICACID_TYPE_VAL.equals(group.getAttributeValue(TYPE_ATR)))){
Element beforeSuffix = (Element) XOMTools.getPreviousSibling(suffix);
String o = beforeSuffix.getAttributeValue(SUBSEQUENTUNSEMANTICTOKEN_ATR);
if (o ==null || !StringTools.endsWithCaseInsensitive(o, "o")){
if (group!=null && ARYLSUBSTITUENT_SUBTYPE_VAL.equals(group.getAttributeValue(SUBTYPE_ATR))){
//contracted form for removal of hydride e.g. 9-Anthrylium
suffix.getAttribute(VALUE_ATR).setValue("ylium");
suffix.getAttribute(TYPE_ATR).setValue(CHARGE_TYPE_VAL);
suffix.removeAttribute(suffix.getAttribute(SUBTYPE_ATR));
}
else{
throw new ComponentGenerationException("ylium is intended to be the removal of H- in this context not the formation of an acylium ion");
}
}
}
}
}
}
/**
* Looks for alkaneStems followed by a bridge forming 'o' and makes them fused ring bridge elements
* @param group
*/
private void detectAlkaneFusedRingBridges(Element group) {
if (ALKANESTEM_SUBTYPE_VAL.equals(group.getAttributeValue(SUBTYPE_ATR))){
Element possibleBridgeFormer = XOMTools.getNextSiblingIgnoringCertainElements(group, new String[]{UNSATURATOR_EL});
if(possibleBridgeFormer!=null && possibleBridgeFormer.getLocalName().equals(BRIDGEFORMINGO_EL)){
possibleBridgeFormer.detach();
group.setLocalName(FUSEDRINGBRIDGE_EL);
}
}
}
/**Looks (multiplier)cyclo/spiro/cyclo tags before chain
* and replaces them with a group with appropriate SMILES
* Note that only simple spiro tags are handled at this stage i.e. not dispiro
* @param group A group which is potentially a chain
* @throws ComponentGenerationException
*/
private void processRings(Element group) throws ComponentGenerationException {
Element previous = (Element)XOMTools.getPreviousSibling(group);
if(previous != null) {
String previousElType = previous.getLocalName();
if(previousElType.equals(SPIRO_EL)){
processSpiroSystem(group, previous);
} else if(previousElType.equals(VONBAEYER_EL)) {
processVonBaeyerSystem(group, previous);
}
else if(previousElType.equals(CYCLO_EL)) {
processCyclisedChain(group, previous);
}
}
}
/**
* Processes a spiro descriptor element.
* This modifies the provided chainGroup into the spiro system by replacing the value of the chain group with appropriate SMILES
* @param chainGroup
* @param spiroEl
* @throws ComponentGenerationException
* @throws NumberFormatException
*/
private void processSpiroSystem(Element chainGroup, Element spiroEl) throws NumberFormatException, ComponentGenerationException {
int[][] spiroDescriptors = getSpiroDescriptors(StringTools.removeDashIfPresent(spiroEl.getValue()));
Element multiplier =(Element)XOMTools.getPreviousSibling(spiroEl);
int numberOfSpiros = 1;
if (multiplier != null && multiplier.getLocalName().equals(MULTIPLIER_EL)){
numberOfSpiros = Integer.parseInt(multiplier.getAttributeValue(VALUE_ATR));
multiplier.detach();
}
int numberOfCarbonInDescriptors =0;
for (int[] spiroDescriptor : spiroDescriptors) {
numberOfCarbonInDescriptors += spiroDescriptor[0];
}
numberOfCarbonInDescriptors += numberOfSpiros;
if (numberOfCarbonInDescriptors != chainGroup.getAttributeValue(VALUE_ATR).length()){
throw new ComponentGenerationException("Disagreement between number of atoms in spiro descriptor: " + numberOfCarbonInDescriptors +" and number of atoms in chain: " + chainGroup.getAttributeValue(VALUE_ATR).length());
}
int numOfOpenedBrackets = 1;
int curIndex = 2;
String smiles = "C0" + StringTools.multiplyString("C", spiroDescriptors[0][0]) + "10(";
// for those molecules where no superstrings compare prefix number with curIndex.
for (int i=1; i< spiroDescriptors.length; i++) {
if (spiroDescriptors[i][1] >= 0) {
int ringOpeningPos = findIndexOfRingOpenings( smiles, spiroDescriptors[i][1] );
String ringOpeningLabel = String.valueOf(smiles.charAt(ringOpeningPos));
ringOpeningPos++;
if (ringOpeningLabel.equals("%")){
while (smiles.charAt(ringOpeningPos)>='0' && smiles.charAt(ringOpeningPos)<='9' && ringOpeningPos < smiles.length()) {
ringOpeningLabel += smiles.charAt(ringOpeningPos);
ringOpeningPos++;
}
}
if (smiles.indexOf("C" + ringOpeningLabel, ringOpeningPos)>=0) {
// this ring opening has already been closed
// i.e. this atom connects more than one ring in a spiro fusion
// insert extra ring opening
smiles = smiles.substring(0, ringOpeningPos) + ringClosure(curIndex) + smiles.substring(ringOpeningPos);
// add ring in new brackets
smiles += "(" + StringTools.multiplyString("C", spiroDescriptors[i][0]) + ringClosure(curIndex) + ")";
curIndex++;
}
else {
smiles += StringTools.multiplyString("C", spiroDescriptors[i][0]) + ringOpeningLabel + ")";
}
}
else if (numOfOpenedBrackets >= numberOfSpiros) {
smiles += StringTools.multiplyString("C", spiroDescriptors[i][0]);
// take the number before bracket as index for smiles
// we can open more brackets, this considered in prev if
curIndex--;
smiles += ringClosure(curIndex) + ")";
// from here start to decrease index for the following
}
else {
smiles += StringTools.multiplyString("C", spiroDescriptors[i][0]);
smiles += "C" + ringClosure(curIndex++) + "(";
numOfOpenedBrackets++;
}
}
chainGroup.getAttribute(VALUE_ATR).setValue(smiles);
chainGroup.getAttribute(TYPE_ATR).setValue(RING_TYPE_VAL);
if (chainGroup.getAttribute(USABLEASJOINER_ATR) !=null){
chainGroup.removeAttribute(chainGroup.getAttribute(USABLEASJOINER_ATR));
}
spiroEl.detach();
}
/**
* If the integer given is > 9 return %ringClosure else just returns ringClosure
* @param ringClosure
* @return
*/
private String ringClosure(int ringClosure) {
if (ringClosure >9){
return "%" +Integer.toString(ringClosure);
}
else{
return Integer.toString(ringClosure);
}
}
/**
* Prepares spiro string for processing
* @param text - string with spiro e.g. spiro[2.2]
* @return array with number of carbons in each group and associated index of spiro atom
*/
private int[][] getSpiroDescriptors(String text) {
if (text.indexOf("-")==5){
text= text.substring(7, text.length()-1);//cut off spiro-[ and terminal ]
}
else{
text= text.substring(6, text.length()-1);//cut off spiro[ and terminal ]
}
String[] spiroDescriptorStrings = matchCommaOrDot.split(text);
int[][] spiroDescriptors = new int[spiroDescriptorStrings.length][2]; // array of descriptors where number of elements and super string present
for (int i=0; i < spiroDescriptorStrings.length; i++) {
String[] elements = matchNonDigit.split(spiroDescriptorStrings[i]);
if (elements.length >1) {//a "superscripted" number is present
spiroDescriptors[i][0] = Integer.parseInt(elements[0]);
StringBuilder superScriptedNumber = new StringBuilder();
for (int j = 1; j < elements.length; j++){//may be more than one non digit as there are many ways of indicating superscripts
superScriptedNumber.append(elements[j]);
}
spiroDescriptors[i][1] = Integer.parseInt(superScriptedNumber.toString());
}
else {
spiroDescriptors[i][0] = Integer.parseInt(spiroDescriptorStrings[i]);
spiroDescriptors[i][1] = -1;
}
}
return spiroDescriptors;
}
/**
* Finds the the carbon atom with the given locant in the provided SMILES
* Returns the next index which is expected to correspond to the atom's ring opening/s
* @param smiles string to search in
* @param locant locant of the atom in given structure
* @return index of ring openings
* @throws ComponentGenerationException
*/
private Integer findIndexOfRingOpenings(String smiles, int locant) throws ComponentGenerationException{
int count = 0;
int pos = -1;
for (int i=0; i elementSymbolArray = new LinkedList();
if (chainEl.getAttributeValue(VALTYPE_ATR).equals(SMILES_VALTYPE_VAL)){
String smiles =chainEl.getAttributeValue(VALUE_ATR);
char[] smilesArray =smiles.toCharArray();
for (int i = 0; i < smilesArray.length; i++) {//only able to interpret the SMILES that should be in an unmodified unbranched chain
char currentChar =smilesArray[i];
if (currentChar == '['){
if ( smilesArray[i +2]==']'){
elementSymbolArray.add("[" +String.valueOf(smilesArray[i+1]) +"]");
i=i+2;
}
else{
elementSymbolArray.add("[" + String.valueOf(smilesArray[i+1]) +String.valueOf(smilesArray[i+2]) +"]");
i=i+3;
}
}
else{
elementSymbolArray.add(String.valueOf(currentChar));
}
}
alkylChainLength=elementSymbolArray.size();
}
else{
throw new ComponentGenerationException("unexpected group valType: " + chainEl.getAttributeValue(VALTYPE_ATR));
}
int totalLengthOfBridges=0;
int bridgeLabelsUsed=3;//start labelling from 3 upwards
//3 and 4 will be the atoms on each end of one secondary bridge, 5 and 6 for the next etc.
ArrayList> bridges = new ArrayList>();
HashMap> bridgeLocations = new HashMap>(alkylChainLength);
if (vonBaeyerBracket.indexOf("-")==5){
vonBaeyerBracket = vonBaeyerBracket.substring(7, vonBaeyerBracket.length()-1);//cut off cyclo-[ and terminal ]
}
else{
vonBaeyerBracket = vonBaeyerBracket.substring(6, vonBaeyerBracket.length()-1);//cut off cyclo[ and terminal ]
}
String[] bridgeDescriptors = matchCommaOrDot.split(vonBaeyerBracket);//the bridgelengths and positions for secondary bridges
//all bridges from past the first 3 are secondary bridges and require specification of bridge position which will be partially in the subsequent position in the array
for (int i = 0; i < bridgeDescriptors.length; i++) {
String bridgeDescriptor = bridgeDescriptors[i];
HashMap bridge = new HashMap();
int bridgeLength =0;
if (i > 2){//this is a secondary bridge (chain start/end locations should have been specified)
i++;
String coordinatesStr1;
String coordinatesStr2 = bridgeDescriptors[i].replaceAll("\\D", "");
String[] tempArray = bridgeDescriptor.split("\\D+");
if (tempArray.length ==1){
//there is some ambiguity as it has not been made obvious which number/s are supposed to be the superscripted locant
//so we assume that it is more likely that it will be referring to an atom of label >10
//rather than a secondary bridge of length > 10
char[] tempCharArray = bridgeDescriptor.toCharArray();
if (tempCharArray.length ==2){
bridgeLength= Character.getNumericValue(tempCharArray[0]);
coordinatesStr1= Character.toString(tempCharArray[1]);
}
else if (tempCharArray.length ==3){
bridgeLength= Character.getNumericValue(tempCharArray[0]);
coordinatesStr1=Character.toString(tempCharArray[1]) +Character.toString(tempCharArray[2]);
}
else if (tempCharArray.length ==4){
bridgeLength = Integer.parseInt(Character.toString(tempCharArray[0]) +Character.toString(tempCharArray[1]));
coordinatesStr1 = Character.toString(tempCharArray[2]) +Character.toString(tempCharArray[3]);
}
else{
throw new ComponentGenerationException("Unsupported Von Baeyer locant description: " + bridgeDescriptor );
}
}
else{//bracket or other delimiter detected, no ambiguity!
bridgeLength= Integer.parseInt(tempArray[0]);
coordinatesStr1= tempArray[1];
}
bridge.put("Bridge Length", bridgeLength );
int coordinates1=Integer.parseInt(coordinatesStr1);
int coordinates2=Integer.parseInt(coordinatesStr2);
if (coordinates1 > alkylChainLength || coordinates2 > alkylChainLength){
throw new ComponentGenerationException("Indicated bridge position is not on chain: " +coordinates1 +"," +coordinates2);
}
if (coordinates2>coordinates1){//makes sure that bridges are built from highest coord to lowest
int swap =coordinates1;
coordinates1=coordinates2;
coordinates2=swap;
}
if (bridgeLocations.get(coordinates1)==null){
bridgeLocations.put(coordinates1, new ArrayList());
}
if (bridgeLocations.get(coordinates2)==null){
bridgeLocations.put(coordinates2, new ArrayList());
}
bridgeLocations.get(coordinates1).add(bridgeLabelsUsed);
bridge.put("AtomId_Larger_Label", bridgeLabelsUsed);
bridgeLabelsUsed++;
if (bridgeLength==0){//0 length bridge, hence want atoms with the same labels so they can join together without a bridge
bridgeLocations.get(coordinates2).add(bridgeLabelsUsed -1);
bridge.put("AtomId_Smaller_Label", bridgeLabelsUsed -1);
}
else{
bridgeLocations.get(coordinates2).add(bridgeLabelsUsed);
bridge.put("AtomId_Smaller_Label", bridgeLabelsUsed);
}
bridgeLabelsUsed++;
bridge.put("AtomId_Larger", coordinates1);
bridge.put("AtomId_Smaller", coordinates2);
}
else{
bridgeLength= Integer.parseInt(bridgeDescriptor);
bridge.put("Bridge Length", bridgeLength);
}
totalLengthOfBridges += bridgeLength;
bridges.add(bridge);
}
if (totalLengthOfBridges + 2 !=alkylChainLength ){
throw new ComponentGenerationException("Disagreement between lengths of bridges and alkyl chain length");
}
if (numberOfRings +1 != bridges.size()){
throw new ComponentGenerationException("Disagreement between number of rings and number of bridges");
}
StringBuilder smilesSB = new StringBuilder();
int atomCounter=1;
int bridgeCounter=1;
//add standard bridges
for (HashMap bridge : bridges) {
if (bridgeCounter==1){
smilesSB.append(elementSymbolArray.removeFirst());
smilesSB.append("1");
if (bridgeLocations.get(atomCounter)!=null){
for (Integer bridgeAtomLabel : bridgeLocations.get(atomCounter)) {
smilesSB.append(ringClosure(bridgeAtomLabel));
}
}
smilesSB.append("(");
}
int bridgeLength =bridge.get("Bridge Length");
for (int i = 0; i < bridgeLength; i++) {
atomCounter++;
smilesSB.append(elementSymbolArray.removeFirst());
if (bridgeLocations.get(atomCounter)!=null){
for (Integer bridgeAtomLabel : bridgeLocations.get(atomCounter)) {
smilesSB.append(ringClosure(bridgeAtomLabel));
}
}
}
if (bridgeCounter==1){
atomCounter++;
smilesSB.append(elementSymbolArray.removeFirst());
smilesSB.append("2");
if (bridgeLocations.get(atomCounter)!=null){
for (Integer bridgeAtomLabel : bridgeLocations.get(atomCounter)) {
smilesSB.append(ringClosure(bridgeAtomLabel));
}
}
}
if (bridgeCounter==2){
smilesSB.append("1)");
}
if (bridgeCounter==3){
smilesSB.append("2");
}
bridgeCounter++;
if (bridgeCounter >3){break;}
}
//create list of secondary bridges that need to be added
//0 length bridges and the 3 main bridges are dropped
ArrayList> secondaryBridges = new ArrayList>();
for (HashMap bridge : bridges) {
if(bridge.get("AtomId_Larger")!=null && bridge.get("Bridge Length")!=0){
secondaryBridges.add(bridge);
}
}
Comparator> sortBridges= new VonBaeyerSecondaryBridgeSort();
Collections.sort(secondaryBridges, sortBridges);
ArrayList> dependantSecondaryBridges;
//add secondary bridges, recursively add dependent secondary bridges
do{
dependantSecondaryBridges = new ArrayList>();
for (HashMap bridge : secondaryBridges) {
int bridgeLength =bridge.get("Bridge Length");
if (bridge.get("AtomId_Larger") > atomCounter){
dependantSecondaryBridges.add(bridge);
continue;
}
smilesSB.append(".");
for (int i = 0; i < bridgeLength; i++) {
atomCounter++;
smilesSB.append(elementSymbolArray.removeFirst());
if (i==0){
smilesSB.append(ringClosure(bridge.get("AtomId_Larger_Label")));
}
if (bridgeLocations.get(atomCounter)!=null){
for (Integer bridgeAtomLabel : bridgeLocations.get(atomCounter)) {
smilesSB.append(ringClosure(bridgeAtomLabel));
}
}
}
smilesSB.append(ringClosure(bridge.get("AtomId_Smaller_Label")));
}
if (dependantSecondaryBridges.size() >0 && dependantSecondaryBridges.size()==secondaryBridges.size()){
throw new ComponentGenerationException("Unable to resolve all dependant bridges!!!");
}
secondaryBridges=dependantSecondaryBridges;
}
while(dependantSecondaryBridges.size() > 0);
chainEl.getAttribute(VALUE_ATR).setValue(smilesSB.toString());
chainEl.getAttribute(TYPE_ATR).setValue(RING_TYPE_VAL);
if (chainEl.getAttribute(USABLEASJOINER_ATR) !=null){
chainEl.removeAttribute(chainEl.getAttribute(USABLEASJOINER_ATR));
}
vonBaeyerBracketEl.detach();
}
/**
* Converts a chain group into a ring.
* The chain group can either be an alkane or heteroatom chain
* @param chainGroup
* @param cycloEl
* @throws ComponentGenerationException
*/
private void processCyclisedChain(Element chainGroup, Element cycloEl) throws ComponentGenerationException {
String smiles=chainGroup.getAttributeValue(VALUE_ATR);
int chainlen =0;
for (int i = smiles.length() -1 ; i >=0; i--) {
if (Character.isUpperCase(smiles.charAt(i)) && smiles.charAt(i) !='H'){
chainlen++;
}
}
if (chainlen < 3){
throw new ComponentGenerationException("Heteroatom chain too small to create a ring: " + chainlen);
}
smiles+="1";
if (smiles.charAt(0)=='['){
int closeBracketIndex = smiles.indexOf(']');
smiles= smiles.substring(0, closeBracketIndex +1) +"1" + smiles.substring(closeBracketIndex +1);
}
else{
if (Character.getType(smiles.charAt(1)) == Character.LOWERCASE_LETTER){//element is 2 letters long
smiles= smiles.substring(0,2) +"1" + smiles.substring(2);
}
else{
smiles= smiles.substring(0,1) +"1" + smiles.substring(1);
}
}
chainGroup.getAttribute(VALUE_ATR).setValue(smiles);
if (chainlen==6){//6 membered rings have ortho/meta/para positions
if (chainGroup.getAttribute(LABELS_ATR)!=null){
chainGroup.getAttribute(LABELS_ATR).setValue("1/2,ortho/3,meta/4,para/5/6");
}
else{
chainGroup.addAttribute(new Attribute(LABELS_ATR, "1/2,ortho/3,meta/4,para/5/6"));
}
}
chainGroup.getAttribute(TYPE_ATR).setValue(RING_TYPE_VAL);
if (chainGroup.getAttribute(USABLEASJOINER_ATR) !=null){
chainGroup.removeAttribute(chainGroup.getAttribute(USABLEASJOINER_ATR));
}
cycloEl.detach();
}
/**Handles special cases in IUPAC nomenclature.
* Benzyl etc.
* @param group The group to look for irregularities in.
* @throws ComponentGenerationException
*/
private void handleGroupIrregularities(Element group) throws ComponentGenerationException {
String groupValue =group.getValue();
if (!n2sConfig.allowInterpretationOfAcidsWithoutTheWordAcid()) {
if (group.getAttribute(FUNCTIONALIDS_ATR) !=null && (groupValue.endsWith("ic") || groupValue.endsWith("ous"))){
Node next = XOMTools.getNext(group);
if (next == null){
throw new ComponentGenerationException("\"acid\" not found after " +groupValue);
}
}
}
if(groupValue.equals("thiophen") || groupValue.equals("selenophen") || groupValue.equals("tellurophen")) {//thiophenol is generally phenol with an O replaced with S not thiophene with a hydroxy
Element possibleSuffix = (Element) XOMTools.getNextSibling(group);
if (!"e".equals(group.getAttributeValue(SUBSEQUENTUNSEMANTICTOKEN_ATR)) && possibleSuffix !=null && possibleSuffix.getLocalName().equals(SUFFIX_EL)) {
if (possibleSuffix.getValue().startsWith("ol")){
Element isThisALocant =(Element)XOMTools.getPreviousSibling(group);
if (isThisALocant == null || !isThisALocant.getLocalName().equals(LOCANT_EL) || MATCH_COMMA.split(isThisALocant.getValue()).length != 1){
throw new ComponentGenerationException(groupValue + "ol has been incorrectly interpreted as "+ groupValue+", ol instead of phenol with the oxgen replaced");
}
}
}
}
else if (groupValue.equals("methylene") || groupValue.equals("methylen")) {//e.g. 3,4-methylenedioxyphenyl
Element nextSub = (Element) XOMTools.getNextSibling(group.getParent());
if (nextSub !=null && nextSub.getLocalName().equals(SUBSTITUENT_EL) && XOMTools.getNextSibling(group)==null
&& (XOMTools.getPreviousSibling(group)==null || !((Element)XOMTools.getPreviousSibling(group)).getLocalName().equals(MULTIPLIER_EL))){//not trimethylenedioxy
Elements children = nextSub.getChildElements();
if (children.size() >=2 && children.get(0).getValue().equals("di")&& children.get(1).getValue().equals("oxy")){
XOMTools.setTextChild(group, groupValue + "dioxy");
group.getAttribute(VALUE_ATR).setValue("C(O)O");
group.getAttribute(VALTYPE_ATR).setValue(SMILES_VALTYPE_VAL);
group.getAttribute(OUTIDS_ATR).setValue("2,3");
group.getAttribute(SUBTYPE_ATR).setValue(EPOXYLIKE_SUBTYPE_VAL);
if (group.getAttribute(LABELS_ATR)!=null){
group.getAttribute(LABELS_ATR).setValue(NONE_LABELS_VAL);
}
else{
group.addAttribute(new Attribute(LABELS_ATR, NONE_SUBTYPE_VAL));
}
nextSub.detach();
for (int i = children.size() -1 ; i >=2; i--) {
children.get(i).detach();
XOMTools.insertAfter(group, children.get(i));
}
}
}
}
else if (groupValue.equals("ethylene") || groupValue.equals("ethylen")) {
Element previous = (Element)XOMTools.getPreviousSibling(group);
if (previous!=null && previous.getLocalName().equals(MULTIPLIER_EL)){
int multiplierValue = Integer.parseInt(previous.getAttributeValue(VALUE_ATR));
Element possibleRoot =(Element) XOMTools.getNextSibling(group.getParent());
if (possibleRoot==null && OpsinTools.getParentWordRule(group).getAttributeValue(WORDRULE_ATR).equals(WordRule.glycol.toString())){//e.g. dodecaethylene glycol
StringBuilder smiles = new StringBuilder("CC");
for (int i = 1; i < multiplierValue; i++) {
smiles.append("OCC");
}
group.getAttribute(OUTIDS_ATR).setValue("1," +Integer.toString(3*(multiplierValue-1) +2));
group.getAttribute(VALUE_ATR).setValue(smiles.toString());
previous.detach();
if (group.getAttribute(LABELS_ATR)!=null){//use numeric numbering
group.getAttribute(LABELS_ATR).setValue(NUMERIC_LABELS_VAL);
}
else{
group.addAttribute(new Attribute(LABELS_ATR, NUMERIC_LABELS_VAL));
}
}
else if (possibleRoot!=null && possibleRoot.getLocalName().equals(ROOT_EL)){
Elements children = possibleRoot.getChildElements();
if (children.size()==2){
Element amineMultiplier =children.get(0);
Element amine =children.get(1);
if (amineMultiplier.getLocalName().equals(MULTIPLIER_EL) && (amine.getValue().equals("amine") || amine.getValue().equals("amin"))){//e.g. Triethylenetetramine
if (Integer.parseInt(amineMultiplier.getAttributeValue(VALUE_ATR))!=multiplierValue +1){
throw new ComponentGenerationException("Invalid polyethylene amine!");
}
StringBuilder smiles = new StringBuilder();
for (int i = 0; i < multiplierValue; i++) {
smiles.append("NCC");
}
smiles.append("N");
group.removeAttribute(group.getAttribute(OUTIDS_ATR));
group.getAttribute(VALUE_ATR).setValue(smiles.toString());
previous.detach();
possibleRoot.detach();
((Element)group.getParent()).setLocalName(ROOT_EL);
if (group.getAttribute(LABELS_ATR)!=null){//use numeric numbering
group.getAttribute(LABELS_ATR).setValue(NUMERIC_LABELS_VAL);
}
else{
group.addAttribute(new Attribute(LABELS_ATR, NUMERIC_LABELS_VAL));
}
}
}
}
}
else{
Element nextSub = (Element) XOMTools.getNextSibling(group.getParent());
if (nextSub !=null && nextSub.getLocalName().equals(SUBSTITUENT_EL) && XOMTools.getNextSibling(group)==null){
Elements children = nextSub.getChildElements();
if (children.size() >=2 && children.get(0).getValue().equals("di")&& children.get(1).getValue().equals("oxy")){
XOMTools.setTextChild(group, groupValue + "dioxy");
group.getAttribute(VALUE_ATR).setValue("C(O)CO");
group.getAttribute(VALTYPE_ATR).setValue(SMILES_VALTYPE_VAL);
group.getAttribute(OUTIDS_ATR).setValue("2,4");
group.getAttribute(SUBTYPE_ATR).setValue(EPOXYLIKE_SUBTYPE_VAL);
if (group.getAttribute(LABELS_ATR)!=null){
group.getAttribute(LABELS_ATR).setValue(NONE_LABELS_VAL);
}
else{
group.addAttribute(new Attribute(LABELS_ATR, NONE_SUBTYPE_VAL));
}
nextSub.detach();
for (int i = children.size() -1 ; i >=2; i--) {
children.get(i).detach();
XOMTools.insertAfter(group, children.get(i));
}
}
}
}
}
else if (groupValue.equals("propylene") || groupValue.equals("propylen")) {
Element previous = (Element)XOMTools.getPreviousSibling(group);
if (previous!=null && previous.getLocalName().equals(MULTIPLIER_EL)){
int multiplierValue = Integer.parseInt(previous.getAttributeValue(VALUE_ATR));
Element possibleRoot =(Element) XOMTools.getNextSibling(group.getParent());
if (possibleRoot==null && OpsinTools.getParentWordRule(group).getAttributeValue(WORDRULE_ATR).equals(WordRule.glycol.toString())){//e.g. dodecaethylene glycol
StringBuilder smiles =new StringBuilder("CCC");
for (int i = 1; i < multiplierValue; i++) {
smiles.append("OC(C)C");
}
group.getAttribute(OUTIDS_ATR).setValue("2," +Integer.toString(4*(multiplierValue-1) +3));
group.getAttribute(VALUE_ATR).setValue(smiles.toString());
if (group.getAttribute(LABELS_ATR)!=null){
group.getAttribute(LABELS_ATR).setValue(NONE_LABELS_VAL);
}
else{
group.addAttribute(new Attribute(LABELS_ATR, NONE_LABELS_VAL));
}
previous.detach();
}
}
}
//acridone (not codified), anthrone, phenanthrone and xanthone have the one at position 9 by default
else if (groupValue.equals("anthr") || groupValue.equals("phenanthr") || groupValue.equals("acrid") ||
groupValue.equals("xanth") || groupValue.equals("thioxanth") || groupValue.equals("selenoxanth")|| groupValue.equals("telluroxanth")|| groupValue.equals("xanthen")) {
Element possibleLocant = (Element) XOMTools.getPreviousSibling(group);
if (possibleLocant==null || !possibleLocant.getLocalName().equals(LOCANT_EL)){//only need to give one a locant of 9 if no locant currently present
Element possibleSuffix =(Element) XOMTools.getNextSibling(group);
if (possibleSuffix!=null && "one".equals(possibleSuffix.getAttributeValue(VALUE_ATR))){
//Rule C-315.2
Element newLocant =new Element(LOCANT_EL);
newLocant.appendChild("9");
XOMTools.insertBefore(possibleSuffix, newLocant);
Element newAddedHydrogen = new Element(ADDEDHYDROGEN_EL);
newAddedHydrogen.addAttribute(new Attribute(LOCANT_ATR, "10"));
XOMTools.insertBefore(newLocant, newAddedHydrogen);
}
else if (possibleSuffix!=null && possibleSuffix.getLocalName().equals(SUFFIX_EL) &&
groupValue.equals("xanth") || groupValue.equals("thioxanth") || groupValue.equals("selenoxanth")|| groupValue.equals("telluroxanth")){
//diasambiguate between xanthate/xanthic acid and xanthene
String suffixVal = possibleSuffix.getAttributeValue(VALUE_ATR);
if (suffixVal.equals("ic") || suffixVal.equals("ate")){
throw new ComponentGenerationException(groupValue + possibleSuffix.getValue() +" is not a derivative of xanthene");
}
}
}
}
else if (groupValue.equals("phospho")){//is this the organic meaning (P(=O)=O) or biochemical meaning (P(=O)(O)O)
Element substituent = (Element) group.getParent();
Element nextSubstituent = (Element) XOMTools.getNextSibling(substituent);
if (nextSubstituent !=null){
Element nextGroup = nextSubstituent.getFirstChildElement(GROUP_EL);
String type = nextGroup.getAttributeValue(TYPE_ATR);
String subType = nextGroup.getAttributeValue(SUBTYPE_ATR);
if (nextGroup !=null && (type.equals(AMINOACID_TYPE_VAL) ||
type.equals(CARBOHYDRATE_TYPE_VAL) ||
BIOCHEMICAL_SUBTYPE_VAL.equals(subType) ||
(YLFORACYL_SUBTYPE_VAL.equals(subType) &&
("glycol".equals(nextGroup.getValue()) || "diglycol".equals(nextGroup.getValue())))
)){
group.getAttribute(VALUE_ATR).setValue("-P(=O)(O)O");
group.addAttribute(new Attribute(USABLEASJOINER_ATR, "yes"));
}
}
}
else if (groupValue.equals("aspart") || groupValue.equals("glutam")){//aspartyl and glutamyl typically mean alpha-aspartyl/alpha-glutamyl
if (group.getAttributeValue(SUBTYPE_ATR).equals(ENDINIC_SUBTYPE_VAL)){
Element yl = (Element) XOMTools.getNextSibling(group);
if (yl.getAttributeValue(VALUE_ATR).equals("yl")){
group.removeAttribute(group.getAttribute(SUFFIXAPPLIESTO_ATR));
if (groupValue.equals("aspart")){
group.getAttribute("labels").setValue("/2,alpha/3,beta/4,gamma///1/");
group.getAttribute(VALUE_ATR).setValue("N[C@@H](CC(O)=O)C=O");
group.addAttribute(new Attribute(OUTIDS_ATR, "7"));
}
else {
group.getAttribute("labels").setValue("/2,alpha/3,beta/4,gamma/5,delta///1/");
group.getAttribute(VALUE_ATR).setValue("N[C@@H](CCC(O)=O)C=O");
group.addAttribute(new Attribute(OUTIDS_ATR, "8"));
}
yl.detach();
}
}
}
else if (groupValue.equals("hydrogen")){
Element hydrogenParentEl = (Element) group.getParent();
Element nextSubOrRoot = (Element) XOMTools.getNextSibling(hydrogenParentEl);
if (nextSubOrRoot!=null){
Element possibleSuitableAteGroup = (Element) nextSubOrRoot.getChild(0);
if (!possibleSuitableAteGroup.getLocalName().equals(GROUP_EL) || !NONCARBOXYLICACID_TYPE_VAL.equals(possibleSuitableAteGroup.getAttributeValue(TYPE_ATR))){
throw new ComponentGenerationException("Hydrogen is not meant as a substituent in this context!");
}
Element possibleMultiplier = (Element) XOMTools.getPreviousSibling(group);
String multiplier = "1";
if (possibleMultiplier!=null && possibleMultiplier.getLocalName().equals(MULTIPLIER_EL)){
multiplier = possibleMultiplier.getAttributeValue(VALUE_ATR);
possibleMultiplier.detach();
}
possibleSuitableAteGroup.addAttribute(new Attribute(NUMBEROFFUNCTIONALATOMSTOREMOVE_ATR, multiplier));
group.detach();
Elements childrenToMove = hydrogenParentEl.getChildElements();
for (int i = childrenToMove.size() -1 ; i >=0; i--) {
childrenToMove.get(i).detach();
nextSubOrRoot.insertChild(childrenToMove.get(i), 0);
}
hydrogenParentEl.detach();
}
}
else if (groupValue.equals("acryl")){
if (SIMPLESUBSTITUENT_SUBTYPE_VAL.equals(group.getAttributeValue(SUBTYPE_ATR))){
Element nextEl = (Element) XOMTools.getNext(group);
if (nextEl!=null && nextEl.getValue().equals("amid")){
throw new ComponentGenerationException("amide in acrylamide is not [NH2-]");
}
}
}
else if (groupValue.equals("azo") || groupValue.equals("azoxy") || groupValue.equals("nno-azoxy") || groupValue.equals("non-azoxy") || groupValue.equals("onn-azoxy") || groupValue.equals("diazoamino") || groupValue.equals("hydrazo") ){
Element enclosingSub = (Element) group.getParent();
Element next = XOMTools.getNextSiblingIgnoringCertainElements(enclosingSub, new String[]{HYPHEN_EL});
if (next==null && XOMTools.getPreviousSibling(enclosingSub)==null){//e.g. [(E)-NNO-azoxy]benzene
next = XOMTools.getNextSiblingIgnoringCertainElements((Element) enclosingSub.getParent(), new String[]{HYPHEN_EL});
}
if (next!=null && next.getLocalName().equals(ROOT_EL)){
if (!(((Element)next.getChild(0)).getLocalName().equals(MULTIPLIER_EL))){
List suffixes = XOMTools.getChildElementsWithTagName(next, SUFFIX_EL);
if (suffixes.size()==0){//only case without locants is handled so far. suffixes only apply to one of the fragments rather than both!!!
Element newMultiplier = new Element(MULTIPLIER_EL);
newMultiplier.addAttribute(new Attribute(VALUE_ATR, "2"));
next.insertChild(newMultiplier, 0);
Element interSubstituentHyphen = (Element) XOMTools.getPrevious(group);
if (interSubstituentHyphen!=null && !interSubstituentHyphen.getLocalName().equals(HYPHEN_EL)){//prevent implicit bracketting
XOMTools.insertAfter(interSubstituentHyphen, new Element(HYPHEN_EL));
}
}
}
}
}
else if (groupValue.equals("coenzyme a") || groupValue.equals("coa")){
Element enclosingSubOrRoot = (Element) group.getParent();
Element previous = (Element) XOMTools.getPreviousSibling(enclosingSubOrRoot);
if (previous!=null){
List groups = XOMTools.getDescendantElementsWithTagName(previous, GROUP_EL);
if (groups.size()>0){
Element possibleAcid = groups.get(groups.size()-1);
if (ACIDSTEM_TYPE_VAL.equals(possibleAcid.getAttributeValue(TYPE_ATR))){
if (possibleAcid.getAttribute(SUFFIXAPPLIESTO_ATR)!=null){//multi acid. yl should be one oyl and the rest carboxylic acids
Element suffix = (Element) XOMTools.getNextSibling(possibleAcid, SUFFIX_EL);
if (suffix.getAttribute(ADDITIONALVALUE_ATR)==null){
suffix.addAttribute(new Attribute(ADDITIONALVALUE_ATR, "ic"));
}
}
String subType = possibleAcid.getAttributeValue(SUBTYPE_ATR);
if (subType.equals(YLFORYL_SUBTYPE_VAL) || subType.equals(YLFORNOTHING_SUBTYPE_VAL)){
possibleAcid.getAttribute(SUBTYPE_ATR).setValue(YLFORACYL_SUBTYPE_VAL);//yl always means an acyl when next to coenzyme A
}
}
}
}
//locanted substitution onto Coenzyme A is rarely intended, so put it in a bracket to disfavour it
Element newBracket = new Element(BRACKET_EL);
XOMTools.insertAfter(enclosingSubOrRoot, newBracket);
enclosingSubOrRoot.detach();
newBracket.appendChild(enclosingSubOrRoot);
}
else if (groupValue.equals("sphinganine") || groupValue.equals("icosasphinganine") || groupValue.equals("eicosasphinganine") || groupValue.equals("phytosphingosine") || groupValue.equals("sphingosine")){
Element enclosingSubOrRoot = (Element) group.getParent();
Element previous = (Element) XOMTools.getPreviousSibling(enclosingSubOrRoot);
if (previous!=null){
List groups = XOMTools.getDescendantElementsWithTagName(previous, GROUP_EL);
if (groups.size()>0){
Element possibleAcid = groups.get(groups.size()-1);
if (ALKANESTEM_SUBTYPE_VAL.equals(possibleAcid.getAttributeValue(SUBTYPE_ATR))){
List inlineSuffixes = XOMTools.getChildElementsWithTagNameAndAttribute((Element) possibleAcid.getParent(), SUFFIX_EL, TYPE_ATR, INLINE_TYPE_VAL);
if (inlineSuffixes.size()==1 && inlineSuffixes.get(0).getAttributeValue(VALUE_ATR).equals("yl")){
inlineSuffixes.get(0).getAttribute(VALUE_ATR).setValue("oyl");//yl on a systematic acid next to a fatty acid means acyl
//c.f. Nomenclature of Lipids 1976, Appendix A, note a
}
}
}
}
}
else if (groupValue.equals("sel")){
//check that it is not "selenium"
if (HETEROSTEM_SUBTYPE_VAL.equals(group.getAttributeValue(SUBTYPE_ATR)) && group.getAttribute(SUBSEQUENTUNSEMANTICTOKEN_ATR) ==null){
Element unsaturator = (Element) XOMTools.getNextSibling(group);
if (unsaturator !=null && unsaturator.getLocalName().equals(UNSATURATOR_EL) && unsaturator.getValue().equals("en") && group.getAttribute(SUBSEQUENTUNSEMANTICTOKEN_ATR) ==null){
Element ium = (Element) XOMTools.getNextSibling(unsaturator);
if (ium !=null && ium.getLocalName().equals(SUFFIX_EL) && ium.getValue().equals("ium")){
throw new ComponentGenerationException("selenium does not indicate a chain of selenium atoms with a double bond and a positive charge");
}
}
}
}
else if ((groupValue.equals("keto") || groupValue.equals("aldehydo")) && SIMPLESUBSTITUENT_SUBTYPE_VAL.equals(group.getAttributeValue(SUBTYPE_ATR))){
//check for case where this is specifying the open chain form of a ketose/aldose
Element previousEl = (Element) XOMTools.getPreviousSibling(group);
if (previousEl ==null || !previousEl.getLocalName().equals(LOCANT_EL) || groupValue.equals("aldehydo")){
Element parentSubstituent = (Element) group.getParent();
Element nextSubOrRoot = (Element) XOMTools.getNextSibling(parentSubstituent);
Element parentOfCarbohydate = nextSubOrRoot;
Element carbohydrate = null;
while (parentOfCarbohydate != null){
Element possibleCarbohydrate = parentOfCarbohydate.getFirstChildElement(GROUP_EL);
if (possibleCarbohydrate !=null && possibleCarbohydrate.getAttributeValue(TYPE_ATR).equals(CARBOHYDRATE_TYPE_VAL)){
carbohydrate = possibleCarbohydrate;
break;
}
parentOfCarbohydate = (Element) XOMTools.getNextSibling(parentOfCarbohydate);
}
if (carbohydrate != null) {
if (XOMTools.getChildElementsWithTagName(parentOfCarbohydate, CARBOHYDRATERINGSIZE_EL).size() > 0){
throw new ComponentGenerationException("Carbohydrate has a specified ring size but " + groupValue + " indicates the open chain form!");
}
group.detach();
Elements childrenToMove = parentSubstituent.getChildElements();
for (int i = childrenToMove.size() -1 ; i >=0; i--) {
Element el = childrenToMove.get(i);
if (!el.getLocalName().equals(HYPHEN_EL)){
el.detach();
nextSubOrRoot.insertChild(el, 0);
}
}
parentSubstituent.detach();
String carbohydrateAdditionValue = carbohydrate.getAttributeValue(ADDITIONALVALUE_ATR);
//OPSIN assumes a few trival names are more likely to describe the cyclic form. additonalValue contains the SMILES for the acyclic form
if (carbohydrateAdditionValue != null){
if (carbohydrateAdditionValue.equals("n/a")){
throw new ComponentGenerationException(carbohydrate.getValue() + " can only describe the cyclic form but " + groupValue + " indicates the open chain form!");
}
carbohydrate.getAttribute(VALUE_ATR).setValue(carbohydrateAdditionValue);
}
}
else if (groupValue.equals("aldehydo")){
throw new ComponentGenerationException("aldehydo is only a valid prefix when it precedes a carbohydrate!");
}
}
}
else if (groupValue.equals("bor") || groupValue.equals("antimon")
|| groupValue.equals("arsen") || groupValue.equals("phosphor") || groupValue.equals("phosphate")
|| groupValue.equals("silicicacid") || groupValue.equals("silicic acid")
|| groupValue.equals("silicate")){//fluoroboric acid/fluoroborate are trivial rather than systematic; tetra(fooyl)borate is inorganic
Element suffix = null;
Boolean isAcid = null;
if (groupValue.endsWith("acid")){
if (XOMTools.getNext(group) == null){
isAcid = true;
}
}
else if (groupValue.endsWith("ate")){
if (XOMTools.getNext(group) == null){
isAcid = false;
}
}
else{
suffix = (Element) XOMTools.getNextSibling(group);
if (suffix != null && suffix.getLocalName().equals(SUFFIX_EL) &&
suffix.getAttribute(INFIX_ATR) == null && XOMTools.getNext(suffix) == null){
String suffixValue = suffix.getAttributeValue(VALUE_ATR);
if (suffixValue.equals("ic")){
isAcid = true;
}
else if (suffixValue.equals("ate")){
isAcid = false;
}
}
}
if (isAcid != null){//check for inorganic interpretation
Element substituent = (Element) XOMTools.getPreviousSibling(group.getParent());
if (substituent !=null && (substituent.getLocalName().equals(SUBSTITUENT_EL) || substituent.getLocalName().equals(BRACKET_EL))){
Elements children = substituent.getChildElements();
Element firstChild = children.get(0);
boolean matched = false;
if (children.size() ==1 && firstChild.getLocalName().equals(GROUP_EL) && (firstChild.getValue().equals("fluoro") || firstChild.getValue().equals("fluor"))){
if (groupValue.equals("bor")) {
group.getAttribute(VALUE_ATR).setValue(isAcid ? "F[B-](F)(F)F.[H+]" : "F[B-](F)(F)F");
matched = true;
}
else if (groupValue.equals("antimon")) {
group.getAttribute(VALUE_ATR).setValue(isAcid ? "F[Sb-](F)(F)(F)(F)F.[H+]" : "F[Sb-](F)(F)(F)(F)F");
matched = true;
}
else if (groupValue.startsWith("silicic")) {
group.getAttribute(VALUE_ATR).setValue(isAcid ? "F[Si|6-2](F)(F)(F)(F)F.[H+].[H+]" : "F[Si|6-2](F)(F)(F)(F)F");
matched = true;
}
if (matched) {
substituent.detach();
}
}
else if (firstChild.getLocalName().equals(MULTIPLIER_EL)) {
String multiplerVal = firstChild.getAttributeValue(VALUE_ATR);
if (groupValue.equals("bor") && multiplerVal.equals("4")) {
group.getAttribute(VALUE_ATR).setValue(isAcid ? "[B-].[H+]" :"[B-]");
matched = true;
}
else if (groupValue.equals("antimon") && multiplerVal.equals("6")) {
group.getAttribute(VALUE_ATR).setValue(isAcid ? "[Sb-].[H+]" :"[Sb-]");
matched = true;
}
else if (groupValue.equals("arsen") && multiplerVal.equals("6")) {
group.getAttribute(VALUE_ATR).setValue(isAcid ? "[As-].[H+]" :"[As-]");
matched = true;
}
else if (groupValue.startsWith("phosph") && multiplerVal.equals("6")) {
group.getAttribute(VALUE_ATR).setValue(isAcid ? "[P-].[H+]" :"[P-]");
matched = true;
}
else if (groupValue.startsWith("silic") && multiplerVal.equals("6")) {
group.getAttribute(VALUE_ATR).setValue(isAcid ? "[Si|6-2].[H+].[H+]" :"[Si|6-2]");
matched = true;
}
}
if (matched) {
group.getAttribute(TYPE_ATR).setValue(SIMPLEGROUP_TYPE_VAL);
group.getAttribute(SUBTYPE_ATR).setValue(SIMPLEGROUP_SUBTYPE_VAL);
Attribute usableAsJoiner = group.getAttribute(USABLEASJOINER_ATR);
if (usableAsJoiner != null){
group.removeAttribute(usableAsJoiner);
}
Attribute acceptsAdditiveBonds = group.getAttribute(ACCEPTSADDITIVEBONDS_ATR);
if (acceptsAdditiveBonds != null){
group.removeAttribute(acceptsAdditiveBonds);
}
Attribute functionalIds = group.getAttribute(FUNCTIONALIDS_ATR);
if (functionalIds != null){
group.removeAttribute(functionalIds);
}
if (suffix != null){
suffix.detach();
}
}
}
}
}
}
}
dan2097-opsin-12cfaef8a36f/opsin-core/src/main/java/uk/ac/cam/ch/wwmm/opsin/ComponentProcessor.java 0000644 0000000 0000000 00000720727 12172764765 031125 0 ustar 0000000 0000000 package uk.ac.cam.ch.wwmm.opsin;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static uk.ac.cam.ch.wwmm.opsin.XmlDeclarations.*;
import static uk.ac.cam.ch.wwmm.opsin.OpsinTools.*;
import nu.xom.Attribute;
import nu.xom.Element;
import nu.xom.Elements;
import nu.xom.Node;
/**Performs structure-aware destructive procedural parsing on parser results.
*
* @author dl387
*
*/
class ComponentProcessor {
private final static Pattern matchAddedHydrogenBracket =Pattern.compile("[\\[\\(\\{]([^\\[\\(\\{]*)H[\\]\\)\\}]");
private final static Pattern matchElementSymbolOrAminoAcidLocant = Pattern.compile("[A-Z][a-z]?'*(\\d+[a-z]?'*)?");
private final static Pattern matchChalcogenReplacement= Pattern.compile("thio|seleno|telluro");
private final static Pattern matchInlineSuffixesThatAreAlsoGroups = Pattern.compile("carbon|oxy|sulfen|sulfin|sulfon|selenen|selenin|selenon|telluren|tellurin|telluron");
private final static String[] traditionalAlkanePositionNames =new String[]{"alpha", "beta", "gamma", "delta", "epsilon", "zeta"};
private final SuffixRules suffixRules;
private final BuildState state;
private final Element parse;
//rings that look like HW rings but have other meanings. For the HW like inorganics the true meaning is given
private static final HashMap specialHWRings = new HashMap();
static{
//The first entry of the array is a special instruction e.g. blocked or saturated. The correct order of the heteroatoms follows
//terminal e is ignored from all of the keys as it is optional in the input name
specialHWRings.put("oxin", new String[]{"blocked"});
specialHWRings.put("azin", new String[]{"blocked"});
specialHWRings.put("selenin", new String[]{"not_icacid", "Se","C","C","C","C","C"});
specialHWRings.put("tellurin", new String[]{"not_icacid", "Te","C","C","C","C","C"});
specialHWRings.put("thiol", new String[]{"not_nothingOrOlate", "S","C","C","C","C"});
specialHWRings.put("selenol", new String[]{"not_nothingOrOlate", "Se","C","C","C","C"});
specialHWRings.put("tellurol", new String[]{"not_nothingOrOlate", "Te","C","C","C","C"});
specialHWRings.put("oxazol", new String[]{"","O","C","N","C","C"});
specialHWRings.put("thiazol", new String[]{"","S","C","N","C","C"});
specialHWRings.put("selenazol", new String[]{"","Se","C","N","C","C"});
specialHWRings.put("tellurazol", new String[]{"","Te","C","N","C","C"});
specialHWRings.put("oxazolidin", new String[]{"","O","C","N","C","C"});
specialHWRings.put("thiazolidin", new String[]{"","S","C","N","C","C"});
specialHWRings.put("selenazolidin", new String[]{"","Se","C","N","C","C"});
specialHWRings.put("tellurazolidin", new String[]{"","Te","C","N","C","C"});
specialHWRings.put("oxazolid", new String[]{"","O","C","N","C","C"});
specialHWRings.put("thiazolid", new String[]{"","S","C","N","C","C"});
specialHWRings.put("selenazolid", new String[]{"","Se","C","N","C","C"});
specialHWRings.put("tellurazolid", new String[]{"","Te","C","N","C","C"});
specialHWRings.put("oxazolin", new String[]{"","O","C","N","C","C"});
specialHWRings.put("thiazolin", new String[]{"","S","C","N","C","C"});
specialHWRings.put("selenazolin", new String[]{"","Se","C","N","C","C"});
specialHWRings.put("tellurazolin", new String[]{"","Te","C","N","C","C"});
specialHWRings.put("oxoxolan", new String[]{"","O","C","O","C","C"});
specialHWRings.put("oxoxan", new String[]{"","O","C","C","O","C","C"});
specialHWRings.put("oxoxin", new String[]{"","O","C","C","O","C","C"});
specialHWRings.put("boroxin", new String[]{"saturated","O","B","O","B","O","B"});
specialHWRings.put("borazin", new String[]{"saturated","N","B","N","B","N","B"});
specialHWRings.put("borthiin", new String[]{"saturated","S","B","S","B","S","B"});
}
public ComponentProcessor(SuffixRules suffixRules, BuildState state, Element parse) {
this.suffixRules = suffixRules;
this.state = state;
this.parse = parse;
}
/**
* Processes a parse result that has already gone through the ComponentGenerator.
* At this stage one can expect all substituents/roots to have at least 1 group.
* Multiple groups are present in, for example, fusion nomenclature. By the end of this function there will be exactly 1 group
* associated with each substituent/root. Multiplicative nomenclature can result in there being multiple roots
* @throws ComponentGenerationException
* @throws StructureBuildingException
*/
void processParse() throws ComponentGenerationException, StructureBuildingException {
List words =XOMTools.getDescendantElementsWithTagName(parse, WORD_EL);
int wordCount =words.size();
for (int i = wordCount -1; i>=0; i--) {
Element word =words.get(i);
String wordRule = OpsinTools.getParentWordRule(word).getAttributeValue(WORDRULE_EL);
state.currentWordRule = WordRule.valueOf(wordRule);
if (word.getAttributeValue(TYPE_ATR).equals(WordType.functionalTerm.toString())){
continue;//functionalTerms are handled on a case by case basis by wordRules
}
List roots = XOMTools.getDescendantElementsWithTagName(word, ROOT_EL);
if (roots.size() >1){
throw new ComponentGenerationException("Multiple roots, but only 0 or 1 were expected. Found: " +roots.size());
}
List substituents = XOMTools.getDescendantElementsWithTagName(word, SUBSTITUENT_EL);
List substituentsAndRoot = OpsinTools.combineElementLists(substituents, roots);
List brackets = XOMTools.getDescendantElementsWithTagName(word, BRACKET_EL);
List substituentsAndRootAndBrackets =OpsinTools.combineElementLists(substituentsAndRoot, brackets);
List groups = XOMTools.getDescendantElementsWithTagName(word, GROUP_EL);
for (Element group : groups) {
Fragment thisFrag = resolveGroup(state, group);
processChargeAndOxidationNumberSpecification(group, thisFrag);//e.g. mercury(2+) or mercury(II)
state.xmlFragmentMap.put(group, thisFrag);
}
for (Element subOrRoot : substituentsAndRoot) {
applyDLPrefixes(subOrRoot);
processCarbohydrates(subOrRoot);//e.g. glucopyranose (needs to be done before determineLocantMeaning to cope with alpha,beta for undefined anomer stereochemistry)
}
for (int j = substituents.size() -1; j >=0; j--) {
Element substituent = substituents.get(j);
boolean removed = removeAndMoveToAppropriateGroupIfHydroSubstituent(substituent);//this REMOVES a substituent just containing hydro/perhydro elements and moves these elements in front of an appropriate ring
if (!removed){
removed = removeAndMoveToAppropriateGroupIfSubtractivePrefix(substituent);
}
if (removed){
substituents.remove(j);
substituentsAndRoot.remove(substituent);
substituentsAndRootAndBrackets.remove(substituent);
}
}
Element finalSubOrRootInWord =(Element) word.getChild(word.getChildElements().size()-1);
while (!finalSubOrRootInWord.getLocalName().equals(ROOT_EL) && !finalSubOrRootInWord.getLocalName().equals(SUBSTITUENT_EL)){
List children = XOMTools.getChildElementsWithTagNames(finalSubOrRootInWord, new String[]{ROOT_EL, SUBSTITUENT_EL, BRACKET_EL});
if (children.size()==0){
throw new ComponentGenerationException("Unable to find finalSubOrRootInWord");
}
finalSubOrRootInWord = children.get(children.size()-1);
}
for (Element subOrRootOrBracket : substituentsAndRootAndBrackets) {
determineLocantMeaning(subOrRootOrBracket, finalSubOrRootInWord);
}
for (Element subOrRoot : substituentsAndRoot) {
processMultipliers(subOrRoot);
detectConjunctiveSuffixGroups(subOrRoot, groups);
matchLocantsToDirectFeatures(subOrRoot);
Elements groupsOfSubOrRoot = subOrRoot.getChildElements(GROUP_EL);
Element lastGroupInSubOrRoot =groupsOfSubOrRoot.get(groupsOfSubOrRoot.size()-1);
preliminaryProcessSuffixes(lastGroupInSubOrRoot, XOMTools.getChildElementsWithTagName(subOrRoot, SUFFIX_EL));
}
FunctionalReplacement.processAcidReplacingFunctionalClassNomenclature(state, finalSubOrRootInWord, word);
if (FunctionalReplacement.processPrefixFunctionalReplacementNomenclature(state, groups, substituents)){//true if functional replacement performed, 1 or more substituents will have been removed
substituentsAndRoot = OpsinTools.combineElementLists(substituents, roots);
substituentsAndRootAndBrackets =OpsinTools.combineElementLists(substituentsAndRoot, brackets);
}
handleGroupIrregularities(groups);
for (Element subOrRoot : substituentsAndRoot) {
processHW(subOrRoot);//hantzch-widman rings
FusedRingBuilder.processFusedRings(state, subOrRoot);
processFusedRingBridges(subOrRoot);
assignElementSymbolLocants(subOrRoot);
processRingAssemblies(subOrRoot);
processPolyCyclicSpiroNomenclature(subOrRoot);
}
for (Element subOrRoot : substituentsAndRoot) {
applyLambdaConvention(subOrRoot);
handleMultiRadicals(subOrRoot);
}
//System.out.println(new XOMFormatter().elemToString(elem));
addImplicitBracketsToAminoAcids(groups, brackets);
findAndStructureImplictBrackets(substituents, brackets);
for (Element subOrRoot : substituentsAndRoot) {
matchLocantsToIndirectFeatures(subOrRoot);
assignImplicitLocantsToDiTerminalSuffixes(subOrRoot);
processConjunctiveNomenclature(subOrRoot);
resolveSuffixes(subOrRoot.getFirstChildElement(GROUP_EL), XOMTools.getChildElementsWithTagName(subOrRoot, SUFFIX_EL));
}
moveErroneouslyPositionedLocantsAndMultipliers(brackets);//e.g. (tetramethyl)azanium == tetra(methyl)azanium
List children = XOMTools.getChildElementsWithTagNames(word, new String[]{ROOT_EL, SUBSTITUENT_EL, BRACKET_EL});
while (children.size()==1){
children = XOMTools.getChildElementsWithTagNames(children.get(0), new String[]{ROOT_EL, SUBSTITUENT_EL, BRACKET_EL});
}
if (children.size()>0){
assignLocantsToMultipliedRootIfPresent(children.get(children.size()-1));//multiplicative nomenclature e.g. methylenedibenzene or 3,4'-oxydipyridine
}
addImplicitBracketsInCaseWhereSubstituentHasTwoLocants(substituents, brackets);
substituentsAndRootAndBrackets =OpsinTools.combineElementLists(substituentsAndRoot, brackets);//implicit brackets may have been created
for (Element subBracketOrRoot : substituentsAndRootAndBrackets) {
assignLocantsAndMultipliers(subBracketOrRoot);
}
processBiochemicalLinkageDescriptors(substituents, brackets);
processWordLevelMultiplierIfApplicable(word, wordCount);
}
new WordRulesOmittedSpaceCorrector(state, parse).correctOmittedSpaces();//TODO where should this go?
}
/**Resolves the contents of a group element
*
* @param group The group element
* @return The fragment specified by the group element.
* @throws StructureBuildingException If the group can't be built.
* @throws ComponentGenerationException
*/
static Fragment resolveGroup(BuildState state, Element group) throws StructureBuildingException, ComponentGenerationException {
String groupType = group.getAttributeValue(TYPE_ATR);
String groupSubType = group.getAttributeValue(SUBTYPE_ATR);
String groupValue = group.getAttributeValue(VALUE_ATR);
String groupValType = group.getAttributeValue(VALTYPE_ATR);
Fragment thisFrag =null;
if(groupValType.equals(SMILES_VALTYPE_VAL)) {
if (group.getAttribute(LABELS_ATR)!=null){
thisFrag = state.fragManager.buildSMILES(groupValue, groupType, groupSubType, group.getAttributeValue(LABELS_ATR));
}
else{
thisFrag = state.fragManager.buildSMILES(groupValue, groupType, groupSubType, "");
}
} else{
throw new StructureBuildingException("Group tag has bad or missing valType: " + group.toXML());
}
//processes groups like cymene and xylene whose structure is determined by the presence of a locant in front e.g. p-xylene
processXyleneLikeNomenclature(state, group, thisFrag);
setFragmentDefaultInAtomIfSpecified(thisFrag, group);
setFragmentFunctionalAtomsIfSpecified(group, thisFrag);
applyTraditionalAlkaneNumberingIfAppropriate(group, thisFrag);
return thisFrag;
}
/**
* Checks for groups with the addGroup/addBond/addHeteroAtom attributes. For the addGroup attribute adds the group defined by the SMILES described within
* e.g. for xylene this function would add two methyls. Xylene is initially generated using the structure of benzene!
* See tokenList dtd for more information on the syntax of these attributes if it is not clear from the code
* @param state
* @param group: The group element
* @param parentFrag: The fragment that has been generated from the group element
* @throws StructureBuildingException
* @throws ComponentGenerationException
*/
private static void processXyleneLikeNomenclature(BuildState state, Element group, Fragment parentFrag) throws StructureBuildingException, ComponentGenerationException {
if(group.getAttribute(ADDGROUP_ATR)!=null) {
String addGroupInformation=group.getAttributeValue(ADDGROUP_ATR);
String[] groupsToBeAdded = MATCH_SEMICOLON.split(addGroupInformation);//typically only one, but 2 in the case of xylene and quinones
ArrayList> allGroupInformation = new ArrayList>();
for (String groupToBeAdded : groupsToBeAdded) {//populate allGroupInformation list
String[] tempArray = MATCH_SPACE.split(groupToBeAdded);
HashMap groupInformation = new HashMap();
if (tempArray.length != 2 && tempArray.length != 3) {
throw new ComponentGenerationException("malformed addGroup tag");
}
groupInformation.put("SMILES", tempArray[0]);
if (tempArray[1].startsWith("id")) {
groupInformation.put("atomReferenceType", "id");
groupInformation.put("atomReference", tempArray[1].substring(2));
} else if (tempArray[1].startsWith("locant")) {
groupInformation.put("atomReferenceType", "locant");
groupInformation.put("atomReference", tempArray[1].substring(6));
} else {
throw new ComponentGenerationException("malformed addGroup tag");
}
if (tempArray.length == 3) {//labels may optionally be specified for the group to be added
groupInformation.put("labels", tempArray[2]);
}
allGroupInformation.add(groupInformation);
}
Element previousEl =(Element) XOMTools.getPreviousSibling(group);
if (previousEl !=null && previousEl.getLocalName().equals(LOCANT_EL)){//has the name got specified locants to override the default ones
List locantValues =StringTools.arrayToList(MATCH_COMMA.split(previousEl.getValue()));
if ((locantValues.size()==groupsToBeAdded.length || locantValues.size() +1 ==groupsToBeAdded.length) && locantAreAcceptableForXyleneLikeNomenclatures(locantValues, group)){//one locant can be implicit in some cases
boolean assignlocants =true;
if (locantValues.size()!=groupsToBeAdded.length){
//check that the firstGroup by default will be added to the atom with locant 1. If this is not the case then as many locants as there were groups should of been specified
//or no locants should have been specified, which is what will be assumed (i.e. the locants will be left unassigned)
HashMap groupInformation =allGroupInformation.get(0);
String locant;
if (groupInformation.get("atomReferenceType").equals("locant")){
locant =parentFrag.getAtomByLocantOrThrow(groupInformation.get("atomReference")).getFirstLocant();
}
else if (groupInformation.get("atomReferenceType").equals("id") ){
locant =parentFrag.getAtomByIDOrThrow(parentFrag.getIdOfFirstAtom() + Integer.parseInt(groupInformation.get("atomReference")) -1 ).getFirstLocant();
}
else{
throw new ComponentGenerationException("malformed addGroup tag");
}
if (locant ==null || !locant.equals("1")){
assignlocants=false;
}
}
if (assignlocants){
for (int i = groupsToBeAdded.length -1; i >=0 ; i--) {
//if less locants than expected are specified the locants of only the later groups will be changed
//e.g. 4-xylene will transform 1,2-xylene to 1,4-xylene
HashMap groupInformation =allGroupInformation.get(i);
if (locantValues.size() >0){
groupInformation.put("atomReferenceType", "locant");
groupInformation.put("atomReference", locantValues.get(locantValues.size()-1));
locantValues.remove(locantValues.size()-1);
}
else{
break;
}
}
group.removeAttribute(group.getAttribute(FRONTLOCANTSEXPECTED_ATR));
previousEl.detach();
}
}
}
for (int i = 0; i < groupsToBeAdded.length; i++) {
HashMap groupInformation =allGroupInformation.get(i);
String smilesOfGroupToBeAdded = groupInformation.get("SMILES");
Fragment newFrag;
if (groupInformation.get("labels")!=null){
newFrag = state.fragManager.buildSMILES(smilesOfGroupToBeAdded, parentFrag.getType(), parentFrag.getSubType(), groupInformation.get("labels"));
}
else{
newFrag = state.fragManager.buildSMILES(smilesOfGroupToBeAdded, parentFrag.getType(), parentFrag.getSubType(), NONE_LABELS_VAL);
}
Atom atomOnParentFrag =null;
if (groupInformation.get("atomReferenceType").equals("locant")){
atomOnParentFrag=parentFrag.getAtomByLocantOrThrow(groupInformation.get("atomReference"));
}
else if (groupInformation.get("atomReferenceType").equals("id") ){
atomOnParentFrag= parentFrag.getAtomByIDOrThrow(parentFrag.getIdOfFirstAtom() + Integer.parseInt(groupInformation.get("atomReference")) -1);
}
else{
throw new ComponentGenerationException("malformed addGroup tag");
}
if (newFrag.getOutAtomCount() >1){
throw new ComponentGenerationException("too many outAtoms on group to be added");
}
if (newFrag.getOutAtomCount() ==1) {
OutAtom newFragOutAtom = newFrag.getOutAtom(0);
newFrag.removeOutAtom(newFragOutAtom);
state.fragManager.incorporateFragment(newFrag, newFragOutAtom.getAtom(), parentFrag, atomOnParentFrag, newFragOutAtom.getValency());
}
else{
Atom atomOnNewFrag = newFrag.getDefaultInAtom();
state.fragManager.incorporateFragment(newFrag, atomOnNewFrag, parentFrag, atomOnParentFrag, 1);
}
}
}
if(group.getAttributeValue(ADDHETEROATOM_ATR)!=null) {
String addHeteroAtomInformation=group.getAttributeValue(ADDHETEROATOM_ATR);
String[] heteroAtomsToBeAdded = MATCH_SEMICOLON.split(addHeteroAtomInformation);
ArrayList> allHeteroAtomInformation = new ArrayList>();
for (String heteroAtomToBeAdded : heteroAtomsToBeAdded) {//populate allHeteroAtomInformation list
String[] tempArray = MATCH_SPACE.split(heteroAtomToBeAdded);
HashMap heteroAtomInformation = new HashMap();
if (tempArray.length != 2) {
throw new ComponentGenerationException("malformed addHeteroAtom tag");
}
heteroAtomInformation.put("SMILES", tempArray[0]);
if (tempArray[1].startsWith("id")) {
heteroAtomInformation.put("atomReferenceType", "id");
heteroAtomInformation.put("atomReference", tempArray[1].substring(2));
} else if (tempArray[1].startsWith("locant")) {
heteroAtomInformation.put("atomReferenceType", "locant");
heteroAtomInformation.put("atomReference", tempArray[1].substring(6));
} else {
throw new ComponentGenerationException("malformed addHeteroAtom tag");
}
allHeteroAtomInformation.add(heteroAtomInformation);
}
Element previousEl =(Element) XOMTools.getPreviousSibling(group);
if (previousEl !=null && previousEl.getLocalName().equals(LOCANT_EL)){//has the name got specified locants to override the default ones
List locantValues =StringTools.arrayToList(MATCH_COMMA.split(previousEl.getValue()));
if (locantValues.size() ==heteroAtomsToBeAdded.length && locantAreAcceptableForXyleneLikeNomenclatures(locantValues, group)){
for (int i = heteroAtomsToBeAdded.length -1; i >=0 ; i--) {//all heteroatoms must have a locant or default locants will be used
HashMap groupInformation =allHeteroAtomInformation.get(i);
groupInformation.put("atomReferenceType", "locant");
groupInformation.put("atomReference", locantValues.get(locantValues.size()-1));
locantValues.remove(locantValues.size()-1);
}
group.removeAttribute(group.getAttribute(FRONTLOCANTSEXPECTED_ATR));
previousEl.detach();
}
}
for (int i = 0; i < heteroAtomsToBeAdded.length; i++) {
HashMap heteroAtomInformation =allHeteroAtomInformation.get(i);
Atom atomOnParentFrag =null;
if (heteroAtomInformation.get("atomReferenceType").equals("locant")){
atomOnParentFrag=parentFrag.getAtomByLocantOrThrow(heteroAtomInformation.get("atomReference"));
}
else if (heteroAtomInformation.get("atomReferenceType").equals("id") ){
atomOnParentFrag= parentFrag.getAtomByIDOrThrow(parentFrag.getIdOfFirstAtom() + Integer.parseInt(heteroAtomInformation.get("atomReference")) -1);
}
else{
throw new ComponentGenerationException("malformed addHeteroAtom tag");
}
state.fragManager.replaceAtomWithSmiles(atomOnParentFrag, heteroAtomInformation.get("SMILES"));
}
}
if(group.getAttributeValue(ADDBOND_ATR)!=null && !HANTZSCHWIDMAN_SUBTYPE_VAL.equals(group.getAttributeValue(SUBTYPE_ATR))) {//HW add bond is handled later
String addBondInformation=group.getAttributeValue(ADDBOND_ATR);
String[] bondsToBeAdded = MATCH_SEMICOLON.split(addBondInformation);
ArrayList> allBondInformation = new ArrayList>();
for (String bondToBeAdded : bondsToBeAdded) {//populate allBondInformation list
String[] tempArray = MATCH_SPACE.split(bondToBeAdded);
HashMap bondInformation = new HashMap();
if (tempArray.length != 2) {
throw new ComponentGenerationException("malformed addBond tag");
}
bondInformation.put("bondOrder", tempArray[0]);
if (tempArray[1].startsWith("id")) {
bondInformation.put("atomReferenceType", "id");
bondInformation.put("atomReference", tempArray[1].substring(2));
} else if (tempArray[1].startsWith("locant")) {
bondInformation.put("atomReferenceType", "locant");
bondInformation.put("atomReference", tempArray[1].substring(6));
} else {
throw new ComponentGenerationException("malformed addBond tag");
}
allBondInformation.add(bondInformation);
}
boolean locanted = false;
Element previousEl =(Element) XOMTools.getPreviousSibling(group);
if (previousEl !=null && previousEl.getLocalName().equals(LOCANT_EL)){//has the name got specified locants to override the default ones
List locantValues =StringTools.arrayToList(MATCH_COMMA.split(previousEl.getValue()));
if (locantValues.size() ==bondsToBeAdded.length && locantAreAcceptableForXyleneLikeNomenclatures(locantValues, group)){
for (int i = bondsToBeAdded.length -1; i >=0 ; i--) {//all bond order changes must have a locant or default locants will be used
HashMap bondInformation =allBondInformation.get(i);
bondInformation.put("atomReferenceType", "locant");
bondInformation.put("atomReference", locantValues.get(locantValues.size()-1));
locantValues.remove(locantValues.size()-1);
}
group.removeAttribute(group.getAttribute(FRONTLOCANTSEXPECTED_ATR));
previousEl.detach();
locanted = true;
}
}
for (int i = 0; i < bondsToBeAdded.length; i++) {
HashMap bondInformation =allBondInformation.get(i);
Atom atomOnParentFrag =null;
if (bondInformation.get("atomReferenceType").equals("locant")){
atomOnParentFrag=parentFrag.getAtomByLocantOrThrow(bondInformation.get("atomReference"));
}
else if (bondInformation.get("atomReferenceType").equals("id") ){
atomOnParentFrag= parentFrag.getAtomByIDOrThrow(parentFrag.getIdOfFirstAtom() + Integer.parseInt(bondInformation.get("atomReference")) -1);
}
else{
throw new ComponentGenerationException("malformed addBond tag");
}
Bond b = FragmentTools.unsaturate(atomOnParentFrag, Integer.parseInt(bondInformation.get("bondOrder")) , parentFrag);
if (!locanted && b.getOrder() ==2 &&
parentFrag.getAtomList().size()==5 &&
b.getFromAtom().getAtomIsInACycle() &&
b.getToAtom().getAtomIsInACycle()){
//special case just that substitution of groups like imidazoline may actually remove the double bond...
b.setOrder(1);
b.getFromAtom().setSpareValency(true);
b.getToAtom().setSpareValency(true);
}
}
}
}
/**
* Checks that all locants are present within the front locants expected attribute of the group
* @param locantValues
* @param group
* @return
*/
private static boolean locantAreAcceptableForXyleneLikeNomenclatures(List locantValues, Element group) {
if (group.getAttribute(FRONTLOCANTSEXPECTED_ATR)==null){
throw new IllegalArgumentException("Group must have frontLocantsExpected to implement xylene-like nomenclature");
}
List allowedLocants = Arrays.asList(MATCH_COMMA.split(group.getAttributeValue(FRONTLOCANTSEXPECTED_ATR)));
for (String locant : locantValues) {
if (!allowedLocants.contains(locant)){
return false;
}
}
return true;
}
/**
* Looks for the presence of DEFAULTINLOCANT_ATR and DEFAULTINID_ATR on the group and applies them to the fragment
* Also sets the default in atom for alkanes so that say methylethyl is prop-2-yl rather than propyl
* @param thisFrag
* @param group
* @throws StructureBuildingException
*/
private static void setFragmentDefaultInAtomIfSpecified(Fragment thisFrag, Element group) throws StructureBuildingException {
String groupSubType = group.getAttributeValue(SUBTYPE_ATR);
if (group.getAttribute(DEFAULTINLOCANT_ATR)!=null){//sets the atom at which substitution will occur to by default
thisFrag.setDefaultInAtom(thisFrag.getAtomByLocantOrThrow(group.getAttributeValue(DEFAULTINLOCANT_ATR)));
}
else if (group.getAttribute(DEFAULTINID_ATR)!=null){
thisFrag.setDefaultInAtom(thisFrag.getAtomByIDOrThrow(thisFrag.getIdOfFirstAtom() + Integer.parseInt(group.getAttributeValue(DEFAULTINID_ATR)) -1));
}
else if ("yes".equals(group.getAttributeValue(USABLEASJOINER_ATR)) && group.getAttribute(SUFFIXAPPLIESTO_ATR)==null){//makes linkers by default attach end to end
int chainLength =thisFrag.getChainLength();
if (chainLength >1){
boolean connectEndToEndWithPreviousSub =true;
if (groupSubType.equals(ALKANESTEM_SUBTYPE_VAL)){//don't do this if the group is preceded by another alkaneStem e.g. methylethyl makes more sense as prop-2-yl rather than propyl
Element previousSubstituent =(Element) XOMTools.getPreviousSibling(group.getParent());
if (previousSubstituent!=null){
Elements groups = previousSubstituent.getChildElements(GROUP_EL);
if (groups.size()==1 && groups.get(0).getAttributeValue(SUBTYPE_ATR).equals(ALKANESTEM_SUBTYPE_VAL) && !groups.get(0).getAttributeValue(TYPE_ATR).equals(RING_TYPE_VAL)){
connectEndToEndWithPreviousSub = false;
}
}
}
if (connectEndToEndWithPreviousSub){
Element parent =(Element) group.getParent();
while (parent.getLocalName().equals(BRACKET_EL)){
parent = (Element) parent.getParent();
}
if (parent.getLocalName().equals(ROOT_EL)){
Element previous = (Element) XOMTools.getPrevious(group);
if (previous==null || !previous.getLocalName().equals(MULTIPLIER_EL)){
connectEndToEndWithPreviousSub=false;
}
}
}
if (connectEndToEndWithPreviousSub){
group.addAttribute(new Attribute(DEFAULTINID_ATR, Integer.toString(chainLength)));
thisFrag.setDefaultInAtom(thisFrag.getAtomByLocantOrThrow(Integer.toString(chainLength)));
}
}
}
}
/**
* Looks for the presence of FUNCTIONALIDS_ATR on the group and applies them to the fragment
* @param group
* @param thisFrag
* @throws StructureBuildingException
*/
private static void setFragmentFunctionalAtomsIfSpecified(Element group, Fragment thisFrag) throws StructureBuildingException {
if (group.getAttribute(FUNCTIONALIDS_ATR)!=null){
String[] functionalIDs = MATCH_COMMA.split(group.getAttributeValue(FUNCTIONALIDS_ATR));
for (String functionalID : functionalIDs) {
thisFrag.addFunctionalAtom(thisFrag.getAtomByIDOrThrow(thisFrag.getIdOfFirstAtom() + Integer.parseInt(functionalID) - 1));
}
}
}
private static void applyTraditionalAlkaneNumberingIfAppropriate(Element group, Fragment thisFrag) {
String groupType = group.getAttributeValue(TYPE_ATR);
if (groupType.equals(ACIDSTEM_TYPE_VAL)){
List atomList = thisFrag.getAtomList();
Atom startingAtom = thisFrag.getFirstAtom();
if (group.getAttribute(SUFFIXAPPLIESTO_ATR)!=null){
String suffixAppliesTo = group.getAttributeValue(SUFFIXAPPLIESTO_ATR);
String suffixAppliesToArr[] = MATCH_COMMA.split(suffixAppliesTo);
if (suffixAppliesToArr.length!=1){
return;
}
startingAtom = atomList.get(Integer.parseInt(suffixAppliesToArr[0])-1);
}
List neighbours = startingAtom.getAtomNeighbours();
int counter =-1;
Atom previousAtom = startingAtom;
for (int i = neighbours.size()-1; i >=0; i--) {//only consider carbon atoms
if (!neighbours.get(i).getElement().equals("C")){
neighbours.remove(i);
}
}
while (neighbours.size()==1){
counter++;
if (counter>5){
break;
}
Atom nextAtom = neighbours.get(0);
if (nextAtom.getAtomIsInACycle()){
break;
}
nextAtom.addLocant(traditionalAlkanePositionNames[counter]);
neighbours = nextAtom.getAtomNeighbours();
neighbours.remove(previousAtom);
for (int i = neighbours.size()-1; i >=0; i--) {//only consider carbon atoms
if (!neighbours.get(i).getElement().equals("C")){
neighbours.remove(i);
}
}
previousAtom = nextAtom;
}
}
else if (groupType.equals(CHAIN_TYPE_VAL) && ALKANESTEM_SUBTYPE_VAL.equals(group.getAttributeValue(SUBTYPE_ATR))){
List