diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b806111 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +__pycache__ +*.egg-info +*.h5 diff --git a/Contributors.md b/Contributors.md new file mode 100644 index 0000000..7198a44 --- /dev/null +++ b/Contributors.md @@ -0,0 +1,12 @@ +This project was started by Muhamed Amin based on ideas and suggestions from +Jochen Küpper. Jean-Michel Hartmann provided Fortran code, based on the book +. + + + + diff --git a/LICENSE-GPLv3.md b/LICENSE-GPLv3.md new file mode 100644 index 0000000..fc69a73 --- /dev/null +++ b/LICENSE-GPLv3.md @@ -0,0 +1,618 @@ +### GNU GENERAL PUBLIC LICENSE + +Version 3, 29 June 2007 + +Copyright (C) 2007 [Free Software Foundation, Inc.](https://fsf.org/) + +Everyone is permitted to copy and distribute verbatim copies of this +license document, but changing it is not allowed. + +### Preamble + +The GNU General Public License is a free, copyleft license for +software and other kinds of works. + +The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom +to share and change all versions of a program--to make sure it remains +free software for all its users. We, the Free Software Foundation, use +the GNU General Public License for most of our software; it applies +also to any other work released this way by its authors. You can apply +it to 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. + +END OF TERMS AND CONDITIONS diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..0d468c4 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,22 @@ +# CMIclassirot licensing conditions + +CMIclassirot is provided by the CFEL Controlled Molecule Imaging group as is. It is licensed under +the [GPL v3](./LICENSE-GPLv3.md) with the following additional requirements: + +* Its use for scientific work is acknowledged by the appropriate reference in any resulting work, + e.g., scientific publication. + +* All corrections and enhancements must be contributed back to the development of the package within + an appropriate time, i.e., no later than the publication of its first use. + Please create a pull request on GitHub (preferred) or send an appropriate patch against the latest + program version on the `develop` branch. + +See the documentation for a full list of contributors. + + + diff --git a/README.devel.md b/README.devel.md new file mode 100644 index 0000000..dfbb434 --- /dev/null +++ b/README.devel.md @@ -0,0 +1,16 @@ +# Development guidelines + +Please follow some simple rules for coding on CMIstark: +- keep the code consistent across the whole package! +- use git-flow (the tools and the concept) +- consistently use two empty lines between functions/methods and three empty + lines above a class + + + + diff --git a/README.md b/README.md index b067dac..41c79f6 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,27 @@ -# Classical-Alignment -Classical Alignment of Molecules and Nanorods +# Classical-physics simulations of laser alignment + +Classical-mechanics simulations of the rotational dynamics of rigid molecules +and nanoparticles in laser-electric fields. + +See the files in `examples/` for a start. + +## Installation + + +## Documentation + + +## Citation + +When you use this program in scientific work, please cite it as Muhamed Amin, +Jean-Michel Hartmann, Amit K. Samanta, Jochen Küpper, "Laser-induced alignment +of nanoparticles and macromolecules for single-particle-imaging applications", +[arXiv:2306.05870](https://arxiv.org/abs/2306.05870) + + + diff --git a/cmiclassirot/__init__.py b/cmiclassirot/__init__.py new file mode 100644 index 0000000..ebfd03d --- /dev/null +++ b/cmiclassirot/__init__.py @@ -0,0 +1,17 @@ +# -*- coding: utf-8; fill-column: 120; truncate-lines: t -*- +# +# Copyright (C) 2020 Jochen Küpper +# +# This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public +# License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later +# version. +# +# If you use this programm for scientific work, you must correctly reference it; see LICENSE file for details. +# +# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with this program. If not, see +# . + +__author__ = "Jochen Küpper " diff --git a/cmiclassirot/field.py b/cmiclassirot/field.py new file mode 100644 index 0000000..5e137c2 --- /dev/null +++ b/cmiclassirot/field.py @@ -0,0 +1,95 @@ +# -*- coding: utf-8; fill-column: 100 -*- +# +# This file is part of CMIclassirot -- classical-physics rotational molecular-dynamics simulations +# +# This program is free software: you can redistribute it and/or modify it under the terms of the GNU +# General Public License as published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. +# +# If you use this programm for scientific work, you must correctly reference it; see LICENSE file +# for details. +# +# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with this program. If not, +# see . + +import numpy as np +from scipy import interpolate +from scipy.constants import c, epsilon_0 +from pyquaternion import Quaternion + +class Field(object): + """Electric field class + + For the beginning, this only implements a simple Gaussian pulse (in field strengths!) centered + at t=0 and along `Z`. + + .. todo:: Keep in mind that we want to be able to represent elliptically polaerized field by their envelope. + + """ + + def __init__(self, amplitude=1.e15, sigma=1.e-9, mean=5.e-9, + intensity=True, filename=None, dc=None): + self.amplitude = amplitude + self.sigma = sigma + self.Ez = np.array([0., 0., 1.]) + self.from_file = None + self.intensity = intensity + self.mu = mean + self.dc = dc + if filename is not None: + f = open(filename) + E=[] + t=[] + for i in f: + token = i.split() + t.append(float(token[0])) + E.append(float(token[1])) + t = np.array(t) + E = np.array(E) + self.from_file = interpolate.interp1d(t,E) + + def __call__(self, t): + """Field at time t + + :return: Field vector at time + """ + if self.dc is not None: + if t > self.dc[0] and t < self.dc[1]: + return self.convert(self.dc[2]) + else: + return 0 + + if self.from_file is None: + E = self.amplitude * np.exp(-0.5 * ((t-self.mu)/self.sigma)**2) + if self.intensity: + return self.convert(E) + else: + return E + else: + try: + E = 1.e16*self.from_file(t) + if self.intensity: + return self.convert(E) + else: + return E + except: + return 0. + + def convert(self, I): + """ Converts intensity to electric field""" + return np.sqrt(2*I/(c * epsilon_0)) + + def rotate(self, quaternion=Quaternion()): + """Rotate field + + This is used in the actual propagation step, as it is easier/cheaper to rotate the field + than to rotate the molecule + + :param rotation: Define the rotation to be applied to the field, as an :class:`Quarternion` + + """ + return quaternion.rotate(self.Ez) diff --git a/cmiclassirot/postprocessing.py b/cmiclassirot/postprocessing.py new file mode 100644 index 0000000..783f8d8 --- /dev/null +++ b/cmiclassirot/postprocessing.py @@ -0,0 +1,76 @@ +# -*- coding: utf-8; fill-column: 100 -*- +# +# This file is part of CMIclassirot -- classical-physics rotational molecular-dynamics simulations +# +# This program is free software: you can redistribute it and/or modify it under the terms of the GNU +# General Public License as published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. +# +# If you use this programm for scientific work, you must correctly reference it; see LICENSE.md file +# for details. +# +# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with this program. If not, +# see . + + +import numpy as np + + +class Expectation(object): + """Calculate expectation values of a probability density function given as an :class:`Ensemble` + + .. todo:: implement + + """ + + def __init__(self, Ensemble): + pass + + def __call__(self): + pass + + +class cos2theta(Expectation): + pass + + +class cos2theta_2D(Expectation): + pass + + + +class ProbabilityGraphics(object): + """Create a graphical representation of a probability density function + + This Object requires a (variable dimension) probability density function and provides various + graphical outputs, such as actual 3D images/VRML graphs, contour plots of projections, etc. + + .. todo:: implement + + """ + + def __init__(self): + pass + + + +class Projection(object): + """Project a probability distribution onto a plane or line + + This object takes a 3D PDF and creates a lower-dimension PDF by projection onto an arbitrary + plane or line. + + .. todo:: Discuss how this blends into :class:`Ensemble` and the funtionality in this file: For + instance, will we just create a new Ensemble with certain restrictions or in fact create an + independent data structure? + + .. todo:: implement + + """ + + def __init__(self): + pass diff --git a/cmiclassirot/propagate.py b/cmiclassirot/propagate.py new file mode 100644 index 0000000..ab233db --- /dev/null +++ b/cmiclassirot/propagate.py @@ -0,0 +1,134 @@ +# -*- coding: utf-8; fill-column: 100 -*- +# +# This file is part of CMIclassirot -- classical-physics rotational molecular-dynamics simulations +# +# This program is free software: you can redistribute it and/or modify it under the terms of the GNU +# General Public License as published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. +# +# If you use this programm for scientific work, you must correctly reference it; see LICENSE.md file +# for details. +# +# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with this program. If not, +# see . + +import numpy as np +from scipy.integrate import ode +import pyquaternion as quat +from cmiclassirot.sample import Position +import multiprocessing as mp + +class Propagate(object): + """Propagate an Ensemble in time""" + + def __init__(self, ensemble, field, dt=2.e-11, timerange=(-1e-9,1e-9)): + """Initialize propagator + + :param ensemble: Ensemble with all |Molecule|s to be propagated + + :param field: Field in which to propagate. This is a univariate function that returns the + field strength (V/m) for any given time (s) in the `timerange`. + + :param timerange: Timerange over which to propagate, specified as tuple (t_init, t_final) + + """ + self.ensemble = ensemble + self.field = field + self.dt = dt + self.t_range = timerange + self.run() + + def run(self): + """Propagate all |Molecule|s in the current |Field| over the current time range + + .. todo:: Parallelize this (which is trivial) + """ + n_cpu = mp.cpu_count() + print("Running on:",n_cpu,"Processors") + self.ensemble.pulse = self.field + pool = mp.Pool(n_cpu) + results = pool.map(self._propagate, self.ensemble.molecules) + pool.close() + pool.join() + for i in range(len(results)): + self.ensemble.molecules[i] = results[i] + return self.ensemble + + @classmethod + def molecule(cls, mol, field, dt, timerange): + cls.field = field + cls.dt = dt + cls.t_range = timerange + cls._propagate(cls, mol) + return mol + + def _propagate(self, molecule): + """Propagate an individual molecule in the current field and over the current time range + + :param molecule: The :class:`Molecule` to propagate over the stored time-range and field; see `__init__`. + + .. note:: This method must be reentrant so we can run it for many molecules in parallel. + + .. todo:: Should use the modern approach, i.e., `scipy.integrate.solve_ivp` + + + # create a copy store a field direction (which can the rotated) + field = self.field + derivative = np.empty((7,)) + rot = quat.Quaternion() + # integrate over time + scipy.integrate.solve_ivp(self._derivative, + self.t_range, + molecule.position, + method='LSODA', + t_eval=None, + dense_output=False, + events=None, + vectorized=False, + args=(derivative, molecule, field)) + """ + + integral = ode( self._derivative ) # initial ode object + integral.set_integrator('dopri5', nsteps=10000) # choose the integrator + #integral.set_integrator('lsoda') + integral.set_initial_value(np.concatenate((molecule.pos[0].angle.elements, + molecule.pos[0].velocity))).set_f_params(molecule) + while integral.successful() and integral.t <= self.t_range[1]: # start the integration + integral.integrate(integral.t + self.dt) # advance the integrator in time + molecule.pos.append( + Position(quat.Quaternion(integral.y[:4]) + , integral.y[4:7], t=integral.t)) + + return molecule + + def _derivative(self, t, dpos, molecule): + """Determine the derivative of a Molecule at a specific time. + + :param t: Time for which to calculate the derivative + + :param molecule: Molecule for which to calculate the derivative + + :param dpos: Derivative vector storage; if provided, this must be a 7-element ndarray which + is used for storage of the derivative (which is returned in any case) + + :return: `ndarray` with the derivate of the current molecule position. + + .. note:: for performance reasons, i.e., avoiding the repeated creation of the derivative + vector, this method expects the vector to be passed by the caller. This method then updates + the elements and also returns the updated derivative vector. + + """ + # derivative of the posiiton is currently calculated under the assumption that pos.angle is a Quaternion + + q = quat.Quaternion(dpos[0:4]) + omega = dpos[4:7] + #E = self.field(t) * self.field.rotate() # uncomment this if you want to rotate the molecule + E = self.field(t) * self.field.rotate(q.inverse) #incase rotating the field + position = Position(q, omega) + dw = molecule.acceleration(E, position) + dq = q.derivative(omega).elements + return np.concatenate((dq,dw)) diff --git a/cmiclassirot/sample.py b/cmiclassirot/sample.py new file mode 100644 index 0000000..04ec35c --- /dev/null +++ b/cmiclassirot/sample.py @@ -0,0 +1,287 @@ +# -*- coding: utf-8; fill-column: 100 -*- +# +# This file is part of CMIclassirot -- classical-physics rotational molecular-dynamics simulations +# +# This program is free software: you can redistribute it and/or modify it under the terms of the GNU +# General Public License as published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. +# +# If you use this programm for scientific work, you must correctly reference it; see the LICENSE.md +# file for details. +# +# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with this program. If not, +# see . + + +import numpy as np +import pyquaternion as quat +import scipy.constants +import pandas as pd + +class Position(object): + """Representation of a phase-space position of a molecule + + The current position can be directly accessed as `Position.angle`, which is a + :class:`Quarternion` and `Position.velocity`, which is a 3-element `ndarray` -- but this will + change in favor of them being implemented as property accessors in the future. + + .. todo:: Make `angle` and `velocity` a real property with accessors, so it get's implementation + independent. + + .. todo:: Implement a 'raw' accessor for the internal data strucure, and epsecially a 'raw + derivative'. The latter what should be set by Molecule._derivative and then be used through an + accessor in the ODE solver... Need to figure out how to do this "efficiently". + + """ + + def __init__(self, angle=quat.Quaternion(), velocity=np.zeros((3,)), t=0.): + self.angle = angle + self.velocity = velocity + self.time = t + +class Molecule(object): + """Object to be manipulated + + The relevant parameters that describe the :class:`Molecule` properties are its principal moments + of inertia and its polarizability tensor, both of which must be given in the principal axis of + inertia system, i.e., :math:`a`, :math:`b`, :math:`c`. + + Furthermore, the molecule has a phase-space position, i.e., a :class:`Position object. + + """ + + def __init__(self, *args, **kwargs): + """Initialize a molecule from it's relevant paramters + + This can be called in two ways + + .. code-block:: python + + __init__(self, molecule, pos=None, temp=None) + __init__(self, I, P, angle=None, velocity=None, temp=None) + + :param molecule: Use first version of constructor: copy the specified molecule and possibly + update its phase-space position + + :param pos: Determines position of new molecule + * 'keep' or None specify to copy the phase-space position from the original Molecule + * 'z' places the :class:`Molecule` along the laboratry :math:`z` axis with a angular + velocity of 0 + * 'random' draws a random direction from a uniform angular distribution and an random + angular velocity according to a 3D Maxwell distribution at temperature `temp` + + :param I: principal moments of inertia: these are the three diagonal elements of the in the + inertial tensor in the principle axis of inertia frame (in SI units: kg * m**2) + + :param P: polarizabiity tensor in the inertial frame of the molecule (in SI units: ???) + + :param T: Temperature of the thermal distribution from which to draw the initial momentum of + the particle; typically this should not be done here but in a (to be provided) `Source` + + :param angle: initial position, as a Quaternion, if not provided a random direction id + choosen + + :param velocity: initial angular frequency, if not provided a random vector drawn from three + one-dimensional Maxell distribution for rotations about x, y, z is drawn + """ + if isinstance(args[0], Molecule): + # first variant of constructor -- get args + assert(len(args)==1) + mol = args[0] + # get keyword args + pos = kwargs.get('pos', None) + temp = kwargs.get('temp', 0) + # construct object + self._I = mol.I + self._P = mol.P + if pos == None or pos == 'keep': + self.pos = mol.pos + elif pos == 'z': + self.pos = [Position()] + elif pos == 'random': + self.pos = [self._thermal_position(temp)] + elif isinstance(pos, Position): + self.pos = [pos] + elif isinstance(pos, list): + self.pos = pos + + elif len(args) == 0 or isinstance(args[0], np.ndarray): + # second variant of constructor + if len(args) >= 1: + self._I = args[0] + else: + self._I = kwargs.get('I') + if len(args) >= 2: + self._P = args[1] + else: + self._P = kwargs.get('P') + angle = kwargs.get('angle', None) + velocity = kwargs.get('velocity', None) + temp = kwargs.get('temp', None) + # set initila phase-space position + self.pos = [] + pos = Position() + if temp is not None: + pos = self._thermal_position(temp) + # overwrite thermal phase-space position by explicitely specified values + if angle is not None: + pos.angle = angle + if velocity is not None: + pos.velocity = velocity + self.pos.append(pos) + else: + # something wrong! + raise TypeError('Wrong argument types to Molecule.__init__') + + + @property + def I(self): + return self._I + + + @property + def P(self): + return self._P + + + def acceleration(self, field, position, factor=1): + """Calculate the molecule's angular acceleration at its current position in a field + + :param field: Field for which to calculate the acceleration + + """ + q = position.angle + v = position.velocity + #I, P = self.rotate(q) # uncomment this line incase you want to rotate + # the molecule not the field + if self._I[2][2]. +# +# This file shall eventually serve as a driver for the calculation and postprocessing +# for rotMD simulations + + +from cmiclassirot.field import * +from cmiclassirot.sample import * +from scipy.constants import epsilon_0 +from cmiclassirot.propagate import * +import math +P = 1.e-30 * epsilon_0 * np.array([[ 5.646E5, 0.E2, 0.E2], + [ 0.E2, 5.646E5, 0.E2], + [ 0.E2, 0.E2, 4.860E6]]) +nm = 1.e-9 +rho = 19.3e3 # density of gold (kg/m**3) +height = 10 * nm +radius = 2 * nm +volume = math.pi * radius**2 * height +mass = volume*rho +Iz = 0.5*mass*radius**2 +Ix = Iy = 1./12 * mass * (3*radius**2 + height**2) +I = np.array([[Ix ,0.,0.], + [0., Iy,0.], + [0., 0.,Iz]]) + +E = Field(amplitude=1.e15, sigma=1.e-9, mean=3.e-9, intensity=True) +n = 100 +mol = Molecule(I, P) +ensemble = Ensemble(n, mol, temperature=20.) +p = Propagate(ensemble, E, timerange=(0.,15.e-9), dt=5.e-11) +ensemble._save('T298Knanorod.h5') diff --git a/examples/co2.py b/examples/co2.py new file mode 100644 index 0000000..a00ccfd --- /dev/null +++ b/examples/co2.py @@ -0,0 +1,29 @@ +from cmiclassirot.field import * +from cmiclassirot.sample import * +from scipy.constants import epsilon_0 +from cmiclassirot.propagate import * +import numpy as np +P = 4 * np.pi * 1.e-30 * epsilon_0 * np.array([[ 1.93, 0.E2, 0.E2], + [ 0.E2, 1.93, 0.E2], + [ 0.E2, 0.E2, 4.03]]) +#Polarizabilities are taken from +#https://faculty.missouri.edu/~glaserr/vitpub/jp002927r.pdf + +Iz = 0. +Ix = Iy = 7.14987936e-46 +I = np.array([[Ix ,0.,0.], + [0., Iy,0.], + [0., 0.,Iz]]) +T = 298. +sigma = 0.1e-12/ 2.355 +# define a field +E = Field(amplitude=1.5e18, sigma=sigma, mean=0.25e-12) +n = 1500 +# define a molecule +mol = Molecule(I, P) +# define an ensemble +ensemble = Ensemble(n, mol, temperature=T) +# start simulation +p = Propagate(ensemble, E, timerange=(0.,1.5e-12), dt=1.e-14) +# save results +ensemble._save('CO2_150TWcm2_298K.h5') diff --git a/examples/ocs.py b/examples/ocs.py new file mode 100644 index 0000000..7d92aa0 --- /dev/null +++ b/examples/ocs.py @@ -0,0 +1,21 @@ +from cmiclassirot.field import * +from cmiclassirot.sample import * +from scipy.constants import epsilon_0 +from cmiclassirot.propagate import * +import numpy as np + +P = 1.e-30 * epsilon_0 * np.array([[ 3.06, 0.E2, 0.E2], + [ 0.E2, 3.06, 0.E2], + [ 0.E2, 0.E2, 7.46]]) +Ix = Iy = 1.38493163e-45 +I = np.array([[Ix ,0.,0.], + [0., Iy,0.], + [0., 0.,0.]]) +T = 0. +sigma = 1.e-10 / 2.355 +E = Field(amplitude=1.e14/2., sigma=sigma, mean=2.5e-10) +n = 50 +mol = Molecule(I, P) +ensemble = Ensemble(n, mol, temperature=T) +p = Propagate(ensemble, E, timerange=(0.,1.e-9), dt=1.e-11) +ensemble._save('OCS_0.01TWcm2_0K.h5') diff --git a/scripts/cmiclassirot b/scripts/cmiclassirot new file mode 100644 index 0000000..19f8290 --- /dev/null +++ b/scripts/cmiclassirot @@ -0,0 +1,52 @@ +#!/usr/bin/env python +# -*- coding: utf-8; fill-column: 120 -*- +# +# This file is part of CMIrotMD +# +# This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public +# License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later +# version. +# +# If you use this programm for scientific work, you must correctly reference it; see LICENSE file for details. +# +# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with this program. If not, see +# . +# +# This file shall eventually serve as a driver for the calculation and postprocessing +# for rotMD simulations + + +import h5py +import numpy as np +import matplotlib.pyplot as plt +import sys +fname = sys.argv[1] +rho = 19300. +M = 3.79347234e-18 +L = 50.e-9 +R = 5.e-9 +V = np.pi*L*R**2 +M = V*rho +KB = 1.38064852e-23 +I = np.array([ (0.083*M*L**2 + 0.25*M*R**2), (0.083*M*L**2 + 0.25*M*R**2), 0.5*M*R**2]) +f = h5py.File(fname, 'r') + +time = f['time'] +cos = f['cos'] +E = f['pulse'] +Tt = f['pulseT'] +t = max(np.max(Tt), np.max(time)) +fig, (ax1, ax2) = plt.subplots(2) +ax1.plot(time, cos) +ax2.plot(Tt, E) +ax1.set_xlabel('Time (s)') +ax2.set_xlabel('Time (s)') +ax1.set_ylabel('cos2') +ax2.set_ylabel('I TW/cm2') +ax1.set_xlim(0., t) +ax2.set_xlim(0., t) +plt.tight_layout() +plt.show() diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..411fd79 --- /dev/null +++ b/setup.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python +# -*- coding: utf-8; fill-column: 120 -*- +# +# This file is part of the CMI classical-rotation simulations + +from setuptools import setup + +extra_compile_args = [] +library_dirs = [] + +long_description = """CMI classical-physics rotational molecular-dynamics simulations + +This package provides facilities for the simulation of the rotation dynamics of molecules and particles in external +electric fields. + +""" + + +setup(name="cmiclassirot", + author = "CFEL Controlled Molecule Imaging group", + maintainer = "CFEL Controlled Molecule Imaging group", + maintainer_email = "jochen.kuepper@cfel.de", + url = "https://www.controlled-molecule-imaging.org/research/further_projects/software", + description = "CMI classical-physics rotational molecular-dynamics simulations", + version = "0.1.dev0", + long_description = long_description, + license = "GPL", + packages = ['cmiclassirot'], + scripts = ['scripts/cmiclassirot'], + python_requires = '>=3.5', + install_requires = ['numpy>=1.16.0', + 'pyquaternion', + 'scipy>=1.3.0'], + ) diff --git a/test/__init__.py b/test/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/test/test.py b/test/test.py new file mode 100644 index 0000000..c282717 --- /dev/null +++ b/test/test.py @@ -0,0 +1,129 @@ +# -*- coding: utf-8; fill-column: 100 -*- +# +# This file is part of CMIclassirot -- classical-physics rotational molecular-dynamics simulations +# +# This program is free software: you can redistribute it and/or modify it under the terms of the GNU +# General Public License as published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. +# +# If you use this programm for scientific work, you must correctly reference it; see the LICENSE.md +# file for details. +# +# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License along with this program. If not, +# see . + +__doc__ = """Running this file gives mane warnings -- fix. +.. todo:: SyntaxWarning: "is" with a literal. Did you mean "=="? +""" + +from cmiclassirot.sample import * +from cmiclassirot.field import * +from math import pi +import unittest +from pyquaternion import Quaternion +from scipy.constants import c, epsilon_0 + +# moments of inertia of solid cylinder of gold +# see https://en.wikipedia.org/wiki/List_of_moments_of_inertia +rho = 19.3e3 # density of gold (kg/m**3) +height = 20e-9 # m +radius = 1e-9 # m +volume = pi * radius**2 * height +mass = volume*rho + +# inertia tensor in the PA frame +I = np.array([1./12 * mass * (3*radius**2 + height**2), + 1./12 * mass * (3*radius**2 + height**2), + 0.5*mass*radius**2]) + +# polarizability tensor of a perfectly conducting nanorod of 20 nm height and 2 nm diameter +P = np.array([[ 1.1e-26, 0., 0], + [ 0.00e0, 1.1e-26, 0], + [ 0, 0, 2.5e-25]]) + +T = 0.4 #K +# testing the first version of the constructor of the molecule class +class TestCMIclassirot(unittest.TestCase): + + def test_molecule_constructor_first_version(self): + """ + Testing the first version of the constructor of the + molecule class. + """ + + m1 = Molecule(I, P) + m2 = Molecule(m1) + self.assertEqual(m1.I.tolist(), m2.I.tolist()) + self.assertEqual(m1.P.tolist(), m2.P.tolist()) + m2 = Molecule(m1, pos='random') + self.assertIsNotNone(m2.pos[0].angle) + self.assertIsNotNone(m2.pos[0].velocity) + velocity = np.zeros((3,)) + angle = Quaternion() + m2 = Molecule(m1, pos='z') + self.assertEqual(m2.pos[0].velocity.tolist(), velocity.tolist()) + self.assertEqual(m2.pos[0].angle.angle, angle.angle) + pos = Position(angle, velocity) + m2 = Molecule(m1, pos=pos) + self.assertEqual(m2.pos[0].velocity.tolist(), velocity.tolist()) + self.assertEqual(m2.pos[0].angle.angle, angle.angle) + + def test_molecule_constructor_second_version(self): + """ + Testing the second version of the constructor of the + molecule class. + """ + + m = Molecule(I, P, temp=T) + self.assertEqual(m.I.tolist(), I.tolist()) + self.assertEqual(m.P.tolist(), P.tolist()) + self.assertIsNotNone(m.pos[0].angle) + self.assertIsNotNone(m.pos[0].velocity) + + def test_assigning_speed_angles(self): + """ + test passing values for angle and velocities + """ + + velocity = np.array([3e6, 2e6, -1.e7]) + angle = Quaternion() + m = Molecule(I, P, temp=T, velocity=velocity, angle=angle) + self.assertEqual(m.pos[0].velocity.tolist(), velocity.tolist()) + self.assertEqual(m.pos[0].angle.angle, angle.angle) + + def test_Ensemble(self): + """ + test generating ensemble of molecules + """ + n = 100 + mol = Molecule(I, P) + ensemble = Ensemble(n, mol) + self.assertEqual(ensemble.size, n) + self.assertEqual(ensemble.size, ensemble.index) + + def test_save_load_ensemble(self): + """ + testing save and load of ensemble + to and from file""" + n = 100 + mol = Molecule(I, P) + ensemble = Ensemble(n, mol) + ensemble._save('Data.h5') + ensemble_from_file = Ensemble.FromFile('Data.h5') + self.assertEqual(len(ensemble.molecules), len(ensemble_from_file.molecules)) + + def test_intensity_to_field(self): + """testing the conversion from intenisty + to electric field. if the intensity = c*epsilon_0 + then the field should equal 1 V/d""" + + A = c * epsilon_0/2. + E = Field(amplitude=A, sigma=5e-9, mean=0., intensity=True) + self.assertEqual(E(0.)[2], 1.) + +if __name__ == '__main__': + unittest.main() diff --git a/utilities/__init__.py b/utilities/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/utilities/plot.py b/utilities/plot.py new file mode 100644 index 0000000..01b037b --- /dev/null +++ b/utilities/plot.py @@ -0,0 +1,32 @@ +from cmiclassirot.sample import Ensemble +import matplotlib.pyplot as plt +import numpy as np +import sys + +fname = sys.argv[1] +t=[] +cos2=[] +e = Ensemble.FromFile(fname) +r = np.zeros(len(e.molecules[0].pos)) +E = e.pulse +print("Number of Molecules:", len(e.molecules)) +for i in e.molecules: + t=[] + pulse = [] + for j in range(len(i.pos)): + try: + r[j] = r[j] + i.pos[j].angle.rotation_matrix[2][2]**2 + t.append(i.pos[j].time) + pulse.append(E(i.pos[j].time)) + except: + pass + +r=r/len(e.molecules) +fig, ax = plt.subplots(2) +ax[0].plot(t, r) +ax[1].plot(t, pulse) +plt.xlabel("Time (s)") +ax[0].set_ylabel("Cos^2") +ax[1].set_ylabel("E (V/m)") +plt.tight_layout() +plt.show() diff --git a/utilities/rot_period.py b/utilities/rot_period.py new file mode 100644 index 0000000..6d579d8 --- /dev/null +++ b/utilities/rot_period.py @@ -0,0 +1,24 @@ +import numpy as np +from numpy import pi +from scipy.constants import h + +# define a nanorod +rho = 19300. # density *(kg/m**3) +L = 2.e-9 # length (m) +R = 2.e-10 # radius (m) +V = pi*L*R**2 # volume (m**3) +M = V*rho # mass (kg) + +# principal moments of inertia (see, e.g., Wikipedia) +I = np.array([(0.083*M*L**2 + 0.25*M*R**2), + (0.083*M*L**2 + 0.25*M*R**2), + 0.5*M*R**2]) + +# calulate rotational constand B = \frac{h}{8 \pi^2 I} (Hz) +B = h / (8 * pi**2 * I) + +# rotational periods (s) +rot_period = 1/(2*B) + +print('rotational periods are calculated as ', rot_period, ' (s)') + diff --git a/utilities/time_of_alignment.py b/utilities/time_of_alignment.py new file mode 100644 index 0000000..74d4242 --- /dev/null +++ b/utilities/time_of_alignment.py @@ -0,0 +1,60 @@ +#!/usr/bin/env python +# -*- coding: utf-8; fill-column: 120 -*- +import numpy as np +from cmiext import const + +# physical constants +ε0 = const.vacuum_permittivity +c = const.speed_of_light # needed for unit conversion + + +# definition of an Au cylinder in its principal axis system +rho = 19300. # density of gold (kg/m**3) +L = 2.e-9 # length of the cylinder (m) +R = 0.2e-9 # radius of the cylinder (m) +V = np.pi*L*R**2 # volume (m**3) +M = V*rho # mass (kg) + +# inertia tensor for a cylinder with the figure axis along z +# see ... (link to Wikipedia) +I = np.array([(0.083*M*L**2 + 0.25*M*R**2), + (0.083*M*L**2 + 0.25*M*R**2), + 0.5*M*R**2]) + +### *** potential issue *** +### +### The following might not be the correct polarizability tensor -- which +### should be diagonal in the principal axis frame, not? +### Or is there something "special" about a *rod*? + +# polarizability tensor for a cylinder with the figure axis along z (m**3) +# obtained as polarizability volume from a ZENO calucation (angstrom**3), +# see ... (link to blogpost with input and documentation) +P = np.array([[ 50, 0., 0.], + [ 0., 50, 0.], + [ 0., 0.,800.]]) +# conversion to polariability in SI units (C m**2 / V) +# see https://en.wikipedia.org/wiki/Polarizability +P *= ε0 / 1e30 + + +# definition of control field +# we assume a constant ("dc") field corresponding to a laser of intensity 10**10 W/cm**2 +I0 = 1e14/2. # intensity (W/m**2) +# amplitude of the electric field (see https://www.rp-photonics.com/optical_intensity.html) in vacuum (n = 1) +A = np.sqrt((2*I0) / (c * ε0 * 1)) +# applied electric field at 45º from Z in XZ plane +E = A * np.array((1,0,1))/np.sqrt(2) + +# induced dipole: dot product between of polarizability and electric field +dipole = np.dot(P, E) +# torque: cross product between the dipole moment and E +torque = np.cross(dipole, E) +# angular acceleration (with center of mass at origin) +a = torque/I + +# simple estimate of the time needed for the rod to rotate Δθ = 1/4 pi in space (Δθ = 1/2 a t**2) +t = np.sqrt(np.pi/4 / (np.abs(a)/2)) + +# print the result for the +print('Estimated time for 1/4 pi rotation about y (from θ=0..45º in the XZ plane): %.2g s' % t[1])