diff --git a/docs/old_source/api.rst b/docs/old_source/api.rst deleted file mode 100644 index c3af764ba..000000000 --- a/docs/old_source/api.rst +++ /dev/null @@ -1,9 +0,0 @@ -============= -QCFractal API -============= - -.. automodapi:: qcfractal - -.. automodapi:: qcfractal.qc_queue - -.. automodapi:: qcfractal.services diff --git a/docs/old_source/changelog.rst b/docs/old_source/changelog.rst deleted file mode 100644 index 28c13d5e8..000000000 --- a/docs/old_source/changelog.rst +++ /dev/null @@ -1,954 +0,0 @@ -Changelog -========= - -.. Use headers commented below commented as templates - -.. X.Y.0 / 2020-MM-DD -.. ------------------- -.. -.. New Features -.. ++++++++++++ -.. -.. Enhancements -.. ++++++++++++ -.. -.. Bug Fixes -.. +++++++++ - -0.15.8 / 2022-02-04 -------------------- - -Some minor additions/fixes, mostly to to qcportal and the user interface. No database migrations. - -- (:pr:`694`, :pr:`701`) Make QCFractal compatible with new QCElemental and QCEngine versions -- (:pr:`700`) Replace concurrent.futures with multiprocessing in ExecutorAdapter to help with process termination issues -- (:pr:`704`) Eliminate issues when retrieving datasets with duplicate records -- (:pr:`704`) Make saving optional when calling Dataset.compute - - - -0.15.7 / 2021-11-05 -------------------- - -Some minor additions/fixes, mostly to improve performance of some operations -and to prevent consistency issues. The database migrations in (:pr:`676`) have -been thoroughly tested, however please backup you database before ugrading! - -- (:pr:`683`) Fixes issue with keyword aliases not being compared case-insensitive -- (:pr:`685`) Fixes issues with duplicate calculations, large client bodies, and efficiency of certain searches -- (:pr:`686`) Pins qcelemental/qcengine versions -- (:pr:`691`) Fix for some dftd3 calculations not working due to composition_planner -- (:pr:`693`) Allow for additional keywords in torsiondrive optimizations -- (:pr:`694`) Support (and pin) QCElemental v0.23 and QCEngine 0.20 - - - -0.15.6 / 2021-06-06 -------------------- - -Some minor additions/fixes, mostly to the user interface. The database migration in (:pr:`676`) has been thoroughly tested, -however please backup you database before ugrading! - -Client and managers should not need to be upgraded. - -- (:pr:`672`) Adds ability to add compute specs to only a subset of entries in a Dataset -- (:pr:`673`) Allow for selecting by status in dataset get_records() -- (:pr:`676`) A migration for fixing fields in the database which have been changed in QCSchema/QCElemental -- (:pr:`678`) Fixes errors related to str vs. bytes in collection views -- (:pr:`679`) Fix incorrect status reporting in collections - - -0.15.3 / 2021-03-15 -------------------- - -This is a small release focused on some database migrations to improve performance. -This should greatly improve performance of certain actions (particularly task submission) -with large databases. - -This release also drops support for python < 3.7 - -Client and managers should not need to be upgraded. - -- (:pr:`663`) Adds indices to base_result and molecule (improves ability to delete orphan kvstore) -- (:pr:`664`) Adds indices to base_result and access_log (improves existing procedure lookup) - - -0.15.0 / 2020-11-11 -------------------- - -This release is focused on bugfixes, and laying some foundation for larger changes to come. - -New features -++++++++++++ - -- (:pr:`636`) Add ability to profile fractal instances -- (:pr:`642`) Add (experimental!) qcexport code to devtools - -Enhancements -++++++++++++ - -- (:pr:`629`) (Standard) Output of torsion drive service is now captured and stored in the procedure record -- (:pr:`631`) Compress errors on server - -Bug Fixes -+++++++++ - -- (:pr:`624`) Lock task queue rows to prevent multiple managers requesting the same task -- (:pr:`626`) Fix printing of client version during version check failure -- (:pr:`632`) Fix ordering of initial/final molecule in torsion drives -- (:pr:`637`) Fix inability to shutdown ProcessPoolExecutor workers -- (:pr:`638`) Fix incorrect error in datasets -- (:pr:`641`) Fix exception in web handler that was polluting log files - -Miscellaneous -+++++++++++++ -- (:pr:`633`, :pr:`634`, :pr:`635`, :pr:`639`) Miscellaneous cleanup and removal of unused database columns - - -0.14.0 / 2020-09-30 -------------------- - -New Features -++++++++++++ - -- (:pr:`597`) Add ability to query managers -- (:pr:`612`) Enabled compression of KVStore (generally, outputs) -- (:pr:`617`) Ability to control level of logging via the command line -- (:pr:`620`) Add ability to regenerate and modify tasks - - -Enhancements -++++++++++++ - -- (:pr:`592` and :pr:`615`) Improved performance of task retrieval of managers -- (:pr:`620`) Improve performance of task submission, and add additional logging - -Bug Fixes -+++++++++ - -- (:pr:`603`) Fix error when running older computations missing 'protocols' -- (:pr:`617`) Fix printing of base folder with the CLI - - -0.13.1 / 2020-02-18 -------------------- - -New Features -++++++++++++ -- (:pr:`566`) A ``list_keywords`` function was added to ``Dataset``. - -Enhancements -++++++++++++ -- (:pr:`547`, :pr:`553`) Miscellaneous documentation edits and improvements. -- (:pr:`556`) Molecule queries filtered on molecular formula no longer depend on the order of elements. -- (:pr:`565`) ``query`` method for ``Datasets`` now returns collected records. - -Bug Fixes -+++++++++ -- (:pr:`559`) Fixed an issue where Docker images did not have qcfractal in their PATH. -- (:pr:`561`) Fixed a bug that caused errors with pandas v1.0. -- (:pr:`564`) Fixes a bug where optimization protocols were not respected during torsiondrives and grid optimizations. - - -0.13.0 / 2020-01-15 -------------------- - -New Features -++++++++++++ -- (:pr:`541`) Managers can now accept multiple tags. Tasks are pulled first in order of tag, then priority, then creation time. -- (:pr:`544`) Adds backup/restore commands to the QCFractal CLI to allow for easier backup and restore options. - -Enhancements -++++++++++++ -- (:pr:`507`) Automatically adds collection molecules in chunks if more than the current limit needs to be submitted. -- (:pr:`515`) Conda environments now correspond to docker images in all deployed cases. -- (:pr:`524`) The ``delete_collection`` function was added to ``qcportal.FractalClient``. -- (:pr:`530`) Adds the ability to specify cores per rank for node-parallel tasks in QCEngine. -- (:pr:`507`) Adds a formatting and lint check to CI during pull requests. -- (:pr:`535`) Allows dftd3 to be computed for all stoichiometries rather than just defaults. -- (:pr:`542`) Important: TaskRecord.base_result is now an ObjectId (int or str), and no more a ``DBRef``. So, code that uses ``my_task.base_result.id`` should change to simply use ``my_task.base_result``. - -Bug Fixes -+++++++++ -- (:pr:`506`) Fixes repeated visualize calls where previously the visualize call would corrupt local state. -- (:pr:`521`) Fixes an issue where ProcessPoolExecutor returned the incorrect number of currently running tasks. -- (:pr:`522`) Fixes a bug where ``ProcedureDataset.status()`` failed for specifications where only a subset was computed. -- (:pr:`525`) This PR fixes ENTRYPOINT of the qcarchive_worker_openff worker. (Conda and Docker are not friends.) -- (:pr:`532`) Fixes a testing subprocess routine when coverage is enabled for coverage 5.0 breaking changes. -- (:pr:`543`) Fixes a bug where ``qcfractal-server`` "start" before an "upgrade" prevented the "upgrade" command from correctly running. -- (:pr:`545`) Fixed an issue in Dataset.get_records() that could occur when the optional arguments keywords and basis were not provided. - - - -0.12.2 / 2019-12-07 -------------------- - -Enhancements -++++++++++++ -- (:pr:`477`) Removes 0.12.x xfails when connecting to the server. -- (:pr:`481`) Expands Parsl Manager Adapter to include ALCF requirements. -- (:pr:`483`) Dataset Views are now much faster to load in HDF5. -- (:pr:`488`) Allows gzipped dataset views. -- (:pr:`490`) Computes checksums on gzipped dataset views. -- (:pr:`542`) ``TaskRecord.base_result`` is now an ``ObjectId``, and no more a ``DBRef``. So, code that uses ``my_task.base_result.id`` should change to simply be ``my_task.base_result``. - -Bug Fixes -+++++++++ -- (:pr:`486`) Fixes pydantic ``__repr__`` issues after update. -- (:pr:`492`) Fixes error where ``ReactionDataset`` didn't allow a minimum number of n-body expansion to be added. -- (:pr:`493`) Fixes an issue with ``ReactionDataset.get_molecules`` when a subset is present. -- (:pr:`494`) Fixes an issue where queries with ``limit=0`` erroneously returned all results. -- (:pr:`496`) TorsionDrive tests now avoid 90 degree angles with RDKit to avoid some linear issues in the forcefield and make them more stable. -- (:pr:`497`) ``TorsionDrive.get_history`` now works for extremely large (1000+) optimizations in the procedure. - -0.12.1 / 2019-11-08 -------------------- - -Enhancements -++++++++++++ -- (:pr:`472`) Update to GitHub ISSUE templates. -- (:pr:`473`) Server ``/information`` endpoint now contains the number of records for molecules, results, procedures, and collections. -- (:pr:`474`) Dataset Views can now be of arbitrary shape. -- (:pr:`475`) Changes the default formatting of the codebase to Black. - - -Bug Fixes -+++++++++ -- (:pr:`470`) Dataset fix for non-energy units. - -0.12.0 / 2019-11-06 -------------------- - -Highlights -++++++++++ - -- The ability to handle very large datasets (1M+ entries) quickly and efficiently. -- Store and compute Wavefunction information. -- Build, serve, and export views for Datasets that can stored in journal supplementary information or services like Zenodo. -- A new GUI dashboard to observe the current state of the server, see statistics, and fix issues. - -New Features -++++++++++++ -- (:pr:`433` and :pr:`462`) ``Dataset`` and ``ReactionDataset`` (``interface.collections``) now have a ``download``` method which - downloads a frozen view of the dataset. This view is used to speed up calls to ``get_values``, ``get_molecules``, - ``get_entries``, and ``list_values``. -- (:pr:`440`) Wavefunctions can now be stored in the database using Result ``protocols``. -- (:pr:`453`) The server now periodically logs manager and current state to provide data over time. -- (:pr:`460`) Contributed values are now in their own table to speed up access of Collections. -- (:pr:`461`) Services now update their corresponding record every iteration. An example is a torsiondrive which now updates the ``optimization_history`` field each iteration. - -Enhancements -++++++++++++ -- (:pr:`429`) Enables protocols for ``OptimizationDataset`` collections. -- (:pr:`430`) Adds additional QCPortal type hints. -- (:pr:`433`, :pr:`443`) ``Dataset`` and ``ReactionDataset`` (``interface.collections``) are now faster for calls to calls to ``get_values``, ``get_molecules``, - ``get_entries``, and ``list_values`` for large datasets if the server is configured to use frozen views. See "Server-side Dataset Views" documentation. Subsets - may be passed to ``get_values``, ``get_molecules``, and ``get_entries`` -- (:pr:`447`) Enables the creation of plaintext (xyz and csv) output from Dataset Collections. -- (:pr:`455`) Projection queries should now be much faster as excluded results are not pulled to the server. -- (:pr:`458`) Collections now have a metadata field. -- (:pr:`463`) ``FractalClient.list_collections`` by default only returns collections whose visibility flag is set to true, - and whose group is "default". This change was made to filter out in-progress, intermediate, and specialized collections. -- (:pr:`464`) Molecule insert speeds are now 4-16x faster. - -Bug Fixes -+++++++++ -- (:pr:`424`) Fixes a ``ReactionDataset.visualize`` bug with ``groupby='D3'``. -- (:pr:`456`, :pr:`452`) Queries that project hybrid properties should now work as expected. - - -Deprecated Features -+++++++++++++++++++ -- (:pr:`426`) In ``Dataset`` and ``ReactionDataset`` (``interface.collections``), - the previously deprecated functions ``query``, ``get_history``, and ``list_history`` have been removed. - -Optional Dependency Changes -+++++++++++++++++++++++++++ -- (:pr:`454`) Users of the optional Parsl queue adapter are required to upgrade to Parsl v0.9.0, which fixes - issues that caused SLURM managers to crash. - -0.11.0 / 2019-10-01 -------------------- - -New Features -++++++++++++ - -- (:pr:`420`) Pre-storage data handling through Elemental's ``Protocols`` feature are now present in Fractal. Although - only optimization protocols are implemented functionally, the database side has been upgraded to store protocol - settings. - -Enhancements -++++++++++++ - -- (:pr:`385`, :pr:`404`, :pr:`411`) ``Dataset`` and ``ReactionDataset`` have five new functions for accessing data. - ``get_values`` returns the canonical headline value for a dataset (e.g. the interaction energy for S22) in data - columns with caching, both for result-backed values and contributed values. This function replaces the now-deprecated - ``get_history`` and ``get_contributed_values``. ``list_values`` returns the list of data columns available from - ``get_values``. This function replaces the now-deprecated ``list_history`` and ``list_contributed_values``. - ``get_records`` either returns ``ResultRecord`` or a projection. For the case of ``ReactionDataset``, the results are - broken down into component calculations. The function replaces the now-deprecated ``query``. - ``list_records`` returns the list of data columns available from ``get_records``. - ``get_molecules`` returns the ``Molecule`` associated with a dataset. -- (:pr:`393`) A new feature added to ``Client`` to be able to have more custom and fast queries, the ``custom_query`` - method. - Those fast queries are now used in ``torsiondrive.get_final_molecules`` and ``torsiondrive.get_final_results``. More - Advanced queries will be added. -- (:pr:`394`) Adds ``tag`` and ``manager`` selector fields to ``client.query_tasks``. - This is helpful for managing jobs in the queue and detecting failures. -- (:pr:`400`, :pr:`401`, :pr:`410`) Adds Dockerfiles corresponding to builds on - `Docker Hub `_. -- (:pr:`406`) The ``Dataset`` collection's primary indices (database level) have been updated to reflect its new - understanding. - - -Bug Fixes -+++++++++ - -- (:pr:`396`) Fixed a bug in internal ``Dataset`` function which caused ``ComputeResponse`` to be truncated when the - number of calculations is larger than the query_limit. -- (:pr:`403`) Fixed ``Dataset.get_values`` for any method which involved DFTD3. -- (:pr:`409`) Fixed a compatibility bug in specific version of Intel-OpenMP by skipping version - 2019.5-281. - -Documentation Improvements -++++++++++++++++++++++++++ - -- (:pr:`399`) A Kubernetes quickstart guide has been added. - -0.10.0 / 2019-08-26 -------------------- - -.. note:: Stable Beta Release - - This release marks Fractal's official Stable Beta Release. This means that future, non-backwards compatible - changes to the API will result in depreciation warnings. - - -Enhancements -++++++++++++ - -- (:pr:`356`) Collections' database representations have been improved to better support future upgrade paths. -- (:pr:`375`) Dataset Records are now copied alongside the Collections. -- (:pr:`377`) The ``testing`` suite from Fractal now exposes as a PyTest entry-point when Fractal is installed so - that tests can be run from anywhere with the ``--pyargs qcfractal`` flag of ``pytest``. -- (:pr:`384`) "Dataset Records" and "Reaction Dataset Records" have been renamed to "Dataset Entry" and "Reaction - Dataset Entry" respectively. -- (:pr:`387`) The auto-documentation tech introduced in :pr:`321` has been replaced by the improved implementation in - Elemental. - -Bug Fixes -+++++++++ - -- (:pr:`388`) Queue Manager shutdowns will now signal to reset any running tasks they own. - -Documentation Improvements -++++++++++++++++++++++++++ - -- (:pr:`372`, :pr:`376`) Installation instructions have been updated and typo-corrected such that they are accurate - now for both Conda and PyPi. - -0.9.0 / 2019-08-16 ------------------- - -New Features -++++++++++++ - -- (:pr:`354`) Fractal now takes advantage of Elemental's new Msgpack serialization option for Models. Serialization - defaults to msgpack when available (``conda install msgpack-python [-c conda-forge]``), falling back to JSON - otherwise. This results in substantial speedups for both serialization and deserialization actions and should be a - transparent replacement for users within Fractal, Engine, and Elemental themselves. -- (:pr:`358`) Fractal Server now exposes a CLI for user/permissions management through the ``qcfractal-server user`` - command. `See the full documentation for details `_. -- (:pr:`358`) Fractal Server's CLI now supports user manipulations through the ``qcfractal-server user`` subcommand. - This allows server administrators to control users and their access without directly interacting with the storage - socket. - -Enhancements -++++++++++++ - -- (:pr:`330`, :pr:`340`, :pr:`348`, :pr:`349`) Many Pydantic based Models attributes are now documented and in an - on-the-fly manner derived from the Pydantic Schema of those attributes. -- (:pr:`335`) Dataset's ``get_history`` function is fixed by allowing the ability to force a new query even if one has - already been cached. -- (:pr:`338`) The Queue Manager which generated a ``Result`` is now stored in the ``Result`` records themselves. -- (:pr:`341`) Skeletal Queue Manager YAML files can now be generated through the ``--skel`` or ``--skeleton`` CLI flag - on ``qcfractal-manager`` -- (:pr:`361`) Staged DB's in Fractal copy Alembic alongside them. -- (:pr:`363`) A new REST API hook for services has been added so Clients can manage Services. - -Bug Fixes -+++++++++ - -- (:pr:`359`) A ``FutureWarning`` from Pandas has been addressed before it becomes an error. - -Documentation Improvements -++++++++++++++++++++++++++ - -- (:pr:`351`, :pr:`352`, :pr:`353`, :pr:`360`, :pr:`362`, :pr:`364`, :pr:`366`, :pr:`368`) The documentation has been - significantly edited to be up to date, fix numerous typos, reworded and refined for clarity, and overall flow better - between pages. - -0.8.0 / 2019-07-25 ------------------- - -Breaking Changes -++++++++++++++++ - -.. warning:: PostgreSQL is now the only supported database backend. - - Fractal has officially dropped support for MongoDB in favor of PostgreSQL as our - database backend. Although MongoDB served the start of Fractal well, our database design - as evolved since then and will be better served by PostgreSQL. - -New Features -++++++++++++ - -- (:pr:`307`, :pr:`319` :pr:`321`) Fractal's Server CLI has been overhauled to more intuitively and intelligently - control Server creation, startup, configuration, and upgrade paths. This is mainly reflected in a Fractal Server - config file, a config folder - (default location ``~/.qca``, and sub-commands ``init``, ``start``, ``config``, and ``upgrade`` of the - ``qcfractal-server (command)`` CLI. - `See the full documentation for details `_ -- (:pr:`323`) First implementation of the ``GridOptimizationDataset`` for collecting Grid Optimization calculations. - Not yet fully featured, but operational for users to start working with. - - -Enhancements -++++++++++++ - -- (:pr:`291`) Tests have been formally added for the Queue Manager to reduce bugs in the future. They cannot test on - actual Schedulers yet, but its a step in the right direction. -- (:pr:`295`) Quality of life improvement for Mangers which by default will be less noisy about heartbeats and trigger - a heartbeat less frequently. Both options can still be controlled through verbosity and a config setting. -- (:pr:`296`) Services are now prioritized by the date they are created to properly order the compute queue. -- (:pr:`301`) ``TorsionDriveDataset`` status can now be checked through the ``.status()`` method which shows the - current progress of the computed data. -- (:pr:`310`) The Client can now modify tasks and restart them if need be in the event of random failures. -- (:pr:`313`) Queue Managers now have more detailed statistics about failure rates, and core-hours consumed (estimated) -- (:pr:`314`) The ``PostgresHarness`` has been improved to include better error handling if Postgress is not found, and - will not try to stop/start if the target data directory is already configured and running. -- (:pr:`318`) Large collections are now automatically paginated to improve Server/Client response time and reduce - query sizes. See also :pr:`322` for the Client-side requested pagination. -- (:pr:`322`) Client's can request paginated queries for quicker responses. See also :pr:`318` for the Server-side - auto-pagination. -- (:pr:`322`) ``Record`` models and their derivatives now have a ``get_molecule()`` method for fetching the molecule - directly. -- (:pr:`324`) Optimization queries for its trajectory pull the entire trajectory in one go and keep the correct order. - ``get_trajectory`` also pulls the correct order. -- (:pr:`325`) Collections' have been improved to be more efficient. Previous queries are cached locally and the - ``compute`` call is now a single function, removing the need to make a separate call to the submission formation. -- (:pr:`326`) ``ReactionDataset`` now explicitly groups the fragments to future-proof this method from upstream - changes to ``Molecule`` fragmentation. -- (:pr:`329`) All API requests are now logged server side anonymously. -- (:pr:`331`) Queue Manager jobs can now auto-retry failed jobs a finite number of times through QCEngine's retry - capabilities. This will only catch RandomErrors and all other errors are raised normally. -- (:pr:`332`) SQLAlchemy layer on the PostgreSQL database has received significant polish - - -Bug Fixes -+++++++++ - -- (:pr:`291`) Queue Manager documentation generation works on Pydantic 0.28+. A number as-of-yet uncaught/unseen bugs - were revealed in tests and have been fixed as well. -- (:pr:`300`) Errors thrown in the level between Managers and their Adapters now correctly return a ``FailedOperation`` - instead of ``dict`` to be consistent with all other errors and not crash the Manager. -- (:pr:`301`) Invalid passwords present a helpful error message now instead of raising an Internal Server Error to the - user. -- (:pr:`306`) The Manager CLI option ``tasks-per-worker`` is correctly hyphens instead of underscores to be consistent - with all other flags. -- (:pr:`316`) Queue Manager workarounds for older versions of Dask-Jobqueue and Parsl have been removed and implicit - dependency on the newer versions of those Adapters is enforced on CLI usage of ``qcfractal-manager``. These packages - are *not required* for Fractal, so their versions are only checked when specifically used in the Managers. -- (:pr:`320`) Duplicated ``initial_molecules`` in the ``TorsionDriveDataset`` will no longer cause a failure in adding - them to the database while still preserving de-duplication. -- (:pr:`327`) Jupyter Notebook syntax highlighting has been fixed on Fractal's documentation pages. -- (:pr:`331`) The BaseModel/Settings auto-documentation function can no longer throw an error which prevents - using the code. - - -Deprecated Features -+++++++++++++++++++ - -- (:pr:`291`) Queue Manager Template Generator CLI has been removed as its functionality is superseded by the - ``qcfractal-manager`` CLI. - - -0.7.2 / 2019-05-31 ------------------- - -New Features -++++++++++++ - -- (:pr:`279`) Tasks will be deleted from the ``TaskQueue`` once they are completed successfully. -- (:pr:`271`) A new set of scripts have been created to facilitate migration between MongoDB and PostgreSQL. - -Enhancements -++++++++++++ - -- (:pr:`275`) Documentation has been further updated to be more contiguous between pages. -- (:pr:`276`) Imports and type hints in Database objects have been improved to remove ambiguity and make imports easier - to follow. -- (:pr:`280`) Optimizations queried in the database are done with a more efficient lazy ``selectin``. This should make - queries much faster. -- (:pr:`281`) Database Migration tech has been moved to their own folder to keep them isolated from normal - production code. This PR also called the testing database ``test_qcarchivedb`` to avoid - clashes with production DBs. Finally, a new keyword for testing geometry optimizations - has been added. - -Bug Fixes -+++++++++ - -- (:pr:`280`) Fixed a SQL query where ``join`` was set instead of ``noload`` in the lazy reference. -- (:pr:`283`) The monkey-patch for Dask + LSF had a typo in the keyword for its invoke. This has - been fixed for the monkey-patch, as the upstream change was already fixed. - - -0.7.1 / 2019-05-28 ------------------- - -Bug Fixes -+++++++++ - -- (:pr:`277`) A more informative error is thrown when Mongo is not found by ``FractalSnowflake``. -- (:pr:`277`) ID's are no longer presented when listing Collections in Portal to minimize extra data. -- (:pr:`278`) Fixed a bug in Portal where the Server was not reporting the correct unit. - - -0.7.0 / 2019-05-27 ------------------- - -.. warning:: Final MongoDB Supported Release - - **This is the last major release which support MongoDB.** Fractal is moving towards a PostgreSQL for database to - make upgrades more stable and because it is more suited to the nature of QCArchive Data. The upgrade path from - MongoDB to PostgreSQL will be provided by the Fractal developers in the next release. Due to the complex nature - of the upgrade, the PostgreSQL upgrade will through scripts which will be provided. After the PostgreSQL upgrade, - there will be built-in utilities to upgrade the Database. - -New Features -++++++++++++ - -- (:pr:`206`, :pr:`249`, :pr:`264`, :pr:`267`) SQL Database is now feature complete and implemented. As final testing in - production is continued, MongoDB will be phased out in the future. -- (:pr:`242`) Parsl can now be used as an ``Adapter`` in the Queue Managers. -- (:pr:`247`) The new ``OptimizationDataset`` collection has been added! This collection returns a set of optimized - molecular structures given an initial input. -- (:pr:`254`) The QCFractal Server Dashboard is now available through a Dash interface. Although not fully featured yet, - future updates will improve this as features are requested. -- (:pr:`260`) Its now even easier to install Fractal/Portal through conda with pre-built environments on the - ``qcarchive`` conda channel. This channel only provides environment files, no packages (and there are not plans to - do so.) -- (:pr:`269`) The Fractal Snowflake project has been extended to work in Jupyter Notebooks. A Fractal Snowflake can - be created with the ``FractalSnowflakeHandler`` inside of a Jupyter Session. - -Database Compatibility Updates -++++++++++++++++++++++++++++++ - -- (:pr:`256`) API calls to Elemental 0.4 have been updated. This changes the hashing system and so upgrading your - Fractal Server instance to this (or higher) will require an upgrade path to the indices. - -Enhancements -++++++++++++ - -- (:pr:`238`) ``GridOptimizationRecord`` supports the helper function ``get_final_molecules`` which returns the - set of molecules at each final, optimized grid point. -- (:pr:`259`) Both ``GridOptimizationRecord`` and ``TorsionDriveRecord`` support the helper function - ``get_final_results``, which is like ``get_final_molecules``, but for x -- (:pr:`241`) The visualization suite with Plotly has been made more general so it can be invoked in different classes. - This particular PR updates the TorsionDriveDataSet objects. -- (:pr:`243`) TorsionDrives in Fractal now support the updated Torsion Drive API from the underlying package. This - includes both the new arguments and the "extra constraints" features. -- (:pr:`244`) Tasks which fail are now more verbose in the log as to why they failed. This is additional information - on top of the number of pass/fail. -- (:pr:`246`) Queue Manager ``verbosity`` level is now passed down into the adapter programs as well and the log - file (if set) will continue to print to the terminal as well as the physical file. -- (:pr:`247`) Procedure classes now all derive from a common base class to be more consistent with one another and - for any new Procedures going forward. -- (:pr:`248`) Jobs which fail, or cannot be returned correctly, from Queue Managers are now better handled in the - Manager and don't sit in the Manager's internal buffer. They will attempt to be returned to the Server on later - updates. If too many jobs become stale, the Manager will shut itself down for safety. -- (:pr:`258` and :pr:`268`) Fractal Queue Managers are now fully documented, both from the CLI and through the doc pages - themselves. There have also been a few variables renamed and moved to be more clear the nature of what they do. - See the PR for the renamed variables. -- (:pr:`251`) The Fractal Server now reports valid minimum/maximum allowed client versions. The Portal Client will try - check these numbers against itself and fail to connect if it is not within the Server's allowed ranges. Clients - started from Fractal's ``interface`` do not make this check. - -Bug Fixes -+++++++++ - -- (:pr:`248`) Fixed a bug in Queue Managers where the extra worker startup commands for the Dask Adapter were not being - parsed correctly. -- (:pr:`250`) Record objects now correctly set their provenance time on object creation, not module import. -- (:pr:`253`) A spelling bug was fixed in GridOptimization which caused hashing to not be processed correctly. -- (:pr:`270`) LSF clusters not in ``MB`` for the units on memory by config are now auto-detected (or manually set) - without large workarounds in the YAML file and the CLI file itself. Supports documented settings of LSF 9.1.3. - -0.6.0 / 2019-03-30 ------------------- - -Enhancements -++++++++++++ - -- (:pr:`236` and :pr:`237`) A large number of docstrings have been improved to be both more uniform, - complete, and correct. -- (:pr:`239`) DFT-D3 can now be queried through the ``Dataset`` and ``ReactionDataset``. -- (:pr:`239`) ``list_collections`` now returns Pandas Dataframes. - - -0.5.5 / 2019-03-26 ------------------- - -New Features -++++++++++++ - -- (:pr:`228`) ReactionDatasets visualization statistics plots can now be generated through Plotly! This feature includes - bar plots and violin plots and is designed for interactive use through websites, Jupyter notebooks, and more. -- (:pr:`233`) TorsionDrive Datasets have custom visualization statistics through Plotly! This allows plotting 1-D - torsion scans against other ones. - -Enhancements -++++++++++++ - -- (:pr:`226`) LSF can now be specified for the Queue Managers for Dask Managers. -- (:pr:`228`) Plotly is an optional dependency overall, it is not required to run QCFractal or QCPortal but will be - downloaded in some situations. If you don't have Plotly installed, more graceful errors beyond just raw - ``ImportErrors`` are given. -- (:pr:`234`) Queue Managers now report the number of passed and failed jobs they return to the server and can also - have verbose (debug level) outputs to the log. -- (:pr:`234`) Dask-driven Queue Managers can now be set to simply scale up to a fixed number of workers instead of - trying to adapt the number of workers on the fly. - -Bug Fixes -+++++++++ - -- (:pr:`227`) SGE Clusters specified in Queue Manager under Dask correctly process ``job_extra`` for additional - scheduler headers. This is implemented in a stable way such that if the upstream Dask Jobqueue implements a fix, the - Manager will keep working without needing to get a new release. -- (:pr:`234`) Fireworks managers now return the same pydantic models as every other manager instead of raw dictionaries. - - -0.5.4 / 2019-03-21 ------------------- - -New Features -++++++++++++ - -- (:pr:`216`) Jobs submitted to the queue can now be assigned a priority to be served out to the Managers. -- (:pr:`219`) Temporary, pop-up, local instances of ``FractalServer`` can now be created through the - ``FractalSnowflake``. This creates an instance of ``FractalServer``, with its database structure, which is entirely - held in temporary storage and memory, all of which is deleted upon exit/stop. This feature is designed for those - who want to tinker with Fractal without needed to create their own database or connect to a production - ``FractalServer``. -- (:pr:`220`) Queue Managers can now set the ``scratch_directory`` variable that is passed to QCEngine and its workers. - -Enhancements -++++++++++++ - -- (:pr:`216`) Queue Managers now report what programs and procedures they have access to and will only pull jobs they - think they can execute. -- (:pr:`222`) All of ``FractalClient``'s methods now have full docstrings and type annotations for clairy -- (:pr:`222`) Massive overhaul to the REST interface to simplify internal calls from the client and server side. -- (:pr:`223`) ``TorsionDriveDataset`` objects are modeled through pydantic objects to allow easier interface with the - database back end and data validation. - -Bug Fixes -+++++++++ - -- (:pr:`215`) Dask Jobqueue for the ``qcfractal-manager`` is now tested and working. This resolve the outstanding issue - introduced in :pr:`211` and pushed in v0.5.3. -- (:pr:`216`) Tasks are now stored as ``TaskRecord`` pydantic objects which now preempts a bug introduced - from providing the wrong schema. -- (:pr:`217`) Standalone QCPortal installs now report the correct version -- (:pr:`221`) Fixed a bug in ``ReactionDataset.query`` where passing in ``None`` was treated as a string. - - -0.5.3 / 2019-03-13 ------------------- - -New Features -++++++++++++ - -- (:pr:`207`) All compute operations can now be augmented with a ``tag`` which can be later consumed by different - ``QueueManager``\s to only carry out computations with specified tags. -- (:pr:`210`) Passwords in the database can now be generated for new users and user information can be updated (server-side only) -- (:pr:`210`) ``Collections`` can now be updated automatically from the defaults -- (:pr:`211`) The ``qcfractal-manager`` CLI command now accepts a config file for more complex managers through Dask JobQueue. - As such, many of the command line flags have been altered and can be used to either spin up a PoolExecutor, or overwrite the - config file on-the-fly. As of this PR, the Dask Jobqueue component has been untested. Future updates will indicate - when this has been tested. - - -Enhancements -++++++++++++ - -- (:pr:`203`) ``FractalClient``'s ``get_X`` methods have been renamed to ``query_X`` to better reflect what they actually do. - An exception to this is the ``get_collections`` method which is still a true ``get``. -- (:pr:`207`) ``FractalClient.list_collections`` now respects show case sensitive results and queries are case - insensitive -- (:pr:`207`) ``FractalServer`` can now compress responses to reduce the amount of data transmitted over the serialization. - The main benefactor here is the ``OpenFFWorkflow`` collection which has significant transfer speed improvements due to compression. -- (:pr:`207`) The ``OpenFFWorkflow`` collection now has better validation on input and output data. -- (:pr:`210`) The ``OpenFFWorkflow`` collection only stores database ``id`` to reduce duplication and data transfer quantities. - This results in about a 50x duplication reduction. -- (:pr:`211`) The ``qcfractal-template`` command now has fields for Fractal username and password. -- (:pr:`212`) The docs for QCFractal and QCPortal have been split into separate structures. They will be hosted on - separate (although linked) pages, but their content will all be kept in the QCFractal source code. QCPortal's docs - are for most users whereas QCFractal docs will be for those creating their own Managers, Fractal instances, and - developers. - -Bug Fixes -+++++++++ - -- (:pr:`207`) ``FractalClient.get_collections`` is now correctly case insensitive. -- (:pr:`210`) Fixed a bug in the ``iterate`` method of services which returned the wrong status if everything completed right away. -- (:pr:`210`) The ``repr`` of the MongoEngine Socket now displays correctly instead of crashing the socket due to missing attribute - - -0.5.2 / 2019-03-08 ------------------- - -New Features -++++++++++++ - -- (:pr:`197`) New ``FractalClient`` instances will automatically connect to the central MolSSI Fractal Server - -Enhancements -++++++++++++ - -- (:pr:`195`) Read-only access has been granted to many objects separate from their write access. - This is in contrast to the previous model where either there was no access security, or - everything was access secure. -- (:pr:`197`) Unknown stoichiometry are no longer allowed in the ``ReactionDataset`` -- (:pr:`197`) CLI for FractalServer uses Executor only to encourage using the - Template Generator introduced in :pr:`177`. -- (:pr:`197`) ``Dataset`` objects can now query keywords from aliases as well. - - -Bug Fixes -+++++++++ - -- (:pr:`195`) Manager cannot pull too many tasks and potentially loose data due to query limits. -- (:pr:`195`) ``Records`` now correctly adds Provenance information -- (:pr:`196`) ``compute_torsion`` example update to reflect API changes -- (:pr:`197`) Fixed an issue where CLI input flags were not correctly overwriting default values -- (:pr:`197`) Fixed an issue where ``Collections`` were not correctly updating when the ``save`` function was called - on existing objects in the database. -- (:pr:`197`) ``_qcfractal_tags`` are no longer carried through the ``Records`` objects in errant. -- (:pr:`197`) Stoichiometry information is no longer accepted in the ``Dataset`` object since this is not - used in this class of object anymore (see ``ReactionDataset``). - - -0.5.1 / 2019-03-04 ------------------- - -New Features -++++++++++++ -- (:pr:`177`) Adds a new ``qcfractal-template`` command to generate ``qcfractal-manager`` scripts. -- (:pr:`181`) Pagination is added to queries, defaults to 1000 matches. -- (:pr:`185`) Begins setup documentation. -- (:pr:`186`) Begins database design documentation. -- (:pr:`187`) Results add/update is now simplified to always store entire objects rather than update partials. -- (:pr:`189`) All database compute records now go through a single ``BaseRecord`` class that validates and hashes the objects. - -Enhancements -++++++++++++ - -- (:pr:`175`) Refactors query massaging logic to a single function, ensures all program queries are lowercase, etc. -- (:pr:`175`) Keywords are now lazy reference fields. -- (:pr:`182`) Reworks models to have strict fields, and centralizes object hashing with many tests. -- (:pr:`183`) Centralizes duplicate checking so that accidental mixed case duplicate results could go through. -- (:pr:`190`) Adds QCArchive sphinx theme to the documentation. - -Bug Fixes -+++++++++ - -- (:pr:`176`) Benchmarks folder no longer shipped with package - - -0.5.0 / 2019-02-20 ------------------- - -New Features -++++++++++++ - -- (:pr:`165`) Separates datasets into a Dataset, ReactionDataset, and OptimizationDataset for future flexability. -- (:pr:`168`) Services now save their Procedure stubs automatically, the same as normal Procedures. -- (:pr:`169`) ``setup.py`` now uses the README.md and conveys Markdown to PyPI. -- (:pr:`171`) Molecule addition now takes in a flat list and returns a flat list of IDs rather than using a dictionary. -- (:pr:`173`) Services now return their correspond Procedure ID fields. - - -Enhancements -++++++++++++ - -- (:pr:`163`) Ignores pre-existing IDs during storage add operations. -- (:pr:`167`) Allows empty queries to successfully return all results rather than all data in a collection. -- (:pr:`172`) Bumps pydantic version to 0.20 and updates API. - -Bug Fixes -+++++++++ - -- (:pr:`170`) Switches Parsl from IPPExecutor to ThreadExecutor to prevent some bad semaphore conflicts with PyTest. - -0.5.0rc1 / 2019-02-15 ---------------------- - -New Features -++++++++++++ -- (:pr:`114`) A new Collection: ``Generic``, has been added to allow semi-structured user defined data to be built without relying only on implemented collections. -- (:pr:`125`) QCElemental common pydantic models have been integrated throughout the QCFractal code base, making a common model repository for the prevalent ``Molecule`` object (and others) come from a single source. - Also converted QCFractal to pass serialized pydantic objects between QCFractal and QCEngine to allow validation and (de)serialization of objects automatically. -- (:pr:`130`, :pr:`142`, and :pr:`145`) Pydantic serialization has been added to all REST calls leaving and entering both QCFractal Servers and QCFractal Portals. This allows automatic REST call validation and formatting on both server and client sides. -- (:pr:`141` and :pr:`152`) A new GridOptimizationRecord service has been added to QCFractal. This feature supports relative starting positions from the input molecule. - -Enhancements -++++++++++++ - -General note: ``Options`` objects have been renamed to ``KeywordSet`` to better match their goal (See :pr:`155`.) - -- (:pr:`110`) QCFractal now depends on QCElemental and QCEngine to improve consistent imports. -- (:pr:`116`) Queue Manger Adapters are now more generalized and inherit more from the base classes. -- (:pr:`118`) Single and Optimization procedures have been streamlined to have simpler submission specifications and less redundancy. -- (:pr:`133`) Fractal Server and Queue Manager startups are much more verbose and include version information. -- (:pr:`135`) The TorsionDriveService has a much more regular structure based on pydantic models and a new TorsionDrive model has been created to enforce both validation and regularity. -- (:pr:`143`) ``Task``s in the Mongo database can now be referenced by multiple ``Results`` and ``Procedures`` (i.e. a single ``Result`` or ``Procedure`` does not have ownership of a ``Task``.) -- (:pr:`147`) Service submission has been overhauled such that all services submit to a single source. Right now, only one service can be submitted at a time (to be expanded in a future feature.) - TorsionDrive can now have multiple molecule inputs. -- (:pr:`149`) Package import logic has been reworked to reduce the boot-up time of QCFractal from 3000ms at the worst to about 600ms. -- (:pr:`150`) ``KeywordSet`` objects are now modeled much more consistently through pydantic models and are consistently hashed to survive round trip serialization. -- (:pr:`153`) Datasets now support option aliases which map to the consistent ``KeywordSet`` models from :pr:`150`. -- (:pr:`155`) Adding multiple ``Molecule`` or ``Result`` objects to the database at the same time now always return their Database ID's if added, and order of returned list of ID's matches input order. - This PR also renamed ``Options`` to ``KeywordSet`` to properly reflect the goal of the object. -- (:pr:`156`) Memory and Number of Cores per Task can be specified when spinning up a Queue Manager and/or Queue Adapter objects. - These settings are passed on to QCEngine. These must be hard-set by users and no environment inspection is done. Users may continue to choose - not to set these and QCEngine will consume everything it can when it lands on a compute. -- (:pr:`162`) Services can now be saved and fetched from the database through MongoEngine with document validation on both actions. - -Bug Fixes -+++++++++ - -- (:pr:`132`) Fixed MongoEngine Socket bug where calling some functions before others resulted in an error due to lack of initialized variables. -- (:pr:`133`) ``Molecule`` objects cannot be oriented once they enter the QCFractal ecosystem (after optional initial orientation.) ``Molecule`` objects also cannot be oriented by programs invoked by the QCFractal ecosystem so orientation is preserved post-calculation. -- (:pr:`146`) CI environments have been simplified to make maintaining them easier, improve test coverage, and find more bugs. -- (:pr:`158`) Database addition documents in general will strip IDs from the input dictionary which caused issues from MongoEngine having a special treatment for the dictionary key "id". - - -0.4.0a / 2019-01-15 -------------------- - -This is the fourth alpha release of QCFractal focusing on the database backend -and compute manager enhancements. - -New Features -++++++++++++ -- (:pr:`78`) Migrates Mongo backend to MongoEngine. -- (:pr:`78`) Overhauls tasks so that results or procedures own a task and ID. -- (:pr:`78`) Results and procedures are now inserted upon creation, not just completion. Added a status field to results and procedures. -- (:pr:`78`) Overhauls storage API to no longer accept arbitrary JSON queries, but now pinned kwargs. -- (:pr:`106`) Compute managers now have heartbeats and tasks are recycled after a manager has not been heard from after a preset interval. -- (:pr:`106`) Managers now also quietly shutdown on SIGTERM as well as SIGINT. - -Bug Fixes -+++++++++ -- (:pr:`102`) Py37 fix for pydantic and better None defaults for ``options``. -- (:pr:`107`) ``FractalClient.get_collections`` now raises an exception when no collection is found. - - -0.3.0a / 2018-11-02 -------------------- - -This is the third alpha release of QCFractal focusing on a command line -interface and the ability to have multiple queues interacting with a central -server. - -New Features -++++++++++++ -- (:pr:`72`) Queues are no longer required of FractalServer instances, now separate QueueManager instances can be created that push and pull tasks to the server. -- (:pr:`80`) A `Parsl `_ Queue Manager was written. -- (:pr:`75`) CLI's have been added for the ``qcfractal-server`` and ``qcfractal-manager`` instances. -- (:pr:`83`) The status of server tasks and services can now be queried from a FractalClient. -- (:pr:`82`) OpenFF Workflows can now add single optimizations for fragments. - -Enhancements -++++++++++++ - -- (:pr:`74`) The documentation now has flowcharts showing task and service pathways through the code. -- (:pr:`73`) Collection ``.data`` attributes are now typed and validated with pydantic. -- (:pr:`85`) The CLI has been enhanced to cover additional features such as ``queue-manager`` ping time. -- (:pr:`84`) QCEngine 0.4.0 and geomeTRIC 0.9.1 versions are now compatible with QCFractal. - - -Bug Fixes -+++++++++ - -- (:pr:`92`) Fixes an error with query OpenFFWorkflows. - -0.2.0a / 2018-10-02 -------------------- - -This is the second alpha release of QCFractal containing architectural changes -to the relational pieces of the database. Base functionality has been expanded -to generalize the collection idea with BioFragment and OpenFFWorkflow -collections. - -Documentation -+++++++++++++ -- (:pr:`58`) A overview of the QCArchive project was added to demonstrate how all modules connect together. - -New Features -++++++++++++ -- (:pr:`57`) OpenFFWorkflow and BioFragment collections to support OpenFF uses cases. -- (:pr:`57`) Requested compute will now return the id of the new submissions or the id of the completed results if duplicates are submitted. -- (:pr:`67`) The OpenFFWorkflow collection now supports querying of individual geometry optimization trajectories and associated data for each torsiondrive. - -Enhancements -++++++++++++ -- (:pr:`43`) Services and Procedures now exist in the same unified table when complete as a single procedure can be completed in either capacity. -- (:pr:`44`) The backend database was renamed to storage to prevent misunderstanding of the Database collection. -- (:pr:`47`) Tests can that require an activate Mongo instance are now correctly skipped. -- (:pr:`51`) The queue now uses a fast hash index to determine uniqueness and prevent duplicate tasks. -- (:pr:`52`) QCFractal examples are now tested via CI. -- (:pr:`53`) The MongoSocket ``get_generic_by_id`` was deprecated in favor of ``get_generic`` where an ID can be a search field. -- (:pr:`61`, :pr:`64`) TorsionDrive now tracks tasks via ID rather than hash to ensure integrity. -- (:pr:`63`) The Database collection was renamed Dataset to more correctly illuminate its purpose. -- (:pr:`65`) Collection can now be aquired directly from a client via the ``client.get_collection`` function. - -Bug Fixes -+++++++++ -- (:pr:`52`) The molecular comparison technology would occasionally incorrectly orientate molecules. - - -0.1.0a / 2018-09-04 -------------------- - -This is the first alpha release of QCFractal containing the primary structure -of the project and base functionality. - -New Features -++++++++++++ - -- (:pr:`41`) Molecules can now be queried by molecule formula -- (:pr:`39`) The server can now use SSL protection and auto-generates SSL certificates if no certificates are provided. -- (:pr:`31`) Adds authentication to the FractalServer instance. -- (:pr:`26`) Adds TorsionDrive (formally Crank) as the first service. -- (:pr:`26`) Adds a "services" feature which can create large-scale iterative workflows. -- (:pr:`21`) QCFractal now maintains its own internal queue and uses queuing services such as Fireworks or Dask only for the currently running tasks - -Enhancements -++++++++++++ - - -- (:pr:`40`) Examples can now be testing through PyTest. -- (:pr:`38`) First major documentation pass. -- (:pr:`37`) Canonicalizes string formatting to the ``"{}".format`` usage. -- (:pr:`36`) Fireworks workflows are now cleared once complete to keep the active entries small. -- (:pr:`35`) The "database" table can now be updated so that database entries can now evolve over time. -- (:pr:`32`) TorsionDrive services now track all computations that are completed rather than just the last iteration. -- (:pr:`30`) Creates a Slack Community and auto-invite badge on the main readme. -- (:pr:`24`) Remove conda-forge from conda-envs so that more base libraries can be used. - -Bug Fixes -+++++++++ - -- Innumerable bug fixes and improvements in this alpha release. diff --git a/docs/old_source/conf.py b/docs/old_source/conf.py deleted file mode 100644 index 457ab1aed..000000000 --- a/docs/old_source/conf.py +++ /dev/null @@ -1,228 +0,0 @@ -# -*- coding: utf-8 -*- -# -# Configuration file for the Sphinx documentation builder. -# -# This file does only contain a selection of the most common options. For a -# full list see the documentation: -# http://www.sphinx-doc.org/en/master/config - -import datetime -import os -import sys -import qcfractal - -# -- Path setup -------------------------------------------------------------- - -# If extensions (or modules to document with autodoc) are in another directory, -# add these directories to sys.path here. If the directory is relative to the -# documentation root, use os.path.abspath to make it absolute, like shown here. -# -# import os -# import sys -# sys.path.insert(0, os.path.abspath('.')) - - -# -- Project information ----------------------------------------------------- - -project = 'QCFractal' -copyright = f'2018-{datetime.datetime.today().year}, The Molecular Sciences Software Institute' -author = 'The QCArchive Development Team' - -# The short X.Y version -version = qcfractal.__version__ -# The full version, including alpha/beta/rc tags -release = qcfractal.__version__ - - -# -- General configuration --------------------------------------------------- - -# If your documentation needs a minimal Sphinx version, state it here. -# -# needs_sphinx = '1.0' - -# Add any Sphinx extension module names here, as strings. They can be -# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom -# ones. -extensions = [ - 'sphinx.ext.autodoc', - 'sphinx.ext.autosummary', -# 'sphinx.ext.doctest', -# 'sphinx.ext.todo', -# 'sphinx.ext.coverage', - 'sphinx.ext.mathjax', - 'sphinx.ext.viewcode', - 'sphinx.ext.napoleon', - 'sphinx.ext.intersphinx', - 'sphinx.ext.extlinks', - 'sphinx_automodapi.automodapi', - 'nbsphinx' -] - -napoleon_google_docstring = False -napoleon_use_param = False -napoleon_use_ivar = True - -# Add any paths that contain templates here, relative to this directory. -templates_path = ['_templates'] - -# The suffix(es) of source filenames. -# You can specify multiple suffix as a list of string: -# -# source_suffix = ['.rst', '.md'] -source_suffix = '.rst' - -# The master toctree document. -master_doc = 'index' - -# Abbreviations -rst_epilog = """ - -.. color: #273896;"> -.. |PSIfour| raw:: html - - PSI4 - -.. |PSIfours| replace:: |PSIfour|\ 's -.. |qcarc| replace:: :file:`~/.qca/` -.. |dl| replace:: :math:`\Rightarrow` -.. |join_slack_lower| replace:: join our Slack group -.. _join_slack_lower: https://join.slack.com/t/qcdb/shared_invite/enQtNDIzNTQ2OTExODk0LWM3OTgxN2ExYTlkMTlkZjA0OTExZDlmNGRlY2M4NWJlNDlkZGQyYWUxOTJmMzc3M2VlYzZjMjgxMDRkYzFmOTE -.. |join_slack_upper| replace:: Join our Slack group -.. _join_slack_upper: https://join.slack.com/t/qcdb/shared_invite/enQtNDIzNTQ2OTExODk0LWM3OTgxN2ExYTlkMTlkZjA0OTExZDlmNGRlY2M4NWJlNDlkZGQyYWUxOTJmMzc3M2VlYzZjMjgxMDRkYzFmOTE -.. |DaskJQ| replace:: Dask Jobqueue Docs -.. _DaskJQ: https://jobqueue.dask.org/en/latest/ -.. |DaskD| replace:: Dask Distributed Docs -.. _DaskD: http://distributed.dask.org/en/latest/ -.. |ParslDoc| replace:: Parsl Docs -.. _ParslDoc: https://parsl.readthedocs.io/en/latest/index.html -""" - -# The language for content autogenerated by Sphinx. Refer to documentation -# for a list of supported languages. -# -# This is also used if you do content translation via gettext catalogs. -# Usually you set "language" from the command line for these cases. -language = None - -# List of patterns, relative to source directory, that match files and -# directories to ignore when looking for source files. -# This pattern also affects html_static_path and html_extra_path . -exclude_patterns = ['.ipynb_checkpoints/*'] - - -# The name of the Pygments (syntax highlighting) style to use. -pygments_style = 'default' - - -# -- Keywords for HTML output ------------------------------------------------- - -# The theme to use for HTML and HTML Help pages. See the documentation for -# a list of builtin themes. -# -html_theme = 'sphinx_rtd_theme' - -# Theme options are theme-specific and customize the look and feel of a theme -# further. For a list of options available for each theme, see the -# documentation. -# -# html_theme_options = {} - -# Add any paths that contain custom static files (such as style sheets) here, -# relative to this directory. They are copied after the builtin static files, -# so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ['_static'] - -# Custom sidebar templates, must be a dictionary that maps document names -# to template names. -# -# The default sidebars (for documents that don't match any pattern) are -# defined by theme itself. Builtin themes are using these templates by -# default: ``['localtoc.html', 'relations.html', 'sourcelink.html', -# 'searchbox.html']``. -# -# html_sidebars = {} - - -# -- Keywords for HTMLHelp output --------------------------------------------- - -# Output file base name for HTML help builder. -htmlhelp_basename = 'QCFractaldoc' - - -# -- Keywords for LaTeX output ------------------------------------------------ - -latex_elements = { - # The paper size ('letterpaper' or 'a4paper'). - # - # 'papersize': 'letterpaper', - - # The font size ('10pt', '11pt' or '12pt'). - # - # 'pointsize': '10pt', - - # Additional stuff for the LaTeX preamble. - # - # 'preamble': '', - - # Latex figure (float) alignment - # - # 'figure_align': 'htbp', -} - -# Grouping the document tree into LaTeX files. List of tuples -# (source start file, target name, title, -# author, documentclass [howto, manual, or own class]). -latex_documents = [ - (master_doc, 'QCFractal.tex', 'QCFractal Documentation', - 'The QCArchive Development Team', 'manual'), -] - - -# -- Keywords for manual page output ------------------------------------------ - -# One entry per manual page. List of tuples -# (source start file, name, description, authors, manual section). -man_pages = [ - (master_doc, 'qcfractal', 'QCFractal Documentation', - [author], 1) -] - - -# -- Keywords for Texinfo output ---------------------------------------------- - -# Grouping the document tree into Texinfo files. List of tuples -# (source start file, target name, title, author, -# dir menu entry, description, category) -texinfo_documents = [ - (master_doc, 'QCFractal', 'QCFractal Documentation', - author, 'QCFractal', 'One line description of project.', - 'Miscellaneous'), -] - - - -# -- Extension configuration ------------------------------------------------- - -extlinks = { - 'issue': ('https://github.com/MolSSI/QCFractal/issues/%s', 'GH#'), - 'pr': ('https://github.com/MolSSI/QCFractal/pull/%s', 'GH#') -} - - - -# -- Keywords for intersphinx extension --------------------------------------- - -# Example configuration for intersphinx: refer to the Python standard library. -intersphinx_mapping = { - # 'python': ('https://docs.python.org/3.7', None), - # 'numpy': ('https://docs.scipy.org/doc/numpy/', None), - # 'scipy': ('https://docs.scipy.org/doc/scipy/reference/', None), - # 'matplotlib': ('https://matplotlib.org/', None), - 'qcelemental': ('https://qcelemental.readthedocs.io/en/latest/', None), - 'qcengine': ('https://qcengine.readthedocs.io/en/latest/', None), - } - -# -- Keywords for todo extension ---------------------------------------------- - -# If true, `todo` and `todoList` produce output, else they produce nothing. -todo_include_todos = True diff --git a/docs/old_source/database_design.rst b/docs/old_source/database_design.rst deleted file mode 100644 index 0cca4340a..000000000 --- a/docs/old_source/database_design.rst +++ /dev/null @@ -1,117 +0,0 @@ -Database Design -================== - -.. warning:: Final MongoDB Supported Version: 0.7.0 - - **0.7.0 is the last major release which support MongoDB.** Fractal is moving towards a PostgreSQL database to - make upgrades more stable and because it is more suited to the nature of QCArchive Data. The upgrade path from - MongoDB to PostgreSQL will be provided by the Fractal developers in the next release. Due to the complex nature - of the upgrade, the PostgreSQL upgrade will through scripts which will be provided. After the PostgreSQL upgrade, - there will be built-in utilities to upgrade the Database. - -QCArchive stores all its data and computations in a database in the backend -of QCFractal_. The DB is designed with extensibility in mind, allowing -flexibility and easy accommodation of future features. The current backend -of the DB storage is build on top of a non-relational DB, MongoDB, but it can -be easily implemented in a Relational DB like MySQL or Postgres. In addition, -Object Relational Mapping (ORM) is used to add some structure and ensure -validation on the MongoDB which does not have any by definition. The ORM used -is the most popular general MongoDB Python ORM, Mongoengine_. - -.. _Mongoengine: http://mongoengine.org - - -The main idea behind QCArchive DB design is to be able to store and retrieve -wide range of Quantum Chemistry computations using different programs and -variety of configurations. The DB also stores information about jobs submitted -to request computations, and all their related data, along with registered users and -computational managers. - - -QCArchive DB is organized into a set of tables (or documents), each of which are detailed below. - - -1) Molecule -+++++++++++++ - -The molecule table stores molecules used in any computation in the system. -The molecule structure is based on the standard QCSchema_. It stores entries like -geometry, masses, and fragment charges. Please refer to the QCSchema_ for a complete -description of all the possible fields. - -.. Uniqueness among molecules is ensured by creating a hash index calculated using -.. TODO: add a simple description - - -2) Keyword -+++++++++++ - -Keywords are a store of key-value pairs that are configuration for some -QC program. It is flexible and there is no restriction on what configuration -can be stored here. This table referenced by the ``Result`` table. - - -3) Result -++++++++++ - -This table stores the actual computation results along with the attributes -used to calculate it. Each entry is a single unit of computation. -The following are the unique set of keys (or indices) that define a result: - -- ``driver`` - The type of calculation being evaluated (i.e. ``energy``, ``gradient``, ``hessian``, ``properties``) -- ``program``: such as ``gamess`` or ``psi4`` (lower case) -- ``molecule``: the ID of the molecule in the ``Molecule`` table -- ``method``: the method used in the computation (b3lyp, mp2, ccsd(t)) -- ``keywords``: the ID of the keywords in the ``Keywords`` table -- ``basis``: the name of the basis used in the computation (6-31g, cc-pvdz, def2-svp) - -For more information see: :doc:`results`. - - -4) Procedure -+++++++++++++ - -Procedures are also computational results but in a more complex fashion. -They perform more aggregate computations like optimizations, torsion drive, and -grid optimization. The DB can support new types of optimizations by -inheriting from the the base procedure table. Each procedure usually reference -several other results from the ``Results`` table, and possibly other procedures -(self-reference). - - -5) Services -+++++++++++ - -Services are more flexible workflows that eventually produce results to be -stored in the ``Result`` and/or the ``Procedure`` tables when they are done. -So, from the DB point of view, this is an intermediate table for on going -iterative computations. - -More about services in QCArchive can be found here: :doc:`services`. - - -6) TaskQueue -+++++++++++++ - -This table is the main task queue of the system. Tasks are submitted to this -table by QCFractal_ and wait for a manager to pull it for computation. Each -task in the queue references a ``Result`` or a ``Procedure``, meaning that it is -corresponding to a specific Quantum computation. The table stores the status -of the task (``WAITING``, ``RUNNING``, ``COMPLETE``, and ``ERROR``) and also -keeps track of the execution manager and the modification dates. - - -7) QueueManagers -+++++++++++++++++ - -:term:`Managers` are the registered servers for computing tasks from the ``TaskQueue``. -This table keep information about the server such as the host, cluster, -number of completed tasks, submissions, and failures. - -The database only keeps track of what :term:`Tasks` have been handed out to -each :term:`Manager` and maintains a heartbeat to ensure the :term:`Manager` is still connected. More information about -the configuration and execution of managers can be found here: :doc:`managers`. - - -.. _QCSchema: https://github.com/MolSSI/QC_JSON_Schema -.. _QCFractal: https://github.com/MolSSI/QCFractal diff --git a/docs/old_source/dev_guidelines.rst b/docs/old_source/dev_guidelines.rst deleted file mode 100644 index c7b7a077e..000000000 --- a/docs/old_source/dev_guidelines.rst +++ /dev/null @@ -1,26 +0,0 @@ -Development Guidelines -====================== - -QCArchive developers adhere to a set of guidelines, both in the software stylistic guide, and in the outward conduct. -We are working on codifying these in a clean list here, but early guides can be as follows - -Software Development Guides ---------------------------- - -We openly encourage development of the QCArchive and all of its projects in public discourse through GitHub and the -QCArchive Slack (|join_slack_upper|_). - -All changes should be proposed through a PR to the main projects from Forks of said projects. - -For more details about the development cycle and guidelines, please -`see the DevTools Readme on GitHub `_ for the -project. - -Personal Conduct Guides ------------------------ - -Basic rule of thumb: Be respectful, welcome people, keep all interactions harassment-free. - -Please see the -`full Code of Conduct on the project's GitHub page `_ -for more information. diff --git a/docs/old_source/flow.rst b/docs/old_source/flow.rst deleted file mode 100644 index 38bceae03..000000000 --- a/docs/old_source/flow.rst +++ /dev/null @@ -1,42 +0,0 @@ -Fractal Call Flowcharts -======================= - -The interface between the Portal client, the Fractal server, and the distributed -compute resources is not something easily conveyed by text. We have created -flowchart diagrams to help explain what happens from the time Portal invokes a -call to Fractal, to the time that Fractal finishes handling the request. -These diagrams are simplified to not show every routine and middleware -call, but instead to provide a visual aid to what is happening to help -understanding. - -.. _flowchart_add_compute: - -``add_compute`` ---------------- - -This flowchart follows the logic behind a user's call to add a compute action -to fractal and any attached distributed compute system. - -.. image:: media/QCAAddCompute.png - :width: 800px - :alt: Flowchart of what happens when a user calls add_compute - :align: center - - -.. _flowchart_add_procedure: - -``add_procedure`` or ``add_service`` ------------------------------------- - -When a user calls ``add_procedure`` or ``add_service``, much of the same -logic is called. The major difference is which side of the distributed -compute engine the logic of the subsequent procedural calls are handled, -on the compute side, or the Fractal side. - -This flowchart shows both ends and provides a different path -for each call show by the different colored connecting arrows. - -.. image:: media/QCAAddProcedure.png - :width: 800px - :alt: Flowchart of what happens when a user calls add_procedure or add_compute - :align: center diff --git a/docs/old_source/glossary.rst b/docs/old_source/glossary.rst deleted file mode 100644 index 3b7835614..000000000 --- a/docs/old_source/glossary.rst +++ /dev/null @@ -1,65 +0,0 @@ -Glossary -======== - -This glossary contains the common terms which appear over the entire Fractal project. There are other, specialized -glossaries for components of Fractal which are linked below to help group terms together with their contextual docs. -Some terms may appear in multiple glossaries, but will always have the same meaning, e.g. :term:`Queue Adapter` and -:term:`Adapter`. - -.. glossary:: - :sorted: - - Procedures - On-node computations, these can either be a single computation (energy, - gradient, property, etc.) or a series of calculations such as a geometry - optimization. - - Services - Iterative workflows where the required computations are distributed via - the queue and then are processed on the server to acquire the next iteration of - calculations. - - Queue Adapter - The interface between QCFractal's internal queue representation and other - queueing systems such as Dask or Fireworks. Also see the :term:`Adapter` in the - :term:`Manager` glossary. - - Molecule - A unique 3D representation of a molecule. Any changes to the protonation - state, multiplicity, charge, fragments, coordinates, connectivity, isotope, or - ghost atoms represent a change in the molecule. - - DB Socket - A DB Socket (or Database Socket) is the interface layer between standard - Python queries and raw SQL or MongoDB query language. - - DB Index - A DB Index (or Database Index) is a commonly queried field used to speed up - searches in a :term:`DB Table`. - - Hash Index - A index that hashes the information contained in the object - in a reproducible manner. This hash index is only used to find duplicates - and should not be relied upon as it may change in the future. - - ObjectId - A ObjectId (or Database ID) is a unique ID for a given row (a document or - entry) in the database that uniquely defines that particular row in a - :term:`DB Table`. These rows are automatically generated and will be - different for every database, but outlines ways to reference other rows - in the database quickly. A ObjectId is unique to a DB Table. - - DB Table - A set of data inside the Database which has a common :term:`ObjectId`. The ``table`` - name follows SQL conventions which is also known as a ``collection`` in MongoDB. - - Fractal Config Directory - The directory where QCFractal Server and Database configuration files live. This is - also the home of the Database itself in the default configuration. Default path is - ``~/.qca/qcfractal`` - - -Contextually Organized Glossaries ---------------------------------- - -- :ref:`Queue Manager Glossary` diff --git a/docs/old_source/index.rst b/docs/old_source/index.rst deleted file mode 100644 index 4a9b2845b..000000000 --- a/docs/old_source/index.rst +++ /dev/null @@ -1,180 +0,0 @@ -.. QCFractal documentation master file, created by - sphinx-quickstart on Fri Aug 17 09:45:43 2018. - You can adapt this file completely to your liking, but it should at least - contain the root `toctree` directive. - -========= -QCFractal -========= - -*A platform to compute, store, organize, and share large-scale quantum chemistry data.* - -QCFractal emphasizes the following virtues: - -- **Organize:** Large sets of computations are organized into Collections for easy reference and manipulation. -- **Reproducibility:** All steps of commonly used pipelines are elucidated in the input without additional human intervention. -- **History:** Organize all computations ever executed in a research group in an easily indexable manner, never lose data again! -- **Accessibility:** Easily share quantum chemistry data with colleagues or the community through accessibility settings. -- **Elasticity:** Scale from a single laptop to a dozen simultaneous supercomputers. -- **Transferability:** Run many different quantum chemistry, semiempirical, or force field programs with a single unified interface. - -QCFratal within the QCArchive stack ------------------------------------ - -Within the QCArchive stack, QCFractal is responsible for: - -- Accepting requests for calculations, submitted from a client such as `QCPortal `_. -- Running these calculations on disparate compute resources through Quantum Chemistry programs and procedures supported by `QCEngine `_. -- Storing and organizing the results of these calculations in a database. -- Providing access to stored results to clients such as `QCPortal `_. - -The diagram below illustrates a representative data flow: - -.. image:: media/QCEcosystem.png - :width: 800px - :alt: QCArchive ecosystem - :align: center - - -Pipelines ---------- -QCFractal supports several high-throughput pipelines: - -- Ensembles of single point quantum chemistry computations. -- Procedures such as geometry optimization, finite different gradients and Hessians, and complete basis set extrapolations. -- Complex scenarios such as the `OpenFF `_ torsion scan workflow. -- User-defined procedures. - -Data Sharing ------------- - -QCFractal allows for the creation of a single data repository for a group with -varying permission levels to allow control of who can access your data or -submit new tasks to your compute network. Hook into the central MolSSI -repository or create your own! - - -Scales from laptops to supercomputers -------------------------------------- - -QCFractal is build to be elastic, scaling from a single researcher on a laptop -to large multi-PI groups on dozens of different supercomputers. QCFractal -provides a central location to marshal and distribute data or computation. -QCFractal can switch between a variety of computational queue backends such -as: - -- `Parsl `_ - High-performance workflows with backend support for common schedulers, supercomputers, and cloud compute. -- `Dask `_ - A graph-based workflow engine for laptops and small clusters. -- `Fireworks `_ - A asynchronous Mongo-based distributed queuing system. - -Additional backends such as BOINC, RADICAL Pilot, Kubernetes, and Balsam are under active -consideration. :ref:`Contact us ` if you are interested in one of these use-cases. - -======== - -Index ------ - - -**Getting Started** - -* :doc:`install` -* :doc:`quickstart` -* :doc:`setup_quickstart` -* :doc:`setup_server` -* :doc:`setup_compute` - -.. toctree:: - :maxdepth: 1 - :hidden: - :caption: Getting Started - - install.rst - quickstart.ipynb - setup_quickstart.rst - setup_server.rst - setup_compute.rst - -**Records Documentation** - -The records created from adding additional compute. - -* :doc:`results` -* :doc:`procedures` -* :doc:`services` -* :doc:`flow` - -.. toctree:: - :maxdepth: 1 - :hidden: - :caption: Records Documentation - - results.rst - procedures.rst - services.rst - flow.rst - -**Manager Documentation** - -Setting up and running Fractal's Queue Managers on your system. - -* :doc:`managers` -* :doc:`managers_config_api` -* :doc:`managers_hpc` -* :doc:`managers_samples` -* :doc:`managers_faq` - -.. toctree:: - :maxdepth: 1 - :hidden: - :caption: Manager Documentation - - managers.rst - managers_config_api.rst - managers_hpc.rst - managers_samples.rst - managers_faq.rst - managers_detailed.rst - -**Server Documentation** - -Configuring and running the Server from the CLI and Config Files - -* :doc:`server_init` -* :doc:`server_config` -* :doc:`server_start` -* :doc:`server_user` -* :doc:`server_upgrade` - -.. toctree:: - :maxdepth: 1 - :hidden: - :caption: Server CLI and Configuration - - server_init.rst - server_config.rst - server_start.rst - server_user.rst - server_upgrade.rst - server_view.rst - -**Developer Documentation** - -Contains in-depth developer documentation. - -* :doc:`qcarchive_overview` -* :doc:`glossary` -* :doc:`changelog` -* :doc:`glossary` - -.. toctree:: - :maxdepth: 1 - :hidden: - :caption: Developer Documentation - - qcarchive_overview.rst - api.rst - database_design.rst - glossary.rst - dev_guidelines.rst - changelog.rst diff --git a/docs/old_source/install.rst b/docs/old_source/install.rst deleted file mode 100644 index bca5f481f..000000000 --- a/docs/old_source/install.rst +++ /dev/null @@ -1,105 +0,0 @@ -Install QCFractal -================= - -You can install QCFractal with ``conda`` (recommended) or with ``pip`` (with some caveats). - -The below commands install QCFractal and its required dependencies, but *not* any of the quantum -chemistry codes nor the software to run :term:`Queue Managers `. This is done to avoid requiring *all* software -which *can* interface with QCFractal, and instead requires the user to obtain the software they individually *require*. - -.. _conda-install: - -Conda ------ - -You can install QCFractal using `conda `_: - -.. code-block:: console - - >>> conda install qcfractal -c conda-forge - -This installs QCFractal and its dependencies. The QCFractal package is maintained on the -`conda-forge channel `_. - -Conda Pre-Created Environments -++++++++++++++++++++++++++++++ - -QCFractal can also be installed through pre-configured environments you can pull through our Conda Channel: - -.. code-block:: console - - >>> conda env create qcarchive/{environment name} - >>> conda activate {environment name} - -The environments are created from the YAML files hosted on the Anaconda Cloud, which then need to be activated -to use. You can find all of the environments `here `_. - -If you want to use a different name than the environment file, you can add a ``-n {custom name}`` flag to the -``conda env`` command. - -The environments must be installed as new environments and cannot be installed into existing ones. - -The environments are designed to provide pre-built environments which include additional programs beyond QCFractal -itself which are designed for use in production or practical experimentation. For instance, the ``qcf-manager-openff`` -environment also installs a couple quantum chemistry programs, a distributed compute :term:`Queue Adapter`, and a -service which QCFractal can run. This environment can be deployed for immediate use on a remote compute -site (e.g. a cluster) and connect to a QCFractal instance to consume compute tasks. - -Pip ---- - -.. warning:: - - Installing QCFractal from PyPi/``pip`` requires an existing PostgreSQL installation on your computer. Whether that be - through a native install on your device (e.g. managed clusters), a direct installer, ``yum`` install, a ``conda`` - install, or otherwise; it must be installed first or the ``Psycopg2`` package will complain about missing the - ``pg_config``. Installation of PostgreSQL manually is beyond the scope of these instructions, so we recommend - either using a :ref:`Conda install of QCFractal ` or contacting your systems administrator. - -If you have PosgreSQL installed already, you can also install QCFractal using ``pip``: - -.. code-block:: console - - >>> pip install qcfractal - - -Test the Installation ---------------------- - -.. note:: - - There are several optional packages QCFractal can interface with for additional features such as visualization, - :term:`Queue Adapters `, and services. These are not installed by default and so you can expect many - of the tests will be marked with ``skip`` or ``s``. - -You can test to make sure that Fractal is installed correctly by first installing ``pytest``. - -From ``conda``: - -.. code-block:: console - - >>> conda install pytest -c conda-forge - -From ``pip``: - -.. code-block:: console - - >>> pip install pytest - -Then, run the following command: - -.. code-block:: - - >>> pytest --pyargs qcfractal - -QCFractal ships with a small testing plugin which should be automatically detected and gives you access to the -``--runslow`` and ``--runexamples`` PyTest CLI flags. The ``--runslow`` flag tells the testing suite to run any test -the developers think are a bit more time consuming than the others. Without this flag, you will see many tests (such -as those for the CLI) skipped. - - -Developing from Source ----------------------- - -If you are a developer and want to make contributions QCFractal, you can access the source code from -`github `_. diff --git a/docs/old_source/managers.rst b/docs/old_source/managers.rst deleted file mode 100644 index acdb82533..000000000 --- a/docs/old_source/managers.rst +++ /dev/null @@ -1,261 +0,0 @@ -Fractal Queue Managers -====================== - -Queue Managers are the processes which interface with the Fractal :term:`Server` and -clusters, supercomputers, and cloud resources to execute the tasks in the -Fractal :term:`Server`. These managers pull compute :term:`tasks` from the -:term:`Server`, and then pass them to various distributed back ends for computation -for a variety of different needs. The architecture of the Fractal :term:`Server` -allows many managers to be created in multiple physical locations. Currently, -Fractal supports the following: - -- `Pool` - A python `ProcessPoolExecutor` for computing tasks on a single machine (or node). -- `Dask `_ - A graph-based workflow engine for laptops and small clusters. -- `Parsl `_ - High-performance workflows. -- `Fireworks `_ - An asynchronous Mongo-based distributed queuing system. - -These backends allow Fractal to be incredibly elastic in utilizing -computational resources, scaling from a single laptop to thousands of nodes on -physically separate hardware. Our end goal is to be able to setup a manager at -a physical site and allow it to scale up and down as its task queue requires -and execute compute over long periods of time (months) without intervention. - -The basic setup of the Queue :term:`Managers ` and how they interact with the :term:`Server` is as follows: - -.. image:: media/QCQuManagerBasic.png - :width: 400px - :alt: Multiple Managers communicating with one server - :align: right - -In this, multiple :term:`managers ` talk to a central :term:`Fractal Server` and deploy -:term:`tasks` to different compute resources based on availability, physical location, and :term:`tags`. - -The main goals of the Queue :term:`Manager` is to reduce the user's level of expertise needed to start compute with -Fractal and, more importantly, to need as little manual intervention as possible to have persistent compute. Ideally, -you start the :term:`Manager` in a background process, leave it be while it checks in with the -:term:`Fractal Server` from time to time -to get :term:`tasks`, and pushes/pulls :term:`tasks` from the distributed :term:`Adapter` as need be. - -The communication between each of the layers involved, and the mechanism by which they communicate is summarized in -this image: - -.. image:: media/QCQuManagerNetwork.png - :width: 800px - :alt: Line of communication between server to compute - :align: center - -The different levels of communication are all established automatically once the user configures the manager, and -this image shows how information flow from point-to-point. - -The manager itself is a fairly lightweight process and consumes very little CPU power on its own. You should talk with -your sysadmin before running this on a head node, but the Queue :term:`Manager` itself will consume -less than 1% CPU we have found and virtually no RAM. - -If you are interested in the more detailed workings of the :term:`Manager`, please see the :doc:`managers_detailed` -page. However, the information on that page is not required to set up and run a :term:`Manager`. - -Queue Manager Quick Starts --------------------------- - -For those who just want to get up and going, consider the following examples. - -Laptop/Desktop Quick Boot -+++++++++++++++++++++++++ - -To get a Manager set up with defaults, running on local hardware, consuming local CPU and RAM, targeting a -Fractal Server running locally, run the following: - -.. code-block:: bash - - $ qcfractal-manager - -.. _manager_starter_example: - -SLURM Cluster, Dask Adapter -+++++++++++++++++++++++++++ - -To start a manager with a dask :term:`Adapter`, on a SLURM cluster, consuming 1 CPU and 8 GB of ram, targeting a Fractal -Server running on that cluster, and using the SLURM partition ``default``, save the following YAML config file: - -.. code-block:: yaml - - common: - adapter: dask - tasks_per_worker: 1 - cores_per_worker: 1 - memory_per_worker: 8 - - cluster: - scheduler: slurm - - dask: - queue: default - -and then run the following command: - -.. code-block:: bash - - $ qcfractal-manager --config-file="path/to/config.yaml" - -replacing the ``config-file`` arg with the path to the file you saved. You will need ``dask`` and ``dask-jobqueue`` -(|DaskD|_, |DaskJQ|_), to run this example, which are not packages required by Fractal unless you are running compute -managers; if you use a different :term:`Adapter`, you would need a separate set of packages. - - -Queue Manager CLI ------------------ - -The CLI for the Fractal Queue Manager acts as an **option-specific** overwrite of the YAML file for various -options and therefore its flags can be set in tandem with the YAML. However, it does not have as extensive control as -the YAML file and so complex Managers (like those running Dask and Parsl) need to be setup in YAML. - -In case this ever falls out of date, you can always run ``qcfractal-manager --help`` to get the most up-to-date -help block. - -.. code-block:: - - $ qcfractal-manager --help - - usage: qcfractal-manager [-h] [--config-file CONFIG_FILE] [--adapter ADAPTER] - [--tasks_per_worker TASKS_PER_WORKER] - [--cores-per-worker CORES_PER_WORKER] - [--memory-per-worker MEMORY_PER_WORKER] - [--scratch-directory SCRATCH_DIRECTORY] [-v] - [--fractal-uri FRACTAL_URI] [-u USERNAME] - [-p PASSWORD] [--verify VERIFY] - [--manager-name MANAGER_NAME] [--queue-tag QUEUE_TAG] - [--log-file-prefix LOG_FILE_PREFIX] - [--update-frequency UPDATE_FREQUENCY] - [--max-queued-tasks MAX_QUEUED_TASKS] [--test] - [--ntests NTESTS] [--schema] - - A CLI for a QCFractal QueueManager with a ProcessPoolExecutor, Dask, or Parsl - backend. The Dask and Parsl backends *requires* a config file due to the - complexity of its setup. If a config file is specified, the remaining options - serve as CLI overwrites of the config. - - optional arguments: - -h, --help show this help message and exit - --config-file CONFIG_FILE - - Common Adapter Settings: - --adapter ADAPTER The backend adapter to use, currently only {'dask', - 'parsl', 'pool'} are valid. - --tasks_per_worker TASKS_PER_WORKER - The number of simultaneous tasks for the executor to - run, resources will be divided evenly. - --cores-per-worker CORES_PER_WORKER - The number of process for each executor's Workers - --memory-per-worker MEMORY_PER_WORKER - The total amount of memory on the system in GB - --scratch-directory SCRATCH_DIRECTORY - Scratch directory location - -v, --verbose Increase verbosity of the logger. - - FractalServer connection settings: - --fractal-uri FRACTAL_URI - FractalServer location to pull from - -u USERNAME, --username USERNAME - FractalServer username - -p PASSWORD, --password PASSWORD - FractalServer password - --verify VERIFY Do verify the SSL certificate, leave off (unset) for - servers with custom SSL certificates. - - QueueManager settings: - --manager-name MANAGER_NAME - The name of the manager to start - --queue-tag QUEUE_TAG - The queue tag to pull from - --log-file-prefix LOG_FILE_PREFIX - The path prefix of the logfile to write to. - --update-frequency UPDATE_FREQUENCY - The frequency in seconds to check for complete tasks. - --max-queued-tasks MAX_QUEUED_TASKS - Maximum number of tasks to hold at any given time. - Generally should not be set. - - Optional Settings: - --test Boot and run a short test suite to validate setup - --ntests NTESTS How many tests per found program to run, does nothing - without --test set - --schema Display the current Schema (Pydantic) for the YAML - config file and exit. This will always show the most - up-to-date schema. It will be presented in a JSON-like - format. - -.. _manager_glossary: - -Terminology ------------ - -There are a number of terms which can overlap due to the layers of abstraction and the type of software and hardware -the Queue Manager interacts with. To help with that, the pages in this section will use the terminology defined below. -Several pieces of software we interface with may have their own terms or the same term with different meaning, but -because one goal of the Manager is to abstract those concepts away as best it can, we choose the following set. If -you find something inappropriately labeled, unclear, or overloaded in any way, please raise an issue -`on GitHub `_ and help us make it better! - -An important note: Not all the concepts/mechanics of the :term:`Manager` and :term:`Adapter` are covered in the -glossary by design! -There are several abstraction layers and mechanics which the user should never have to interact with or even be aware -of. However, if you feel something is missing, let us know! - -.. glossary:: - :sorted: - - Manager - The :doc:`Fractal Queue Manager`. The term "Manager" presented by itself refers to this object. - - Adapter - The specific piece of software which accepts :term:`tasks` from the :term:`Manager` and sends them to the - physical hardware. It is also the software which typically interacts with a cluster's :term:`Scheduler` to - allocate said hardware and start :term:`Job`. - - Distributed Compute Engine - A more precise, although longer-winded, term for the :term:`Adapter`. - - Scheduler - The software running on a cluster which users request hardware from to run computational :term:`tasks`, - e.g. PBS, SLURM, - LSF, SGE, etc. This, by itself, does not have any concept of the :term:`Manager` or even the :term:`Adapter` - as both interface with *it*, not the other way around. Individual users' clusters may, and almost always, - have a different configuration, even amongst the same governing software. Therefore, no two Schedulers - should be treated the same. In many cases, the :term:`Adapter` submits a :term:`Job` to the Scheduler with - instructions of how the :term:`Job` should start a :term:`Worker` once it is allocated and booted. - - Job - The specific allocation of resources (CPU, Memory, wall clock, etc) provided by the :term:`Scheduler` to the - :term:`Adapter`. This is identical to if you requested batch-like job on a cluster (e.g. though ``qsub`` or - ``sbatch``), however, it is more apt to think of the resources allocated in this way as "resources to be - distributed to the :term:`Task` by the :term:`Adapter`". Although a user running a :term:`Manager` will likely - not directly interact with these, its important to track as these are what your :term:`Scheduler` is actually - running and your allocations will be charged by. At least (and usually only) one :term:`Worker` will be - deployed to a :term:`Job` from the :term:`Adapter` to handle incoming :term:`Task`\s. Once the :term:`Worker` - lands, it will report back to the :term:`Adapter` and all communications happen between those two objects; the - Job simply runs until either the :term:`Adapter` stops it, or the :term:`Scheduler` ends it. - - Task - A single unit of compute as defined by the Fractal :term:`Server` (i.e. the item which comes from the Task - Queue). These tasks are preserved as they pass to the distributed compute engine and are what are presented to - each distributed compute engine's :term:`Worker`\s to compute - - Worker - The process executed from the :term:`Adapter` on the allocated hardware inside a :term:`Job`. This process - receives the :term:`tasks` tracked by the :term:`Adapter` and is responsible for their execution. The - Worker itself is responsible for consuming the resources of the :term:`Job` and distributing them to handle - concurrent :term:`tasks`. In most cases, there will be 1 Worker per :term:`Job`, but there are some - uncommon instances where this isn't true. You can safely assume the 1 Worker/:term:`Job` case for Fractal - usage. Resources allocated for the Worker will be distributed by the :term:`Adapter`\s configuration, - but is usually uniform. - - Server - The Fractal Server that the :term:`Manager` connects to. This is the source of the - :term:`Task`\s which are pulled from and pushed to. Only the :term:`Manager` has any notion - of the Server of all the other software involved with the :term:`Manager` does not. - - Tag - Arbitrary categorization labels that different :term:`tasks` can be assigned when submitted to the - :term:`Server`. :term:`Managers` can pull these tags if configured, and will *exclusively* pull their - defined tag if so. Similarly, :term:`tasks` set with a given tag can *only* be pulled if - their :term:`Manager` is configured to do so. diff --git a/docs/old_source/managers_config_api.rst b/docs/old_source/managers_config_api.rst deleted file mode 100644 index e7cae4b9b..000000000 --- a/docs/old_source/managers_config_api.rst +++ /dev/null @@ -1,74 +0,0 @@ -Queue Manager API -================= - -This page documents **all** valid options for the YAML file inputs to the config manager. This first section outlines -each of the headers (top level objects) and a description for each one. The final file will look like the following: - -.. code-block:: yaml - - common: - option_1: value_for1 - another_opt: 42 - server: - option_for_server: "some string" - - -This is the complete set of options, auto-generated from the parser itself, so it should be accurate for the given -release. If you are using a developmental build or want to see the schema yourself, you can run the -``qcfractal-manager --schema`` command and it will display the whole schema for the YAML input. - -Each section below here is summarized the same way, showing all the options for that YAML header in the form of their -`pydantic `_ API which the YAML is fed into in a one-to-one match of options. - - -.. autoclass:: qcfractal.cli.qcfractal_manager.ManagerSettings - - -common ------- - -.. autoclass:: qcfractal.cli.qcfractal_manager.CommonManagerSettings - - -.. _managers_server: - -server ------- - -.. autoclass:: qcfractal.cli.qcfractal_manager.FractalServerSettings - - -manager -------- - -.. autoclass:: qcfractal.cli.qcfractal_manager.QueueManagerSettings - - -cluster -------- - -.. autoclass:: qcfractal.cli.qcfractal_manager.ClusterSettings - - -dask ----- - -.. autoclass:: qcfractal.cli.qcfractal_manager.DaskQueueSettings - - -parsl ------ - -.. autoclass:: qcfractal.cli.qcfractal_manager.ParslQueueSettings - - -executor -++++++++ - -.. autoclass:: qcfractal.cli.qcfractal_manager.ParslExecutorSettings - - -provider -++++++++ - -.. autoclass:: qcfractal.cli.qcfractal_manager.ParslProviderSettings diff --git a/docs/old_source/managers_detailed.rst b/docs/old_source/managers_detailed.rst deleted file mode 100644 index 70aa3cc9f..000000000 --- a/docs/old_source/managers_detailed.rst +++ /dev/null @@ -1,21 +0,0 @@ -Detailed Manager Information -============================ - -This page documents all the internals of the :term:`Managers` in depth and is **not** intended for the general -user nor should be required for setting up and running them. This page is for those who are interested in the inner -workings and detailed flow of the how the :term:`Manager` interacts with the :term:`Server`, the :term:`Adapter`, -the :term:`Scheduler`, and what it is abstracting away from the user. - -Since this is intended to be a deep dive into mechanics, please let us know if something is missing or unclear and we -can expand this page as needed. - -Manager Flowchart ------------------ - -The Queue Manager's interactions with the Fractal Server, the Distributed Compute Engine, the physical Compute -Hardware, and the user are shown in the following diagram. - -.. image:: media/QCFractalQueueManager.png - :width: 800px - :alt: Flowchart of what happens when a user starts a Queue Manager - :align: center diff --git a/docs/old_source/managers_faq.rst b/docs/old_source/managers_faq.rst deleted file mode 100644 index 33d25a02b..000000000 --- a/docs/old_source/managers_faq.rst +++ /dev/null @@ -1,171 +0,0 @@ -Queue Manager Frequent Questions and Issues -=========================================== - -This page documents some of the frequent questions and issues we see with the -Queue Managers. If this page and none of the other documentation pages have -answered your question, please ask `on GitHub `_ or -|join_slack_lower|_ to get assistance. - -Common Questions ----------------- - -How do I get more information from the Manger? -++++++++++++++++++++++++++++++++++++++++++++++ - -Turn on ``verbose`` mode, either add the ``-v`` flag to the CLI, or set the -``common.verbose`` to ``True`` in the YAML file. Setting this flag will produce -much more detailed information. This sets the loggers to ``DEBUG`` level. - -In the future, we may allow for different levels of increased verbosity, but for now there is -only the one level. - -Can I start more than one Manager at a time? -++++++++++++++++++++++++++++++++++++++++++++ - -Yes. This is often done if you would like to create multiple :term:`task` :term:`tags` that -have different resource requirements or spin up managers that can access -different resources. Check with your cluster administrators though to find out -their policy on multiple processes running on the clusters head node. - -You can reuse the same config file, just invoke the CLI again. - -Can I connect to a Fractal Server besides MolSSI's? -+++++++++++++++++++++++++++++++++++++++++++++++++++ - -Yes! Just change the ``server.fractal_uri`` argument. - -Can I connect to more than one Fractal Server -+++++++++++++++++++++++++++++++++++++++++++++ - -Yes and No. Each :term:`Manager` can only connect to a single :term:`Fractal Server`, but -you can start multiple managers with different config files pointing to different -:term:`Fractal Servers`. - -How do I help contribute compute time to the MolSSI database? -+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - -|join_slack_upper|_! -We would love to talk to you and help get you contributing as well! - -I have this issue, here is my config file... -++++++++++++++++++++++++++++++++++++++++++++ - -Happy to look at it! We only ask that you please **remove the password from the config file before posting it.** -If we see a password, we'll do our best to delete it, but -that does not ensure someone did not see it. - - -Common Issues -------------- - -This documents some of the common issues we see. - -Jobs are quickly started and die without error -++++++++++++++++++++++++++++++++++++++++++++++ - -We see this problem with Dask often and the most common case is the head node (landing node, login node, etc.) -has an ethernet adapter with a different name than the compute nodes. You can check this by running the command -``ip addr`` on both the head node and a compute node (either through an interactive job or a job which writes -the output of that command to a file). - -You will see many lines of output, but there should be a block that looks like the following: - -.. code-block:: - - 1: lo: mtu 65536 qdisc noqueue state UNKNOWN qlen 1 - link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00 - inet 127.0.0.1/8 scope host lo - 3: eno49.4010@eno49: mtu 1500 qdisc noqueue state UP qlen 1000 - inet 10.XX.Y.Z/16 brd 10.XX.255.255 scope global eno49.4010 - 4: eno49.4049@eno49: mtu 1500 qdisc noqueue state UP qlen 1000 - inet 198.XX.YYY.ZZZ/24 brd 198.XX.252.255 scope global eno49.4049 - -the ``XX``, ``YYY`` and ``ZZZ`` will have values corresponding to your cluster's configuration. -There are a few critical items: - -- The headers (``lo``, ``eno.49...``, yours will be different) and the addresses where he ``XX`` placeholders are. -- Ignore the ``lo`` adapter, every machine should have one. -- The head node should have a ``inet`` that looks like a normal IP address, and another one which - looks like it has a ``10.something`` IP address. -- The compute node will likely have an adapter which is only the ``10.something``. -- These ``10.something`` IP addresses are often intranet communication only, meaning the compute - nodes cannot reach the broader internet - -The name of the ethernet adapter housing -the ``10.something`` will be *different* on the head node and the compute node. - -In this case, in your YAML file, add a line in ``dask`` called ``interface`` and set it to the name of the -adapter which is shared. So for this it would be: - -.. code-block:: yaml - - dask: - interface: "eno49.4049" - -plus all the rest of your YAML file. You can safely ignore the bit after the ``@`` sign. - -If there isn't a shared adapter name, try this instead: - -.. code-block:: yaml - - dask: - ip: "10.XX.Y.Z" - -Replace the ``.XX.Y.Z`` with the code which has the intranet IP of the *head node*. This option -acts as a pass through to the Dask :term:`Worker` call and tells the worker to try and connect to the -head node at that IP address. - -If that still doesn't work, contact us. We're working to make this less manual and difficult in the future. - - -Other variants: - -- "My jobs start and stop instantly" -- "My jobs restart forever" - - -My Conda Environments are not Activating -++++++++++++++++++++++++++++++++++++++++ - -You likely have to ``source`` the Conda ``profile.d`` again first. See also -``_ - -This can also happen during testing where you will see command-line based binaries (like Psi4) pass, but Python-based -codes (like RDKit) fail saying complaining about an import error. On cluster compute nodes, this often manifests as -the ``$PATH`` variable being passed from your head node correctly to the compute node, but then the Python imports -cannot be found because the Conda environment is not set up correctly. - -This problem is obfuscated by the fact that -:term:`workers` such as Dask Workers can still start initially despite being a Python code themselves. Many -:term:`adapters` will start their programs using the absolute Python binary path which gets around the -incomplete Conda configuration. **We strongly recommend you do not try setting the absolute Python path** in your -scripts to get around this, and instead try to ``source`` the Conda ``profile.d`` first. For example, you might -need to add something like this to your YAML file (change paths/environment names as needed): - -.. code-block:: yaml - - cluster: - task_startup_commands: - - source ~/miniconda3/etc/profile.d/conda.sh - - conda activate qcfractal - - -Other variants: - -- "Tests from one program pass, but others don't" -- "I get errors about unable to find program, but its installed" -- "I get path and/or import errors when testing" - - -My jobs appear to be running, but only one (or few) workers are starting -++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - -If the jobs appear to be running (and the Manager is reporting they return successfully), -a few things may be happening. - -- If jobs are completing very fast, the :term:`Adapter` may not feel like it needs to start more - :term:`workers`, which is fine. -- (Not recommended, use for debug only) Check your ``manger.max_queued_tasks`` arg to pull more :term:`tasks` - from the :term:`Server` to fill the jobs you have started. This option is usually automatically calculated based on - your ``common.tasks_per_worker`` and ``common.max_workers`` to keep all :term:`workers` busy and - still have a buffer. diff --git a/docs/old_source/managers_hpc.rst b/docs/old_source/managers_hpc.rst deleted file mode 100644 index 60028983b..000000000 --- a/docs/old_source/managers_hpc.rst +++ /dev/null @@ -1,47 +0,0 @@ -Configuration for High-Performance Computing -============================================ - -High-performance computing (HPC) clusters are designed to complete highly-parallel tasks in a short time. -Properly leveraging such clusters requires utilizing large numbers of compute nodes at the same time, -which requires special configurations for the QCFractal manager. -This part of the guide details several routes for configuring HPC clusters to use either large numbers -tasks that each use only a single node, or deploying a smaller number of tasks that use -multiple nodes. - -*Note*: This guide is currently limited to using the Parsl adapter and contains some configuration -options which do not work with other adapters. - -Many Nodes per Job, Single Node per Application ------------------------------------------------ - -The recommended configuration for a QCFractal manager to use multi-node Jobs with -tasks limited to a single node is launch many workers for a single Job. - -The Parsl adapter deploys a single ''manager'' per Job and uses the HPC system's -MPI task launcher to deploy the Parsl executors on to the compute nodes. -Each "executor" will run a single Python process per QCEngine worker and can run -more than one worker per node. -The ``manager`` will run on the login or batch node (depending on the cluster's configuration) -once the Job is started and will communicate to the workers using Parsl's ØMQ messaging protocol. -The QCFractal QueueManager will connect to the Parsl manager for each Job. - -See the `example page `_ for details on how to configure Parsl for your system. -The configuration setting ``common.nodes_per_job`` defines the ability to make multi-node allocation -requests to a scheduler via an Adapter. - -Many Nodes per Job, More than One Node per Application ------------------------------------------------------- - -The recommended configuration for using node-parallel tasks is to have a single QCFractal worker -running on the batch node, and using that worker to launch MPI tasks on the compute nodes. -The differentiating aspect of deploying multi-node tasks is that the QCFractal Worker and -QCEngine Python process will run on different nodes than the quantum chemistry code. - -The Parsl implementation for multi-node jobs will place a Parsl single executor and interchange -on the login/batch node. -The Parsl executor will launch a number of workers (as separate Python processes) -equal to the number of nodes per Job divided by the number of nodes per Task. -The worker will call the MPI launch system to place quantum-chemistry calculations on -the compute nodes of the clusters. - -See the `example page `_ for details on how to configure Parsl for your system. diff --git a/docs/old_source/managers_samples.rst b/docs/old_source/managers_samples.rst deleted file mode 100644 index ed43f1788..000000000 --- a/docs/old_source/managers_samples.rst +++ /dev/null @@ -1,308 +0,0 @@ -Queue Manager Example YAML Files -================================ - -The primary way to set up a :term:`Manager` is to setup a YAML config file. -This page provides helpful config files which mostly can be just copied -and used in place (filling in things like :ref:`**username** and **password** ` -as needed.) - -The full documentation of every option and how it can be used can be found in -:doc:`the Queue Manager's API `. - -For these examples, the ``username`` will always be "Foo" and the ``password`` will always be "b4R" -(which are just placeholders and not valid). The ``manager_name`` variable can be any string and these examples provide -some descriptive samples. The more distinct the name, the better it is to see its status on the :term:`Server`. - -SLURM Cluster, Dask Adapter with additional options ---------------------------------------------------- - -This example is similar to the :ref:`example on the start page for Managers`, but with some -additional options such as connecting back to a central Fractal instance and setting more cluster-specific options. -Again, this starts a manager with a dask :term:`Adapter`, on a SLURM cluster, consuming 1 CPU and 8 GB of ram, targeting -a Fractal Server running on that cluster, and using the SLURM partition ``default``, save the following YAML config -file: - -.. code-block:: yaml - - common: - adapter: dask - tasks_per_worker: 1 - cores_per_worker: 1 - memory_per_worker: 8 - - server: - fractal_uri: "localhost:7777" - username: Foo - password: b4R - - manager: - manager_name: "SlurmCluster_OneDaskTask" - - cluster: - scheduler: slurm - walltime: "72:00:00" - - dask: - queue: default - - -Multiple Tasks, 1 Cluster Job ------------------------------ - -This example starts a max of 1 cluster :term:`Job`, but multiple :term:`tasks`. The hardware will be -consumed uniformly by the :term:`Worker`. With 8 cores, 20 GB of memory, and 4 tasks; the :term:`Worker` will provide -2 cores and 5 GB of memory to compute each :term:`Task`. We set ``common.max_workers`` to 1 to limit the number -of :term:`Workers` and :term:`Jobs ` which can be started. Since this is SLURM, the ``squeue`` information -will show this user has run 1 ``sbatch`` jobs which requested 4 cores and 20 GB of memory. - -.. code-block:: yaml - - common: - adapter: dask - tasks_per_worker: 4 - cores_per_worker: 8 - memory_per_worker: 20 - max_workers: 1 - - server: - fractal_uri: "localhost:7777" - username: Foo - password: b4R - - manager: - manager_name: "SlurmCluster_MultiDask" - - cluster: - scheduler: slurm - walltime: "72:00:00" - - dask: - queue: default - - -Testing the Manager Setup -------------------------- - -This will test the :term:`Manager` to make sure it's setup correctly, and does not need to -connect to the :term:`Server`, and therefore does not need a ``server`` block. It will still however submit -:term:`jobs `. - -.. code-block:: yaml - - common: - adapter: dask - tasks_per_worker: 2 - cores_per_worker: 4 - memory_per_worker: 10 - - manager: - manager_name: "TestBox_NeverSeen_OnServer" - test: True - ntests: 5 - - cluster: - scheduler: slurm - walltime: "01:00:00" - - dask: - queue: default - - -Running commands before work ----------------------------- - -Suppose there are some commands you want to run *before* starting the :term:`Worker`, such as starting a Conda -environment, or setting some environment variables. This lets you specify that. For this, we will run on a -Sun Grid Engine (SGE) cluster, start a conda environment, and load a module. - -An important note about this one, we have now set ``max_workers`` to something larger than 1. -Each :term:`Job` will still request 16 cores and 256 GB of memory to be evenly distributed between the -4 :term:`tasks`, however, the :term:`Adapter` will **attempt to start 5 independent** :term:`jobs`, for a -total of 80 cores, 1.280 TB of memory, distributed over 5 :term:`Workers` collectively running 20 concurrent -:term:`tasks`. If the :term:`Scheduler` does not -allow all of those :term:`jobs` to start, whether due to lack of resources or user limits, the -:term:`Adapter` can still start fewer :term:`jobs`, each with 16 cores and 256 GB of memory, but :term:`Task` -concurrency will change by blocks of 4 since the :term:`Worker` in each :term:`Job` is configured to handle 4 -:term:`tasks` each. - -.. code-block:: yaml - - common: - adapter: dask - tasks_per_worker: 4 - cores_per_worker: 16 - memory_per_worker: 256 - max_workers: 5 - - server: - fractal_uri: localhost:7777 - username: Foo - password: b4R - - manager: - manager_name: "GridEngine_OpenMPI_DaskWorker" - test: False - - cluster: - scheduler: sge - task_startup_commands: - - module load mpi/gcc/openmpi-1.6.4 - - conda activate qcfmanager - walltime: "71:00:00" - - dask: - queue: free64 - - -Additional Scheduler Flags --------------------------- - -A :term:`Scheduler` may ask you to set additional flags (or you might want to) when submitting a :term:`Job`. -Maybe it's a Sys. Admin enforced rule, maybe you want to pull from a specific account, or set something not -interpreted for you in the :term:`Manager` or :term:`Adapter` (do tell us though if this is the case). This -example sets additional flags on a PBS cluster such that the final :term:`Job` launch file will have -``#PBS {my headers}``. - -This example also uses Parsl and sets a scratch directory. - -.. code-block:: yaml - - common: - adapter: parsl - tasks_per_worker: 1 - cores_per_worker: 6 - memory_per_worker: 64 - max_workers: 5 - scratch_directory: "$TMPDIR" - - server: - fractal_uri: localhost:7777 - username: Foo - password: b4R - verify: False - - manager: - manager_name: "PBS_Parsl_MyPIGroupAccount_Manger" - - cluster: - node_exclusivity: True - scheduler: pbs - scheduler_options: - - "-A MyPIsGroupAccount" - task_startup_commands: - - conda activate qca - - cd $WORK - walltime: "06:00:00" - - parsl: - provider: - partition: normal_q - cmd_timeout: 30 - - -Single Job with Multiple Nodes and Single-Node Tasks with Parsl Adapter ------------------------------------------------------------------------ - -Leadership platforms prefer or require more than one node per Job request. -The following configuration will request a Job with 256 nodes and place one Worker on each node. - -.. code-block:: yaml - - common: - adapter: parsl - tasks_per_worker: 1 - cores_per_worker: 64 # Number of cores per compute node - max_workers: 256 # Maximum number of workers deployed to compute nodes - nodes_per_job: 256 - - cluster: - node_exclusivity: true - task_startup_commands: - - module load miniconda-3/latest # You will need to load the Python environment on startup - - source activate qcfractal - - export KMP_AFFINITY=disable # KNL-related issue. Needed for multithreaded apps - - export PATH=~/software/psi4/bin:$PATH # Points to psi4 compiled for compute nodes - scheduler: cobalt # Varies depending on supercomputing center - - parsl: - provider: - queue: default - launcher: # Defines the MPI launching function - launcher_class: AprunLauncher - overrides: -d 64 # Option for XC40 machines, allows workers to access 64 threads - init_blocks: 0 - min_blocks: 0 - account: CSC249ADCD08 - cmd_timeout: 60 - walltime: "3:00:00" - -Consult the `Parsl configuration docs `_ -for information on how to configure the Launcher and Provider classes for your cluster. - - -Single Job with Multiple, Node-Parallel Tasks with Parsl Adapter ----------------------------------------------------------------- - -Running MPI-parallel tasks requires a similar configuration to the multiple nodes per job -for the manager and also some extra work in defining the qcengine environment. -The key difference that sets apart managers for node-parallel applications is that -that ``nodes_per_job`` is set to more than one and -Parsl uses ``SimpleLauncher`` to deploy a Parsl executor onto -the batch/login node once a job is allocated. - -.. code-block:: yaml - - common: - adapter: parsl - tasks_per_worker: 1 - cores_per_worker: 16 # Number of cores used on each compute node - max_workers: 128 - memory_per_worker: 180 # Summary for the amount per compute node - nodes_per_job: 128 - nodes_per_task: 2 # Number of nodes to use for each task - cores_per_rank: 1 # Number of cores to each of each MPI rank - - cluster: - node_exclusivity: true - task_startup_commands: - - module load miniconda-3/latest - - source activate qcfractal - - export PATH="/soft/applications/nwchem/6.8/bin/:$PATH" - - which nwchem - scheduler: cobalt - - parsl: - provider: - queue: default - launcher: - launcher_class: SimpleLauncher - init_blocks: 0 - min_blocks: 0 - account: CSC249ADCD08 - cmd_timeout: 60 - walltime: "0:30:00" - -The configuration that describes how to launch the tasks must be written at a ``qcengine.yaml`` -file. See `QCEngine docs `_ -for possible locations to place the ``qcengine.yaml`` file and full descriptions of the -configuration option. -One key option for the ``qcengine.yaml`` file is the description of how to launch MPI -tasks, ``mpiexec_command``. For example, many systems use ``mpirun`` -(e.g., `OpenMPI `_). -An example configuration a Cray supercomputer is: - -.. code-block:: yaml - - all: - hostname_pattern: "*" - scratch_directory: ./scratch # Must be on the global filesystem - is_batch_node: True # Indicates that `aprun` must be used for all QC code invocations - mpiexec_command: "aprun -n {total_ranks} -N {ranks_per_node} -C -cc depth --env CRAY_OMP_CHECK_AFFINITY=TRUE --env OMP_NUM_THREADS={cores_per_rank} --env MKL_NUM_THREADS={cores_per_rank} - -d {cores_per_rank} -j 1" - jobs_per_node: 1 - ncores: 64 - -Note that there are several variables in the ``mpiexec_command`` that describe how to insert parallel configurations into the -command: ``total_ranks``, ``ranks_per_node``, and ``cores_per_rank``. -Each of these values are computed based on the number of cores per node, the number of nodes per application -and the number of cores per MPI rank, which are all defined in the Manager settings file. diff --git a/docs/old_source/media/QCAAddCompute.png b/docs/old_source/media/QCAAddCompute.png deleted file mode 100644 index c366d7b08..000000000 Binary files a/docs/old_source/media/QCAAddCompute.png and /dev/null differ diff --git a/docs/old_source/media/QCAAddProcedure.png b/docs/old_source/media/QCAAddProcedure.png deleted file mode 100644 index 08cbb0437..000000000 Binary files a/docs/old_source/media/QCAAddProcedure.png and /dev/null differ diff --git a/docs/old_source/media/QCEcosystem.png b/docs/old_source/media/QCEcosystem.png deleted file mode 100644 index dea15c93a..000000000 Binary files a/docs/old_source/media/QCEcosystem.png and /dev/null differ diff --git a/docs/old_source/media/QCFractalQueueManager.png b/docs/old_source/media/QCFractalQueueManager.png deleted file mode 100644 index de14877ad..000000000 Binary files a/docs/old_source/media/QCFractalQueueManager.png and /dev/null differ diff --git a/docs/old_source/media/QCFractalQueueManager.xml b/docs/old_source/media/QCFractalQueueManager.xml deleted file mode 100644 index 4af28bb44..000000000 --- a/docs/old_source/media/QCFractalQueueManager.xml +++ /dev/null @@ -1,2 +0,0 @@ - -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 \ No newline at end of file diff --git a/docs/old_source/media/QCQuManagerBasic.png b/docs/old_source/media/QCQuManagerBasic.png deleted file mode 100644 index afcd995dc..000000000 Binary files a/docs/old_source/media/QCQuManagerBasic.png and /dev/null differ diff --git a/docs/old_source/media/QCQuManagerBasic.xml b/docs/old_source/media/QCQuManagerBasic.xml deleted file mode 100644 index e28a6029d..000000000 --- a/docs/old_source/media/QCQuManagerBasic.xml +++ /dev/null @@ -1,2 +0,0 @@ - -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 \ No newline at end of file diff --git a/docs/old_source/media/QCQuManagerNetwork.png b/docs/old_source/media/QCQuManagerNetwork.png deleted file mode 100644 index 3ff828ca4..000000000 Binary files a/docs/old_source/media/QCQuManagerNetwork.png and /dev/null differ diff --git a/docs/old_source/media/QCQuManagerNetwork.xml b/docs/old_source/media/QCQuManagerNetwork.xml deleted file mode 100644 index 73bf33337..000000000 --- a/docs/old_source/media/QCQuManagerNetwork.xml +++ /dev/null @@ -1,2 +0,0 @@ - -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 \ No newline at end of file diff --git a/docs/old_source/media/boxology_overview.jpg b/docs/old_source/media/boxology_overview.jpg deleted file mode 100644 index 5b0790a4b..000000000 Binary files a/docs/old_source/media/boxology_overview.jpg and /dev/null differ diff --git a/docs/old_source/media/openff_torsion_workflow.jpg b/docs/old_source/media/openff_torsion_workflow.jpg deleted file mode 100644 index 9bdb5cf7b..000000000 Binary files a/docs/old_source/media/openff_torsion_workflow.jpg and /dev/null differ diff --git a/docs/old_source/procedures.rst b/docs/old_source/procedures.rst deleted file mode 100644 index 2eca31116..000000000 --- a/docs/old_source/procedures.rst +++ /dev/null @@ -1,8 +0,0 @@ -Procedures -========== - -Pictorial Procedure Flowchart ------------------------------ - -See the :ref:`flowchart showing the psuedo-calls ` made -when the Client adds a procedure to Fractal. diff --git a/docs/old_source/qcarchive_overview.rst b/docs/old_source/qcarchive_overview.rst deleted file mode 100644 index 019cc162a..000000000 --- a/docs/old_source/qcarchive_overview.rst +++ /dev/null @@ -1,134 +0,0 @@ -QCArchive Design -================== - -The QCArchive software ecosystem consists of a series of Python modules that -can either be used together or are useful standalone pieces to the -computational molecular sciences community. This ecosystem is constructed to -be used at single-user, small group, and multi-PI levels while retaining -the ability to scale up to the needs of an entire community of scientist. - -In each case, it is expected only a small number of users are required to -understand the entire software stack and the primary interaction with the -QCArchive ecosystem will be through the user front-end (QCPortal). After the -persistence server instance (QCFractal) is instantiated with a distributed -workflow system and compute the server should be able to maintain -itself without user intervention. A diagram of how the ecosystem works in -concert can be seen below: - - - -.. image:: media/boxology_overview.jpg - :width: 800px - :alt: QCArchive project structure - :align: center - -1) QCPortal -++++++++++++ - -.. image:: https://img.shields.io/github/stars/MolSSI/QCPortal.svg?style=social&label=Stars - :width: 100px - :align: center - :target: https://github.com/MolSSI/QCPortal - -- Hardware: Laptop -- Actor: User -- Primary Developer: MolSSI - -QCPortal provides a Python-based user front-end experience for users who are -interested in exploring data and executing new tasks. Exploration of computed -data is augmented by the ability to generate graphs quickly and other -representations to view the data in Jupyter notebooks and high-level -abstractions are used to view and manipulate many individual tasks -simultaneously. Querying of data and submission of new tasks occurs over the -QCFractal REST API. - - -2) QCFractal -++++++++++++ - -.. image:: https://img.shields.io/github/stars/MolSSI/QCFractal.svg?style=social&label=Stars - :width: 100px - :align: center - :target: https://github.com/MolSSI/QCFractal - -- Hardware: Persistent Server -- Actor: Power User -- Primary Developer: MolSSI - -QCFractal is the primary persistent server that QCPortal communicates with and has several main duties: - -- Maintain a database of all completed quantum chemistry results along with metadata that forms higher-level collections of results. -- Maintain a compute queue of all requested and completed tasks. Where each task is a single quantum chemistry result. -- Submit new tasks to distributed workflow engines and insert complete results into the database. -- Maintain high level compute workflows via the "Services" feature. - - -3) Distributed Compute -++++++++++++++++++++++ - -- Hardware: Persistent Server/Supercomputer -- Actor: Power User (can be separate from the Fractal Power Users) -- Primary Developer: Scientific and HPC Communities - -The QCArchive project relies on a number of distributed compute workflow -engines to enable a large variety of compute workloads. QCFractal will -interact with each of these projects by submitting a series of tasks that do -not have data or execution order dependence. The communication interfaces vary -from Python-based API calls to REST API interfaces depending on the -implementation details of the individual tools. - -Current distributed compute backends are: - -- `Dask Distributed `_ - Multi-node task graph scheduler built in Python. -- `Parsl `_ - High-performance workflows. -- `Fireworks `_ - Multi-site task scheduler built in Python with a central MongoDB server. - -Pending backend implementations include: - -- `RADICAL Cybertools `_ - Distributed task scheduler built for DOE and NSF compute resources. -- `BOINC `_ - High throughput volunteer computing task manager. -- `Balsam `_ - Task manager for a single compute resource (supercomputer) with tasks pulled from a central server. - -The compute workers of each of these tools is executed in different ways. -However, in each case the compute workers will distribute QCSchema_ inputs, -call QCEngine, and receive a QCSchema_ output. - -4) QCEngine -++++++++++++ - -.. image:: https://img.shields.io/github/stars/MolSSI/QCEngine.svg?style=social&label=Stars - :width: 100px - :align: center - :target: https://github.com/MolSSI/QCEngine - -- Hardware: Local Cluster, Supercomputer, or Cloud Compute -- Actor: Power User - -QCEngine is a stateless, lightweight wrapper around Quantum Chemistry programs -so that these programs consistently accept and emit QCSchema_. Depending on -the underlying program QCEngine provides this uniform interface by either: - -1) Calling the QCSchema_ IO functions that individual program have implemented. -2) Calling the Python-API of the program and modifying the input/output according to the QCSchema_. -3) Writing a ASCII input file based on the input QCSchema_, running the program, and parsing an ASCII output file into the QCSchema_. - - -QCEngine also keeps track of the provenance of each task. This includes: - -- A description of the hardware used (CPU, GPU, memory, etc). -- The total compute time and resources allocated to the run. -- The function and version of the program called. - - -5) 3rd Party Services -+++++++++++++++++++++ - -- Hardware: Laptop -- Actor: User/Power User -- Primary Developer: Computational Molecular Sciences Community - -The QCFractal API is expected to have additional services attached by 3rd -parties. These services can range from cross-reference data services to user -website that visualize and interact with the data in a specific way, - -.. _QCSchema: https://github.com/MolSSI/QC_JSON_Schema diff --git a/docs/old_source/quickstart.ipynb b/docs/old_source/quickstart.ipynb deleted file mode 100644 index e047197f5..000000000 --- a/docs/old_source/quickstart.ipynb +++ /dev/null @@ -1,4995 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Example\n", - "\n", - "This tutorial will go over general QCFractal usage to give a feel for the ecosystem. \n", - "In this tutorial, we employ Snowflake, a simple QCFractal stack which runs on a local machine \n", - "for demonstration and exploration purposes.\n", - "\n", - "## Installation\n", - "\n", - "To begin this quickstart tutorial, first install the QCArchive Snowflake environment from conda:\n", - "\n", - "```\n", - "conda env create qcarchive/qcfractal-snowflake -n snowflake\n", - "conda activate snowflake\n", - "```\n", - "\n", - "If you have a pre-existing environment with `qcfractal`, ensure that `rdkit` and `geometric` are installed from the `conda-forge` channel and `psi4` and `dftd3` from the `psi4` channel.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Importing QCFractal\n", - "\n", - "First let us import two items from the ecosystem:\n", - "\n", - "\n", - " * [FractalSnowflakeHandler](http://docs.qcarchive.molssi.org/projects/qcfractal/en/latest/api/qcfractal.FractalSnowflakeHandler.html?highlight=FractalSnowflakeHandler) - This is a [FractalServer](https://qcarchivetutorials.readthedocs.io/projects/qcfractal/en/latest/api/qcfractal.FractalServer.html) that is temporary and is used for trying out new things.\n", - "\n", - " * `qcfractal.interface` is the [QCPortal](https://github.com/MolSSI/QCPortal) module, but if using QCFractal it is best to import it locally.\n", - " \n", - "Typically we alias `qcportal` as `ptl`. We will do the same for `qcfractal.interface` so that the code can be used anywhere." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from qcfractal import FractalSnowflakeHandler\n", - "import qcfractal.interface as ptl" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can now build a temporary server which acts just like a normal server, but we have a bit more direct control of it.\n", - "\n", - "**Warning!** All data is lost when this notebook shuts down! This is for demonstration purposes only!\n", - "For information about how to setup a permanent QCFractal server, see the [Setup Quickstart Guide](setup_quickstart.rst). " - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "

FractalSnowflakeHandler

\n", - "
    \n", - "
  • Server:   db_4dd4a305_1692_4f29_ae5a_ac4c8bcb1002
    • \n", - "
  • Address:   https://localhost:60885
    • \n", - "
\n" - ], - "text/plain": [ - "FractalSnowflakeHandler(name='db_4dd4a305_1692_4f29_ae5a_ac4c8bcb1002' uri='https://localhost:60885')" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "server = FractalSnowflakeHandler()\n", - "server" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can then build a typical [FractalClient](http://docs.qcarchive.molssi.org/projects/qcportal/en/latest/client.html?highlight=fractalclient#portal-client) \n", - "to automatically connect to this server using the [client()](http://docs.qcarchive.molssi.org/projects/qcfractal/en/latest/api/qcfractal.FractalSnowflakeHandler.html?highlight=FractalSnowflakeHandler#qcfractal.FractalSnowflakeHandler.client) helper command. \n", - "Note that the server names and addresses are identical in both the server and client." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "

FractalClient

\n", - "
    \n", - "
  • Server:   FractalSnowFlake_db_4dd4a
    • \n", - "
  • Address:   https://localhost:60885/
    • \n", - "
  • Username:   None
    • \n", - "
\n" - ], - "text/plain": [ - "FractalClient(server_name='FractalSnowFlake_db_4dd4a', address='https://localhost:60885/', username='None')" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "client = server.client()\n", - "client" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Adding and Querying data\n", - "\n", - "A server starts with no data, so let's add some! We can do this by adding a water molecule at a poor geometry from XYZ coordinates. \n", - "Note that all internal QCFractal values are stored and used in atomic units; \n", - "whereas, the standard [Molecule.from_data()](http://docs.qcarchive.molssi.org/projects/qcelemental/en/latest/molecule.html?highlight=from_data#creation) assumes an input of Angstroms. \n", - "We can switch this back to Bohr by adding a `units` command in the text string. " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c872801ba6ef40f5bd1ba3489caabbee", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "_ColormakerRegistry()" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "5a86b98162284e76aa45a9e5f2c3c184", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "NGLWidget()" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "mol = ptl.Molecule.from_data(\"\"\"\n", - "O 0 0 0\n", - "H 0 0 2\n", - "H 0 2 0\n", - "units bohr\n", - "\"\"\")\n", - "mol" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can then measure various aspects of this molecule to determine its shape. Note that the `measure` command will provide a distance, angle, or dihedral depending if 2, 3, or 4 indices are passed in.\n", - "\n", - "This molecule is quite far from optimal, so let's run an geometry optimization!" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2.0\n", - "90.0\n" - ] - } - ], - "source": [ - "print(mol.measure([0, 1]))\n", - "print(mol.measure([1, 0, 2]))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Evaluating a Geometry Optimization\n", - "\n", - "We originally installed `psi4` and `geometric`, so we can use these programs to perform a geometry optimization. In QCFractal, we call a geometry optimization a `procedure`, where `procedure` is a generic term for a higher level operation that will run multiple individual quantum chemistry energy, gradient, or Hessian evaluations. Other `procedure` examples are finite-difference computations, n-body computations, and torsiondrives.\n", - "\n", - "We provide a JSON-like input to the [client.add_procedure()](http://docs.qcarchive.molssi.org/projects/qcportal/en/latest/client-api.html?highlight=add_procedure#qcportal.FractalClient.add_procedure)\n", - " command to specify the method, basis, and program to be used. \n", - "The `qc_spec` field is used in all procedures to determine the underlying quantum chemistry method behind the individual procedure.\n", - "In this way, we can use any program or method that returns a energy or gradient quantity to run our geometry optimization!\n", - "(See also [add_compute()](http://docs.qcarchive.molssi.org/projects/qcportal/en/latest/client-api.html?highlight=add_procedure#qcportal.FractalClient.add_compute).)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ComputeResponse(nsubmitted=1 nexisting=0)\n", - "['1']\n" - ] - } - ], - "source": [ - "spec = {\n", - " \"keywords\": None,\n", - " \"qc_spec\": {\n", - " \"driver\": \"gradient\",\n", - " \"method\": \"b3lyp\",\n", - " \"basis\": \"6-31g\",\n", - " \"program\": \"psi4\"\n", - " },\n", - "}\n", - "\n", - "# Ask the server to compute a new computation\n", - "r = client.add_procedure(\"optimization\", \"geometric\", spec, [mol])\n", - "print(r)\n", - "print(r.ids)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can see that we submitted a single task to be evaluated and the server has not seen this particular procedure before. \n", - "The `ids` field returns the unique `id` of the procedure. Different procedures will always have a unique `id`, while identical procedures will always return the same `id`. \n", - "We can submit the same procedure again to see this effect:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ComputeResponse(nsubmitted=1 nexisting=0)\n", - "['1']\n" - ] - } - ], - "source": [ - "r2 = client.add_procedure(\"optimization\", \"geometric\", spec, [mol])\n", - "print(r)\n", - "print(r.ids)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Querying Procedures\n", - "\n", - "Once a task is submitted, it will be placed in the compute queue and evaluated. In this particular case the [FractalSnowflakeHandler](http://docs.qcarchive.molssi.org/projects/qcfractal/en/latest/api/qcfractal.FractalSnowflakeHandler.html?highlight=FractalSnowflakeHandler) uses your local hardware to evaluate these jobs. We recommend avoiding large tasks!\n", - "\n", - "In general, the server can handle anywhere between laptop-scale resources to many hundreds of thousands of concurrent cores at many physical locations. The amount of resources to connect is up to you and the amount of compute that you require.\n", - "\n", - "Since we did submit a very small job it is likely complete by now. Let us query this procedure from the server using its `id` like so:" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "proc = client.query_procedures(id=r.ids)[0]\n", - "proc" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This [OptimizationRecord](http://docs.qcarchive.molssi.org/projects/qcportal/en/latest/record-api.html?highlight=optimizationrecord#qcportal.models.OptimizationRecord) object has many different fields attached to it so that all quantities involved in the computation can be explored. For this example, let us pull the final molecule (optimized structure) and inspect the physical dimensions.\n", - "\n", - "Note: if the status does not say `COMPLETE`, these fields will not be available. Try querying the procedure again in a few seconds to see if the task completed in the background." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "final_mol = proc.get_final_molecule()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.844111236246719\n", - "108.30246679333517\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c9832fcaa6524780bc83513a2b22390e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "NGLWidget()" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "print(final_mol.measure([0, 1]))\n", - "print(final_mol.measure([1, 0, 2]))\n", - "final_mol" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This water molecule has bond length and angle dimensions much closer to expected values. We can also plot the optimization history to see how each step in the geometry optimization affected the results. Though the chart is not too impressive for this simple molecule, it is hopefully illuminating and is available for any geometry optimization ever completed." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - " \n", - " " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.plotly.v1+json": { - "config": { - "linkText": "Export to plot.ly", - "plotlyServerURL": "https://plot.ly", - "showLink": false - }, - "data": [ - { - "mode": "lines+markers", - "type": "scatter", - "x": [ - 1, - 2, - 3, - 4, - 5, - 6 - ], - "y": [ - 9.189, - 0.52, - 0.124, - 0.001, - 0, - 0 - ] - } - ], - "layout": { - "template": { - "data": { - "bar": [ - { - "error_x": { - "color": "#2a3f5f" - }, - "error_y": { - "color": "#2a3f5f" - }, - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - } - }, - "type": "bar" - } - ], - "barpolar": [ - { - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - } - }, - "type": "barpolar" - } - ], - "carpet": [ - { - "aaxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "baxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "type": "carpet" - } - ], - "choropleth": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "choropleth" - } - ], - "contour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "contour" - } - ], - "contourcarpet": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "contourcarpet" - } - ], - "heatmap": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmap" - } - ], - "heatmapgl": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmapgl" - } - ], - "histogram": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "histogram" - } - ], - "histogram2d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2d" - } - ], - "histogram2dcontour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2dcontour" - } - ], - "mesh3d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "mesh3d" - } - ], - "parcoords": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "parcoords" - } - ], - "pie": [ - { - "automargin": true, - "type": "pie" - } - ], - "scatter": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter" - } - ], - "scatter3d": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter3d" - } - ], - "scattercarpet": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattercarpet" - } - ], - "scattergeo": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergeo" - } - ], - "scattergl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergl" - } - ], - "scattermapbox": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattermapbox" - } - ], - "scatterpolar": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolar" - } - ], - "scatterpolargl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolargl" - } - ], - "scatterternary": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterternary" - } - ], - "surface": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "surface" - } - ], - "table": [ - { - "cells": { - "fill": { - "color": "#EBF0F8" - }, - "line": { - "color": "white" - } - }, - "header": { - "fill": { - "color": "#C8D4E3" - }, - "line": { - "color": "white" - } - }, - "type": "table" - } - ] - }, - "layout": { - "annotationdefaults": { - "arrowcolor": "#2a3f5f", - "arrowhead": 0, - "arrowwidth": 1 - }, - "coloraxis": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "colorscale": { - "diverging": [ - [ - 0, - "#8e0152" - ], - [ - 0.1, - "#c51b7d" - ], - [ - 0.2, - "#de77ae" - ], - [ - 0.3, - "#f1b6da" - ], - [ - 0.4, - "#fde0ef" - ], - [ - 0.5, - "#f7f7f7" - ], - [ - 0.6, - "#e6f5d0" - ], - [ - 0.7, - "#b8e186" - ], - [ - 0.8, - "#7fbc41" - ], - [ - 0.9, - "#4d9221" - ], - [ - 1, - "#276419" - ] - ], - "sequential": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "sequentialminus": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ] - }, - "colorway": [ - "#636efa", - "#EF553B", - "#00cc96", - "#ab63fa", - "#FFA15A", - "#19d3f3", - "#FF6692", - "#B6E880", - "#FF97FF", - "#FECB52" - ], - "font": { - "color": "#2a3f5f" - }, - "geo": { - "bgcolor": "white", - "lakecolor": "white", - "landcolor": "#E5ECF6", - "showlakes": true, - "showland": true, - "subunitcolor": "white" - }, - "hoverlabel": { - "align": "left" - }, - "hovermode": "closest", - "mapbox": { - "style": "light" - }, - "paper_bgcolor": "white", - "plot_bgcolor": "#E5ECF6", - "polar": { - "angularaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "radialaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "scene": { - "xaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "yaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "zaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - } - }, - "shapedefaults": { - "line": { - "color": "#2a3f5f" - } - }, - "ternary": { - "aaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "baxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "caxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "title": { - "x": 0.05 - }, - "xaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - }, - "yaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - } - } - }, - "title": { - "text": "Geometry Optimization" - }, - "xaxis": { - "range": [ - 1, - 6 - ], - "title": { - "text": "Optimization Step" - } - }, - "yaxis": { - "title": { - "text": "Relative Energy [kcal/mol]" - }, - "zeroline": true - } - } - }, - "text/html": [ - "
\n", - " \n", - " \n", - "
\n", - " \n", - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "proc.show_history()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Collections\n", - "\n", - "Submitting individual procedures or single quantum chemistry tasks is not typically done as it becomes hard to track individual tasks. To help resolve this, ``Collections`` are different ways of organizing standard computations so that many tasks can be referenced in a more human-friendly way. In this particular case, we will be exploring an intermolecular potential dataset.\n", - "\n", - "To begin, we will create a new dataset and add a few intermolecular interactions to it." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "ds = ptl.collections.ReactionDataset(\"My IE Dataset\", ds_type=\"ie\", client=client, default_program=\"psi4\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can construct a water dimer that has fragments used in the intermolecular computation with the `--` divider. A single water molecule with ghost atoms can be extracted like so:" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a83818421c2348d0bd26120cec0fc02a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "NGLWidget()" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "water_dimer = ptl.Molecule.from_data(\"\"\"\n", - "O 0.000000 0.000000 0.000000\n", - "H 0.758602 0.000000 0.504284\n", - "H 0.260455 0.000000 -0.872893\n", - "--\n", - "O 3.000000 0.500000 0.000000\n", - "H 3.758602 0.500000 0.504284\n", - "H 3.260455 0.500000 -0.872893\n", - "\"\"\")\n", - "\n", - "water_dimer.get_fragment(0, 1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Many molecular entries can be added to this dataset where each is entry is a given intermolecular complex that is given a unique name. In addition, the `add_ie_rxn` method to can automatically fragment molecules. " - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ReactionEntry(attributes={}, reaction_results={'default': {}}, name='helium dimer', stoichiometry={'default1': {'b3855c64e9f61158f5e449e2df7b79bf1fa599d7': 2.0}, 'cp1': {'e925ae0ef797c65c359e9c8029f0342df495d116': 2.0}, 'default': {'a0d757c65af76f309b2685f31f63b3da781d0ba7': 1.0}, 'cp': {'a0d757c65af76f309b2685f31f63b3da781d0ba7': 1.0}}, extras={})" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds.add_ie_rxn(\"water dimer\", water_dimer)\n", - "ds.add_ie_rxn(\"helium dimer\", \"\"\"\n", - "He 0 0 -3\n", - "--\n", - "He 0 0 3\n", - "\"\"\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Once the Collection is created it can be saved to the server so that it can always be retrived at a future date" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'1'" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds.save()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The client can list all Collections currently on the server and retrive collections to be manipulated:" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
tagline
collectionname
ReactionDatasetMy IE DatasetNone
\n", - "
" - ], - "text/plain": [ - " tagline\n", - "collection name \n", - "ReactionDataset My IE Dataset None" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "client.list_collections()" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds = client.get_collection(\"ReactionDataset\", \"My IE Dataset\")\n", - "ds" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Computing with collections\n", - "\n", - "Computational methods can be applied to all of the reactions in the dataset with just a few simple lines:" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds.compute(\"B3LYP-D3\", \"def2-SVP\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "By default this collection evaluates the non-counterpoise corrected interaction energy which typically requires three computations per entry (the complex and each monomer). In this case we compute the B3LYP and -D3 additive correction separately, nominally 12 total computations. However the collection is smart enough to understand that each Helium monomer is identical and does not need to be computed twice, reducing the total number of computations to 10 as shown here. We can continue to compute additional methods. Again, this is being evaluated on your computer! Be careful of the compute requirements." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds.compute(\"PBE-D3\", \"def2-SVP\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A list of all methods that have been computed for this dataset can also be shown:" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
stoichiometryname
nativedriverprogrammethodbasiskeywords
Trueenergypsi4b3lypdef2-svpNonedefaultB3LYP/def2-svp
b3lyp-d3def2-svpNonedefaultB3LYP-D3/def2-svp
pbedef2-svpNonedefaultPBE/def2-svp
pbe-d3def2-svpNonedefaultPBE-D3/def2-svp
\n", - "
" - ], - "text/plain": [ - " stoichiometry \\\n", - "native driver program method basis keywords \n", - "True energy psi4 b3lyp def2-svp None default \n", - " b3lyp-d3 def2-svp None default \n", - " pbe def2-svp None default \n", - " pbe-d3 def2-svp None default \n", - "\n", - " name \n", - "native driver program method basis keywords \n", - "True energy psi4 b3lyp def2-svp None B3LYP/def2-svp \n", - " b3lyp-d3 def2-svp None B3LYP-D3/def2-svp \n", - " pbe def2-svp None PBE/def2-svp \n", - " pbe-d3 def2-svp None PBE-D3/def2-svp " - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds.list_values()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The above only shows what has been computed and does not pull this data from the server to your computer. To do so, the `get_history` command can be used:" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DataFrame units: kcal / mol\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
PBE/def2-svpB3LYP/def2-svpPBE-D3/def2-svpB3LYP-D3/def2-svp
water dimer-5.11552-4.75187-5.63188-5.57767
helium dimer0.0006841150.0006747480.0002072080.00017274
\n", - "
" - ], - "text/plain": [ - " PBE/def2-svp B3LYP/def2-svp PBE-D3/def2-svp B3LYP-D3/def2-svp\n", - "water dimer -5.11552 -4.75187 -5.63188 -5.57767\n", - "helium dimer 0.000684115 0.000674748 0.000207208 0.00017274" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "print(f\"DataFrame units: {ds.units}\")\n", - "ds.get_values()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can also visualize results and more!" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - " \n", - " " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.plotly.v1+json": { - "config": { - "linkText": "Export to plot.ly", - "plotlyServerURL": "https://plot.ly", - "showLink": false - }, - "data": [ - { - "box": { - "visible": true - }, - "name": "PBE-D3/def2-svp", - "type": "violin", - "y": [ - 0.0004675397066600294, - 0.8800098319745189 - ] - }, - { - "box": { - "visible": true - }, - "name": "B3LYP-D3/def2-svp", - "type": "violin", - "y": [ - 0.0005020075787577952, - 0.8258024674929709 - ] - } - ], - "layout": { - "template": { - "data": { - "bar": [ - { - "error_x": { - "color": "#2a3f5f" - }, - "error_y": { - "color": "#2a3f5f" - }, - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - } - }, - "type": "bar" - } - ], - "barpolar": [ - { - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - } - }, - "type": "barpolar" - } - ], - "carpet": [ - { - "aaxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "baxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "type": "carpet" - } - ], - "choropleth": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "choropleth" - } - ], - "contour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "contour" - } - ], - "contourcarpet": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "contourcarpet" - } - ], - "heatmap": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmap" - } - ], - "heatmapgl": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmapgl" - } - ], - "histogram": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "histogram" - } - ], - "histogram2d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2d" - } - ], - "histogram2dcontour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2dcontour" - } - ], - "mesh3d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "mesh3d" - } - ], - "parcoords": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "parcoords" - } - ], - "pie": [ - { - "automargin": true, - "type": "pie" - } - ], - "scatter": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter" - } - ], - "scatter3d": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter3d" - } - ], - "scattercarpet": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattercarpet" - } - ], - "scattergeo": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergeo" - } - ], - "scattergl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergl" - } - ], - "scattermapbox": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattermapbox" - } - ], - "scatterpolar": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolar" - } - ], - "scatterpolargl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolargl" - } - ], - "scatterternary": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterternary" - } - ], - "surface": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "surface" - } - ], - "table": [ - { - "cells": { - "fill": { - "color": "#EBF0F8" - }, - "line": { - "color": "white" - } - }, - "header": { - "fill": { - "color": "#C8D4E3" - }, - "line": { - "color": "white" - } - }, - "type": "table" - } - ] - }, - "layout": { - "annotationdefaults": { - "arrowcolor": "#2a3f5f", - "arrowhead": 0, - "arrowwidth": 1 - }, - "coloraxis": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "colorscale": { - "diverging": [ - [ - 0, - "#8e0152" - ], - [ - 0.1, - "#c51b7d" - ], - [ - 0.2, - "#de77ae" - ], - [ - 0.3, - "#f1b6da" - ], - [ - 0.4, - "#fde0ef" - ], - [ - 0.5, - "#f7f7f7" - ], - [ - 0.6, - "#e6f5d0" - ], - [ - 0.7, - "#b8e186" - ], - [ - 0.8, - "#7fbc41" - ], - [ - 0.9, - "#4d9221" - ], - [ - 1, - "#276419" - ] - ], - "sequential": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "sequentialminus": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ] - }, - "colorway": [ - "#636efa", - "#EF553B", - "#00cc96", - "#ab63fa", - "#FFA15A", - "#19d3f3", - "#FF6692", - "#B6E880", - "#FF97FF", - "#FECB52" - ], - "font": { - "color": "#2a3f5f" - }, - "geo": { - "bgcolor": "white", - "lakecolor": "white", - "landcolor": "#E5ECF6", - "showlakes": true, - "showland": true, - "subunitcolor": "white" - }, - "hoverlabel": { - "align": "left" - }, - "hovermode": "closest", - "mapbox": { - "style": "light" - }, - "paper_bgcolor": "white", - "plot_bgcolor": "#E5ECF6", - "polar": { - "angularaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "radialaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "scene": { - "xaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "yaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "zaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - } - }, - "shapedefaults": { - "line": { - "color": "#2a3f5f" - } - }, - "ternary": { - "aaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "baxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "caxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "title": { - "x": 0.05 - }, - "xaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - }, - "yaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - } - } - }, - "title": { - "text": "My IE Dataset Dataset Statistics" - }, - "yaxis": { - "title": { - "text": "UE [kcal / mol]" - } - } - } - }, - "text/html": [ - "
\n", - " \n", - " \n", - "
\n", - " \n", - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ds.visualize([\"B3LYP-D3\", \"PBE-D3\"], \"def2-SVP\", bench=\"B3LYP/def2-svp\", kind=\"violin\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This is only the very beginning of what you can do with QCFractal! Explore the documentation to learn more capabilities.\n", - "In particular, see the [next section](setup_quickstart.rst) for a quickstart guide on how to set up QCFractal in production.\n", - "\n", - "If you like the project, consider starring us on [GitHub](https://github.com/MolSSI/QCFractal). If you have any questions, join our [Slack](https://join.slack.com/t/qcdb/shared_invite/enQtNDIzNTQ2OTExODk0LWM3OTgxN2ExYTlkMTlkZjA0OTExZDlmNGRlY2M4NWJlNDlkZGQyYWUxOTJmMzc3M2VlYzZjMjgxMDRkYzFmOTE) channel." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.5" - }, - "pycharm": { - "stem_cell": { - "cell_type": "raw", - "source": [], - "metadata": { - "collapsed": false - } - } - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "015cb0544ff44c68b1c7ddb47bdb46ab": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_9d75834c00a94d828e7f1809d83aaa01", - "max" - ], - "target": [ - "IPY_MODEL_db6345639c3b4abc8bc70b85913b2a6c", - "max_frame" - ] - } - }, - "05fad9d4c5e4441a909dd93ff265a3e2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "06ea71ba35874ec382c84cb58fde86e9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_7a7355e463a0496693c118c7f18145b9", - "max" - ], - "target": [ - "IPY_MODEL_5a86b98162284e76aa45a9e5f2c3c184", - "max_frame" - ] - } - }, - "0d9dcfaed4e24f9389a2ed6c1899ba07": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_1466725088f64032bf963274418fe137", - "max" - ], - "target": [ - "IPY_MODEL_24e3413db2f543839da5f6836dc0bd35", - "max_frame" - ] - } - }, - "0e9fdcaab7d94e43ae84fa7a5a05861d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "125ee3af34134816bf47782b423e19db": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_db8aca2c94734431ac49febea58c3955", - "max" - ], - "target": [ - "IPY_MODEL_c9832fcaa6524780bc83513a2b22390e", - "max_frame" - ] - } - }, - "129386fca991485e9033f24e15571506": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "1466725088f64032bf963274418fe137": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "IntSliderModel", - "state": { - "layout": "IPY_MODEL_b965e3b6c0e34eb6bbf1abb64139938b", - "max": 0, - "style": "IPY_MODEL_aef27dece7254fee80b2ec1e83e85564" - } - }, - "1964a5142c1544d2bb049800cd64be8e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "PlayModel", - "state": { - "layout": "IPY_MODEL_cc704e3ffa7a483f80e9ecbbb1136027", - "max": 0, - "style": "IPY_MODEL_05fad9d4c5e4441a909dd93ff265a3e2" - } - }, - "1b15c8c89d00426997fb4d5b1c6cde42": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "1c9cecb68e324532ae8ac2d035a058db": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ImageModel", - "state": { - "layout": "IPY_MODEL_129386fca991485e9033f24e15571506", - "width": "900.0" - } - }, - "1d68b30554554033b15366756048c5fe": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "20554a9ff7dd4b50b5d0d6fe1b44d28a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "24e3413db2f543839da5f6836dc0bd35": { - "model_module": "nglview-js-widgets", - "model_module_version": "2.7.1", - "model_name": "NGLModel", - "state": { - "_camera_orientation": [ - 0.3587346567537857, - -0.461614837404882, - -11.620883709617265, - 0, - -0.037122892737446296, - 11.626306031114774, - -0.4629762048047823, - 0, - 11.62998918062244, - 0.05134994905839903, - 0.3569759737757603, - 0, - 0, - -0.4877000264823437, - -0.4877000264823437, - 1 - ], - "_camera_str": "orthographic", - "_gui_theme": null, - "_ibtn_fullscreen": "IPY_MODEL_edeebd6d76584ae0980f86d8b71d7b0b", - "_igui": null, - "_iplayer": "IPY_MODEL_d9ccad4633d94100a476ea61783953b6", - "_ngl_color_dict": {}, - "_ngl_coordinate_resource": {}, - "_ngl_full_stage_parameters": { - "ambientColor": 14540253, - "ambientIntensity": 0.2, - "backgroundColor": "white", - "cameraEyeSep": 0.3, - "cameraFov": 40, - "cameraType": "perspective", - "clipDist": 10, - "clipFar": 100, - "clipNear": 0, - "fogFar": 100, - "fogNear": 50, - "hoverTimeout": 0, - "impostor": true, - "lightColor": 14540253, - "lightIntensity": 1, - "mousePreset": "default", - "panSpeed": 1, - "quality": "medium", - "rotateSpeed": 2, - "sampleLevel": 0, - "tooltip": true, - "workerDefault": true, - "zoomSpeed": 1.2 - }, - "_ngl_msg_archive": [ - { - "args": [ - { - "binary": false, - "data": "\nQCElemental\n\n 3 2 0 0 0 0 0 0 0 0 0\n 0.0000 0.0836 0.0836 O 0 0 0 0 0 0 0 0\n 0.0000 -0.0716 1.0470 H 0 0 0 0 0 0 0 0\n 0.0000 1.0470 -0.0716 H 0 0 0 0 0 0 0 0\n 1 2 1 0 0 0 0\n 1 3 1 0 0 0 0\n", - "type": "blob" - } - ], - "kwargs": { - "defaultRepresentation": true, - "ext": "sdf" - }, - "methodName": "loadFile", - "reconstruc_color_scheme": false, - "target": "Stage", - "type": "call_method" - } - ], - "_ngl_original_stage_parameters": { - "ambientColor": 14540253, - "ambientIntensity": 0.2, - "backgroundColor": "white", - "cameraEyeSep": 0.3, - "cameraFov": 40, - "cameraType": "perspective", - "clipDist": 10, - "clipFar": 100, - "clipNear": 0, - "fogFar": 100, - "fogNear": 50, - "hoverTimeout": 0, - "impostor": true, - "lightColor": 14540253, - "lightIntensity": 1, - "mousePreset": "default", - "panSpeed": 1, - "quality": "medium", - "rotateSpeed": 2, - "sampleLevel": 0, - "tooltip": true, - "workerDefault": true, - "zoomSpeed": 1.2 - }, - "_ngl_repr_dict": { - "0": { - "0": { - "params": { - "aspectRatio": 1.5, - "assembly": "default", - "bondScale": 0.3, - "bondSpacing": 0.75, - "clipCenter": { - "x": 0, - "y": 0, - "z": 0 - }, - "clipNear": 0, - "clipRadius": 0, - "colorMode": "hcl", - "colorReverse": false, - "colorScale": "", - "colorScheme": "element", - "colorValue": 9474192, - "cylinderOnly": false, - "defaultAssembly": "", - "depthWrite": true, - "diffuse": 16777215, - "diffuseInterior": false, - "disableImpostor": false, - "disablePicking": false, - "flatShaded": false, - "interiorColor": 2236962, - "interiorDarkening": 0, - "lazy": false, - "lineOnly": false, - "linewidth": 2, - "matrix": { - "elements": [ - 1, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 1 - ] - }, - "metalness": 0, - "multipleBond": "off", - "opacity": 1, - "openEnded": true, - "quality": "high", - "radialSegments": 20, - "radiusData": {}, - "radiusScale": 2, - "radiusSize": 0.15, - "radiusType": "size", - "roughness": 0.4, - "sele": "", - "side": "double", - "sphereDetail": 2, - "useInteriorColor": true, - "visible": true, - "wireframe": false - }, - "type": "ball+stick" - } - } - }, - "_ngl_serialize": false, - "_ngl_version": "2.0.0-dev.36", - "_ngl_view_id": [ - "EE7E02FF-994A-4D80-92F8-0E2C0DB034A8" - ], - "_player_dict": {}, - "_scene_position": {}, - "_scene_rotation": {}, - "_synced_model_ids": [], - "_synced_repr_model_ids": [], - "_view_height": "", - "_view_width": "", - "background": "white", - "frame": 0, - "gui_style": null, - "layout": "IPY_MODEL_55d4b128490943d2b3cc95d8b89b0e84", - "max_frame": 0, - "n_components": 1, - "picked": {} - } - }, - "2703225239ca43818fb3f9ac1c4c332b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_e095a6b9fbde4238892a8d4f0beffa5a", - "IPY_MODEL_7a7355e463a0496693c118c7f18145b9" - ], - "layout": "IPY_MODEL_47f1749a821645f1b1379092555325a1" - } - }, - "2733fc8e14884ec8add7cb17a36cdbe4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_e626666f622f43599f6570cd450182ff", - "max" - ], - "target": [ - "IPY_MODEL_c9832fcaa6524780bc83513a2b22390e", - "max_frame" - ] - } - }, - "2b9eaffd6db342e7af569a4aebccf3e5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_9f36f35dd0cd4c50b87b40313eb5220e", - "value" - ], - "target": [ - "IPY_MODEL_353f9341148249cea1862a06367a02c4", - "value" - ] - } - }, - "2c778813b97e4d03bf5922d64794c09e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "2fda95bb194a4d8c90fa602ef57b5b6d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "30b9574c1d234fc29fb4e3fa582b17fb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "34b6185a0a9149d9829549d0f6ac30ae": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_db8aca2c94734431ac49febea58c3955", - "IPY_MODEL_e626666f622f43599f6570cd450182ff" - ], - "layout": "IPY_MODEL_d50680e0adf047f4bcdbc1adc0bede5d" - } - }, - "353f9341148249cea1862a06367a02c4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "IntSliderModel", - "state": { - "layout": "IPY_MODEL_b748843035524e1dae5d92778a1e692d", - "max": 0, - "style": "IPY_MODEL_5fda4d0a735f46cb96c7e230135dcb9d" - } - }, - "36b12047df4f45b2b06b6f491c717544": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ImageModel", - "state": { - "layout": "IPY_MODEL_8122b1e63dfa4732acfb9831a3b26bc3", - "width": "900.0" - } - }, - "36eab15533df4cbfa949048607b12e2d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "39b0b2646f444c1baa98d12487a530e7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "IntSliderModel", - "state": { - "layout": "IPY_MODEL_0e9fdcaab7d94e43ae84fa7a5a05861d", - "max": 0, - "style": "IPY_MODEL_36eab15533df4cbfa949048607b12e2d" - } - }, - "3c28fcb5fb904eb198b04770f8ed7680": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "3d32337d17534d5781a20a63faf8a2c6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "3d91629d68914798ac2d51e9dcaad209": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "40a32baf36994b96bb268eb27396d929": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_db8aca2c94734431ac49febea58c3955", - "value" - ], - "target": [ - "IPY_MODEL_e626666f622f43599f6570cd450182ff", - "value" - ] - } - }, - "46b29a5714254a8a9ef9275508f392d9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_9f36f35dd0cd4c50b87b40313eb5220e", - "max" - ], - "target": [ - "IPY_MODEL_a84cd78b6b1c49e394d064b837e455cc", - "max_frame" - ] - } - }, - "47f1749a821645f1b1379092555325a1": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "48f7f4ee395d45798f1e8364a3b24a5f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_a0d24f140921447f9f036b3add9136f4", - "value" - ], - "target": [ - "IPY_MODEL_a83818421c2348d0bd26120cec0fc02a", - "frame" - ] - } - }, - "4b6bdda8d92340ceb87c0cc321f090d9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "icon": "compress", - "layout": "IPY_MODEL_4f73f9d2961c4e08b9ce21bcee2bdc40", - "style": "IPY_MODEL_7aea39e8426349c78db3e6cffd705234" - } - }, - "4f73f9d2961c4e08b9ce21bcee2bdc40": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "34px" - } - }, - "501757b1f6e4410c8dd79f7220ee1c3e": { - "model_module": "nglview-js-widgets", - "model_module_version": "2.7.1", - "model_name": "ColormakerRegistryModel", - "state": { - "_msg_ar": [], - "_msg_q": [], - "_ready": true, - "layout": "IPY_MODEL_3c28fcb5fb904eb198b04770f8ed7680" - } - }, - "52584e0ee2a44853ad0a6dbf4c9c5375": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "5387cc68c3624e59b090285931f76840": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "55d4b128490943d2b3cc95d8b89b0e84": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "56bd1113bd6344c0a60fe2e03d34c47c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ImageModel", - "state": { - "layout": "IPY_MODEL_2c778813b97e4d03bf5922d64794c09e", - "width": "900.0" - } - }, - "57e6862900f1453bae6f4a7511cffc32": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ImageModel", - "state": { - "layout": "IPY_MODEL_781d4e55ba144554bd7c95b124d43de7", - "width": "900.0" - } - }, - "5a86b98162284e76aa45a9e5f2c3c184": { - "model_module": "nglview-js-widgets", - "model_module_version": "2.7.1", - "model_name": "NGLModel", - "state": { - "_camera_orientation": [ - -8.030213412475353, - -0.5629232793882898, - -8.279182945268866, - 0, - -0.1053706430326701, - 11.526945540958385, - -0.6815451804346104, - 0, - 8.297629172679084, - -0.39840204179885613, - -8.021016533794372, - 0, - 0, - -0.52920001745224, - -0.52920001745224, - 1 - ], - "_camera_str": "orthographic", - "_gui_theme": null, - "_ibtn_fullscreen": "IPY_MODEL_a05decff2bf446dd8637d3b5ab52ef17", - "_igui": null, - "_iplayer": "IPY_MODEL_2703225239ca43818fb3f9ac1c4c332b", - "_ngl_color_dict": {}, - "_ngl_coordinate_resource": {}, - "_ngl_full_stage_parameters": { - "ambientColor": 14540253, - "ambientIntensity": 0.2, - "backgroundColor": "white", - "cameraEyeSep": 0.3, - "cameraFov": 40, - "cameraType": "perspective", - "clipDist": 10, - "clipFar": 100, - "clipNear": 0, - "fogFar": 100, - "fogNear": 50, - "hoverTimeout": 0, - "impostor": true, - "lightColor": 14540253, - "lightIntensity": 1, - "mousePreset": "default", - "panSpeed": 1, - "quality": "medium", - "rotateSpeed": 2, - "sampleLevel": 0, - "tooltip": true, - "workerDefault": true, - "zoomSpeed": 1.2 - }, - "_ngl_msg_archive": [ - { - "args": [ - { - "binary": false, - "data": "\nQCElemental\n\n 3 2 0 0 0 0 0 0 0 0 0\n 0.0000 0.0000 0.0000 O 0 0 0 0 0 0 0 0\n 0.0000 0.0000 1.0584 H 0 0 0 0 0 0 0 0\n 0.0000 1.0584 0.0000 H 0 0 0 0 0 0 0 0\n 1 2 1 0 0 0 0\n 1 3 1 0 0 0 0\n", - "type": "blob" - } - ], - "kwargs": { - "defaultRepresentation": true, - "ext": "sdf" - }, - "methodName": "loadFile", - "reconstruc_color_scheme": false, - "target": "Stage", - "type": "call_method" - } - ], - "_ngl_original_stage_parameters": { - "ambientColor": 14540253, - "ambientIntensity": 0.2, - "backgroundColor": "white", - "cameraEyeSep": 0.3, - "cameraFov": 40, - "cameraType": "perspective", - "clipDist": 10, - "clipFar": 100, - "clipNear": 0, - "fogFar": 100, - "fogNear": 50, - "hoverTimeout": 0, - "impostor": true, - "lightColor": 14540253, - "lightIntensity": 1, - "mousePreset": "default", - "panSpeed": 1, - "quality": "medium", - "rotateSpeed": 2, - "sampleLevel": 0, - "tooltip": true, - "workerDefault": true, - "zoomSpeed": 1.2 - }, - "_ngl_repr_dict": { - "0": { - "0": { - "params": { - "aspectRatio": 1.5, - "assembly": "default", - "bondScale": 0.3, - "bondSpacing": 0.75, - "clipCenter": { - "x": 0, - "y": 0, - "z": 0 - }, - "clipNear": 0, - "clipRadius": 0, - "colorMode": "hcl", - "colorReverse": false, - "colorScale": "", - "colorScheme": "element", - "colorValue": 9474192, - "cylinderOnly": false, - "defaultAssembly": "", - "depthWrite": true, - "diffuse": 16777215, - "diffuseInterior": false, - "disableImpostor": false, - "disablePicking": false, - "flatShaded": false, - "interiorColor": 2236962, - "interiorDarkening": 0, - "lazy": false, - "lineOnly": false, - "linewidth": 2, - "matrix": { - "elements": [ - 1, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 1 - ] - }, - "metalness": 0, - "multipleBond": "off", - "opacity": 1, - "openEnded": true, - "quality": "high", - "radialSegments": 20, - "radiusData": {}, - "radiusScale": 2, - "radiusSize": 0.15, - "radiusType": "size", - "roughness": 0.4, - "sele": "", - "side": "double", - "sphereDetail": 2, - "useInteriorColor": true, - "visible": true, - "wireframe": false - }, - "type": "ball+stick" - } - } - }, - "_ngl_serialize": false, - "_ngl_version": "2.0.0-dev.36", - "_ngl_view_id": [ - "1BCCAB2E-C6AC-4874-809F-E28D9ECFEEF5" - ], - "_player_dict": {}, - "_scene_position": {}, - "_scene_rotation": {}, - "_synced_model_ids": [], - "_synced_repr_model_ids": [], - "_view_height": "", - "_view_width": "", - "background": "white", - "frame": 0, - "gui_style": null, - "layout": "IPY_MODEL_b12b5c74866040b8abb9d0410ff300a4", - "max_frame": 0, - "n_components": 1, - "picked": {} - } - }, - "5fda4d0a735f46cb96c7e230135dcb9d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "62f38b9bbc284ae3a45f2d01321555c7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "63b16e9880244d6ca5b78f7684b830cc": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_1964a5142c1544d2bb049800cd64be8e", - "value" - ], - "target": [ - "IPY_MODEL_1466725088f64032bf963274418fe137", - "value" - ] - } - }, - "63daa86a3ec44c15b0391ee3c7bf2c06": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_9d75834c00a94d828e7f1809d83aaa01", - "value" - ], - "target": [ - "IPY_MODEL_b1cb0e904ed042b2909a775de4cdceed", - "value" - ] - } - }, - "69620f0cf57748cbb4d698cd984aa939": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_9d75834c00a94d828e7f1809d83aaa01", - "IPY_MODEL_b1cb0e904ed042b2909a775de4cdceed" - ], - "layout": "IPY_MODEL_30b9574c1d234fc29fb4e3fa582b17fb" - } - }, - "6c374326197e43efb60ba57531399d2d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "34px" - } - }, - "6f416140a41a46d483ad84511d75cd7f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "702090757d5240a280b56855dc21f1a5": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_a0d24f140921447f9f036b3add9136f4", - "max" - ], - "target": [ - "IPY_MODEL_a83818421c2348d0bd26120cec0fc02a", - "max_frame" - ] - } - }, - "70bc6342036f47c48362a8e27e10dd08": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "icon": "compress", - "layout": "IPY_MODEL_886bafc267e4476cb691679ab30e7e8f", - "style": "IPY_MODEL_a7a59a739a2e48ddb8d1d61ba9fbba55" - } - }, - "781d4e55ba144554bd7c95b124d43de7": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "7a7355e463a0496693c118c7f18145b9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "IntSliderModel", - "state": { - "layout": "IPY_MODEL_e22dfa6992a7463386b3b5c0f66410f4", - "max": 0, - "style": "IPY_MODEL_20554a9ff7dd4b50b5d0d6fe1b44d28a" - } - }, - "7aea39e8426349c78db3e6cffd705234": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonStyleModel", - "state": {} - }, - "7e454d2896b040febce86a5c2825cd7d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_e095a6b9fbde4238892a8d4f0beffa5a", - "value" - ], - "target": [ - "IPY_MODEL_7a7355e463a0496693c118c7f18145b9", - "value" - ] - } - }, - "8122b1e63dfa4732acfb9831a3b26bc3": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "83a2bfa69cae401a94606948d8284415": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_e095a6b9fbde4238892a8d4f0beffa5a", - "max" - ], - "target": [ - "IPY_MODEL_5a86b98162284e76aa45a9e5f2c3c184", - "max_frame" - ] - } - }, - "843a400e5d7149e48919b76d231c2a83": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonStyleModel", - "state": {} - }, - "84f719fa4dc549b9a0bd1b4d1aa3b7e3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ImageModel", - "state": { - "layout": "IPY_MODEL_931bbbd2373f4dca844e98a679f9f2eb", - "width": "900.0" - } - }, - "86d241b733fa444689f3e70bc28c532c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonStyleModel", - "state": {} - }, - "886bafc267e4476cb691679ab30e7e8f": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "34px" - } - }, - "8d3ee5bb32cd428c983b30bf57a7744d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonStyleModel", - "state": {} - }, - "920d353a7a82436c89a4a271237f9c5c": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_e095a6b9fbde4238892a8d4f0beffa5a", - "value" - ], - "target": [ - "IPY_MODEL_5a86b98162284e76aa45a9e5f2c3c184", - "frame" - ] - } - }, - "931bbbd2373f4dca844e98a679f9f2eb": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "9901f9293f1f4f92899b206dbf4b8b9d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_353f9341148249cea1862a06367a02c4", - "max" - ], - "target": [ - "IPY_MODEL_a84cd78b6b1c49e394d064b837e455cc", - "max_frame" - ] - } - }, - "995fc564127741bc94385d6382f7be7a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "icon": "compress", - "layout": "IPY_MODEL_ca78176594414e46a0be8e1b13dc3174", - "style": "IPY_MODEL_86d241b733fa444689f3e70bc28c532c" - } - }, - "999c1009ac5e421f9ddcd3c432324daf": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "34px" - } - }, - "9d2e99f0d32d4e0fa83b07326e2dc79d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "9d75834c00a94d828e7f1809d83aaa01": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "PlayModel", - "state": { - "layout": "IPY_MODEL_1d68b30554554033b15366756048c5fe", - "max": 0, - "style": "IPY_MODEL_c0b5758822ba45dea0996a573423eaad" - } - }, - "9f36f35dd0cd4c50b87b40313eb5220e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "PlayModel", - "state": { - "layout": "IPY_MODEL_d8b037e6a6194cea9f06b2e1289eef4c", - "max": 0, - "style": "IPY_MODEL_3d91629d68914798ac2d51e9dcaad209" - } - }, - "9f91d5c8f76c4d4f9d83925a4c172198": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "a01dbc8e95b0425384ae15f886dc88ed": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "a05decff2bf446dd8637d3b5ab52ef17": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "icon": "compress", - "layout": "IPY_MODEL_999c1009ac5e421f9ddcd3c432324daf", - "style": "IPY_MODEL_843a400e5d7149e48919b76d231c2a83" - } - }, - "a0d24f140921447f9f036b3add9136f4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "PlayModel", - "state": { - "layout": "IPY_MODEL_add2162ac769490d96352bc8fa3dad17", - "max": 0, - "style": "IPY_MODEL_62f38b9bbc284ae3a45f2d01321555c7" - } - }, - "a1761c7f5b9648fda9c3eb974e7d6e24": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_1964a5142c1544d2bb049800cd64be8e", - "value" - ], - "target": [ - "IPY_MODEL_24e3413db2f543839da5f6836dc0bd35", - "frame" - ] - } - }, - "a19030ff2bd749f8b79a1f56cd6771db": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "a7a59a739a2e48ddb8d1d61ba9fbba55": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonStyleModel", - "state": {} - }, - "a83818421c2348d0bd26120cec0fc02a": { - "model_module": "nglview-js-widgets", - "model_module_version": "2.7.1", - "model_name": "NGLModel", - "state": { - "_camera_orientation": [ - 16.52960793035883, - 0, - 0, - 0, - 0, - 10.27496906111685, - -12.948086697441921, - 0, - 0, - 12.948086697441921, - 10.27496906111685, - 0, - -1.8792999982833862, - -0.25, - 0.1843000054359436, - 1 - ], - "_camera_str": "orthographic", - "_gui_theme": null, - "_ibtn_fullscreen": "IPY_MODEL_4b6bdda8d92340ceb87c0cc321f090d9", - "_igui": null, - "_iplayer": "IPY_MODEL_affc12bc36e2481ebdda98eda9398814", - "_ngl_color_dict": {}, - "_ngl_coordinate_resource": {}, - "_ngl_full_stage_parameters": { - "ambientColor": 14540253, - "ambientIntensity": 0.2, - "backgroundColor": "white", - "cameraEyeSep": 0.3, - "cameraFov": 40, - "cameraType": "perspective", - "clipDist": 10, - "clipFar": 100, - "clipNear": 0, - "fogFar": 100, - "fogNear": 50, - "hoverTimeout": 0, - "impostor": true, - "lightColor": 14540253, - "lightIntensity": 1, - "mousePreset": "default", - "panSpeed": 1, - "quality": "medium", - "rotateSpeed": 2, - "sampleLevel": 0, - "tooltip": true, - "workerDefault": true, - "zoomSpeed": 1.2 - }, - "_ngl_msg_archive": [ - { - "args": [ - { - "binary": false, - "data": "\nQCElemental\n\n 6 4 0 0 0 0 0 0 0 0 0\n 0.0000 0.0000 0.0000 O 0 0 0 0 0 0 0 0\n 0.7586 0.0000 0.5043 H 0 0 0 0 0 0 0 0\n 0.2605 0.0000 -0.8729 H 0 0 0 0 0 0 0 0\n 3.0000 0.5000 0.0000 Gh 0 0 0 0 0 0 0 0\n 3.7586 0.5000 0.5043 Gh 0 0 0 0 0 0 0 0\n 3.2605 0.5000 -0.8729 Gh 0 0 0 0 0 0 0 0\n 1 2 1 0 0 0 0\n 1 3 1 0 0 0 0\n 4 5 1 0 0 0 0\n 4 6 1 0 0 0 0\n", - "type": "blob" - } - ], - "kwargs": { - "defaultRepresentation": true, - "ext": "sdf" - }, - "methodName": "loadFile", - "reconstruc_color_scheme": false, - "target": "Stage", - "type": "call_method" - } - ], - "_ngl_original_stage_parameters": { - "ambientColor": 14540253, - "ambientIntensity": 0.2, - "backgroundColor": "white", - "cameraEyeSep": 0.3, - "cameraFov": 40, - "cameraType": "perspective", - "clipDist": 10, - "clipFar": 100, - "clipNear": 0, - "fogFar": 100, - "fogNear": 50, - "hoverTimeout": 0, - "impostor": true, - "lightColor": 14540253, - "lightIntensity": 1, - "mousePreset": "default", - "panSpeed": 1, - "quality": "medium", - "rotateSpeed": 2, - "sampleLevel": 0, - "tooltip": true, - "workerDefault": true, - "zoomSpeed": 1.2 - }, - "_ngl_repr_dict": { - "0": { - "0": { - "params": { - "aspectRatio": 1.5, - "assembly": "default", - "bondScale": 0.3, - "bondSpacing": 0.75, - "clipCenter": { - "x": 0, - "y": 0, - "z": 0 - }, - "clipNear": 0, - "clipRadius": 0, - "colorMode": "hcl", - "colorReverse": false, - "colorScale": "", - "colorScheme": "element", - "colorValue": 9474192, - "cylinderOnly": false, - "defaultAssembly": "", - "depthWrite": true, - "diffuse": 16777215, - "diffuseInterior": false, - "disableImpostor": false, - "disablePicking": false, - "flatShaded": false, - "interiorColor": 2236962, - "interiorDarkening": 0, - "lazy": false, - "lineOnly": false, - "linewidth": 2, - "matrix": { - "elements": [ - 1, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 1 - ] - }, - "metalness": 0, - "multipleBond": "off", - "opacity": 1, - "openEnded": true, - "quality": "high", - "radialSegments": 20, - "radiusData": {}, - "radiusScale": 2, - "radiusSize": 0.15, - "radiusType": "size", - "roughness": 0.4, - "sele": "", - "side": "double", - "sphereDetail": 2, - "useInteriorColor": true, - "visible": true, - "wireframe": false - }, - "type": "ball+stick" - } - } - }, - "_ngl_serialize": false, - "_ngl_version": "2.0.0-dev.36", - "_ngl_view_id": [ - "0EEE316B-5700-444C-9E2D-417737274180" - ], - "_player_dict": {}, - "_scene_position": {}, - "_scene_rotation": {}, - "_synced_model_ids": [], - "_synced_repr_model_ids": [], - "_view_height": "", - "_view_width": "", - "background": "white", - "frame": 0, - "gui_style": null, - "layout": "IPY_MODEL_b2b1882789c1462a9ac3de732491f028", - "max_frame": 0, - "n_components": 1, - "picked": {} - } - }, - "a84cd78b6b1c49e394d064b837e455cc": { - "model_module": "nglview-js-widgets", - "model_module_version": "2.7.1", - "model_name": "NGLModel", - "state": { - "_camera_orientation": [ - 16.52960793035883, - 0, - 0, - 0, - 0, - 0.8392823288179362, - -16.5082871159886, - 0, - 0, - 16.5082871159886, - 0.8392823288179362, - 0, - -1.8792999982833862, - -0.25, - 0.1843000054359436, - 1 - ], - "_camera_str": "orthographic", - "_gui_theme": null, - "_ibtn_fullscreen": "IPY_MODEL_995fc564127741bc94385d6382f7be7a", - "_igui": null, - "_iplayer": "IPY_MODEL_cccabfe168dd4ebe9b7fb0cc9eefa073", - "_ngl_color_dict": {}, - "_ngl_coordinate_resource": {}, - "_ngl_full_stage_parameters": { - "ambientColor": 14540253, - "ambientIntensity": 0.2, - "backgroundColor": "white", - "cameraEyeSep": 0.3, - "cameraFov": 40, - "cameraType": "perspective", - "clipDist": 10, - "clipFar": 100, - "clipNear": 0, - "fogFar": 100, - "fogNear": 50, - "hoverTimeout": 0, - "impostor": true, - "lightColor": 14540253, - "lightIntensity": 1, - "mousePreset": "default", - "panSpeed": 1, - "quality": "medium", - "rotateSpeed": 2, - "sampleLevel": 0, - "tooltip": true, - "workerDefault": true, - "zoomSpeed": 1.2 - }, - "_ngl_msg_archive": [ - { - "args": [ - { - "binary": false, - "data": "\nQCElemental\n\n 6 4 0 0 0 0 0 0 0 0 0\n 0.0000 0.0000 0.0000 O 0 0 0 0 0 0 0 0\n 0.7586 0.0000 0.5043 H 0 0 0 0 0 0 0 0\n 0.2605 0.0000 -0.8729 H 0 0 0 0 0 0 0 0\n 3.0000 0.5000 0.0000 Gh 0 0 0 0 0 0 0 0\n 3.7586 0.5000 0.5043 Gh 0 0 0 0 0 0 0 0\n 3.2605 0.5000 -0.8729 Gh 0 0 0 0 0 0 0 0\n 1 2 1 0 0 0 0\n 1 3 1 0 0 0 0\n 4 5 1 0 0 0 0\n 4 6 1 0 0 0 0\n", - "type": "blob" - } - ], - "kwargs": { - "defaultRepresentation": true, - "ext": "sdf" - }, - "methodName": "loadFile", - "reconstruc_color_scheme": false, - "target": "Stage", - "type": "call_method" - } - ], - "_ngl_original_stage_parameters": { - "ambientColor": 14540253, - "ambientIntensity": 0.2, - "backgroundColor": "white", - "cameraEyeSep": 0.3, - "cameraFov": 40, - "cameraType": "perspective", - "clipDist": 10, - "clipFar": 100, - "clipNear": 0, - "fogFar": 100, - "fogNear": 50, - "hoverTimeout": 0, - "impostor": true, - "lightColor": 14540253, - "lightIntensity": 1, - "mousePreset": "default", - "panSpeed": 1, - "quality": "medium", - "rotateSpeed": 2, - "sampleLevel": 0, - "tooltip": true, - "workerDefault": true, - "zoomSpeed": 1.2 - }, - "_ngl_repr_dict": { - "0": { - "0": { - "params": { - "aspectRatio": 1.5, - "assembly": "default", - "bondScale": 0.3, - "bondSpacing": 0.75, - "clipCenter": { - "x": 0, - "y": 0, - "z": 0 - }, - "clipNear": 0, - "clipRadius": 0, - "colorMode": "hcl", - "colorReverse": false, - "colorScale": "", - "colorScheme": "element", - "colorValue": 9474192, - "cylinderOnly": false, - "defaultAssembly": "", - "depthWrite": true, - "diffuse": 16777215, - "diffuseInterior": false, - "disableImpostor": false, - "disablePicking": false, - "flatShaded": false, - "interiorColor": 2236962, - "interiorDarkening": 0, - "lazy": false, - "lineOnly": false, - "linewidth": 2, - "matrix": { - "elements": [ - 1, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 1 - ] - }, - "metalness": 0, - "multipleBond": "off", - "opacity": 1, - "openEnded": true, - "quality": "high", - "radialSegments": 20, - "radiusData": {}, - "radiusScale": 2, - "radiusSize": 0.15, - "radiusType": "size", - "roughness": 0.4, - "sele": "", - "side": "double", - "sphereDetail": 2, - "useInteriorColor": true, - "visible": true, - "wireframe": false - }, - "type": "ball+stick" - } - } - }, - "_ngl_serialize": false, - "_ngl_version": "2.0.0-dev.36", - "_ngl_view_id": [ - "13062166-D27B-4A34-A998-D8974637371C" - ], - "_player_dict": {}, - "_scene_position": {}, - "_scene_rotation": {}, - "_synced_model_ids": [], - "_synced_repr_model_ids": [], - "_view_height": "", - "_view_width": "", - "background": "white", - "frame": 0, - "gui_style": null, - "layout": "IPY_MODEL_6f416140a41a46d483ad84511d75cd7f", - "max_frame": 0, - "n_components": 1, - "picked": {} - } - }, - "aaa175b67e854cb999eb18367dfdc102": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "ac25614ecb52486ea47a389d3f657458": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "34px" - } - }, - "add2162ac769490d96352bc8fa3dad17": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "aef27dece7254fee80b2ec1e83e85564": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "SliderStyleModel", - "state": { - "description_width": "" - } - }, - "affc12bc36e2481ebdda98eda9398814": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_a0d24f140921447f9f036b3add9136f4", - "IPY_MODEL_39b0b2646f444c1baa98d12487a530e7" - ], - "layout": "IPY_MODEL_c9285c308ba440d2bca0d09e9b9988c9" - } - }, - "b12b5c74866040b8abb9d0410ff300a4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "b1cb0e904ed042b2909a775de4cdceed": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "IntSliderModel", - "state": { - "layout": "IPY_MODEL_cb8e617669b343e1bc7b7ac575199dc8", - "max": 0, - "style": "IPY_MODEL_9d2e99f0d32d4e0fa83b07326e2dc79d" - } - }, - "b2b1882789c1462a9ac3de732491f028": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "b3bd15457c8c4aee9725c82e582a78da": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ImageModel", - "state": { - "layout": "IPY_MODEL_b6058b46dc114a0bbb11300ab7eb5d65", - "width": "900.0" - } - }, - "b5362ee608ed45d28c8c318ee4198127": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "b6058b46dc114a0bbb11300ab7eb5d65": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "b748843035524e1dae5d92778a1e692d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "b965e3b6c0e34eb6bbf1abb64139938b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "bfc30c28a6b34c53b257fe8c1b306ba7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_9f36f35dd0cd4c50b87b40313eb5220e", - "value" - ], - "target": [ - "IPY_MODEL_a84cd78b6b1c49e394d064b837e455cc", - "frame" - ] - } - }, - "c0b5758822ba45dea0996a573423eaad": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "c1d4ffb6a62345d29fc4779680d9642e": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "c327a29940c64f3ea65c29812dc4b2d0": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_1964a5142c1544d2bb049800cd64be8e", - "max" - ], - "target": [ - "IPY_MODEL_24e3413db2f543839da5f6836dc0bd35", - "max_frame" - ] - } - }, - "c74c34856d7a4600bb09328edf7de03a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_39b0b2646f444c1baa98d12487a530e7", - "max" - ], - "target": [ - "IPY_MODEL_a83818421c2348d0bd26120cec0fc02a", - "max_frame" - ] - } - }, - "c7bee0591c274ff1ab6e809927ce2023": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_b1cb0e904ed042b2909a775de4cdceed", - "max" - ], - "target": [ - "IPY_MODEL_db6345639c3b4abc8bc70b85913b2a6c", - "max_frame" - ] - } - }, - "c872801ba6ef40f5bd1ba3489caabbee": { - "model_module": "nglview-js-widgets", - "model_module_version": "2.7.1", - "model_name": "ColormakerRegistryModel", - "state": { - "_msg_ar": [], - "_msg_q": [], - "_ready": true, - "layout": "IPY_MODEL_a01dbc8e95b0425384ae15f886dc88ed" - } - }, - "c9285c308ba440d2bca0d09e9b9988c9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "c9832fcaa6524780bc83513a2b22390e": { - "model_module": "nglview-js-widgets", - "model_module_version": "2.7.1", - "model_name": "NGLModel", - "state": { - "_camera_orientation": [ - 6.089666284147105, - 0, - -9.91477087744533, - 0, - 0, - 11.635579788068853, - 0, - 0, - 9.91477087744533, - 0, - 6.089666284147105, - 0, - 0, - -0.4877000264823437, - -0.4877000264823437, - 1 - ], - "_camera_str": "orthographic", - "_gui_theme": null, - "_ibtn_fullscreen": "IPY_MODEL_70bc6342036f47c48362a8e27e10dd08", - "_igui": null, - "_iplayer": "IPY_MODEL_34b6185a0a9149d9829549d0f6ac30ae", - "_ngl_color_dict": {}, - "_ngl_coordinate_resource": {}, - "_ngl_full_stage_parameters": { - "ambientColor": 14540253, - "ambientIntensity": 0.2, - "backgroundColor": "white", - "cameraEyeSep": 0.3, - "cameraFov": 40, - "cameraType": "perspective", - "clipDist": 10, - "clipFar": 100, - "clipNear": 0, - "fogFar": 100, - "fogNear": 50, - "hoverTimeout": 0, - "impostor": true, - "lightColor": 14540253, - "lightIntensity": 1, - "mousePreset": "default", - "panSpeed": 1, - "quality": "medium", - "rotateSpeed": 2, - "sampleLevel": 0, - "tooltip": true, - "workerDefault": true, - "zoomSpeed": 1.2 - }, - "_ngl_msg_archive": [ - { - "args": [ - { - "binary": false, - "data": "\nQCElemental\n\n 3 2 0 0 0 0 0 0 0 0 0\n 0.0000 0.0836 0.0836 O 0 0 0 0 0 0 0 0\n 0.0000 -0.0716 1.0470 H 0 0 0 0 0 0 0 0\n 0.0000 1.0470 -0.0716 H 0 0 0 0 0 0 0 0\n 1 2 1 0 0 0 0\n 1 3 1 0 0 0 0\n", - "type": "blob" - } - ], - "kwargs": { - "defaultRepresentation": true, - "ext": "sdf" - }, - "methodName": "loadFile", - "reconstruc_color_scheme": false, - "target": "Stage", - "type": "call_method" - } - ], - "_ngl_original_stage_parameters": { - "ambientColor": 14540253, - "ambientIntensity": 0.2, - "backgroundColor": "white", - "cameraEyeSep": 0.3, - "cameraFov": 40, - "cameraType": "perspective", - "clipDist": 10, - "clipFar": 100, - "clipNear": 0, - "fogFar": 100, - "fogNear": 50, - "hoverTimeout": 0, - "impostor": true, - "lightColor": 14540253, - "lightIntensity": 1, - "mousePreset": "default", - "panSpeed": 1, - "quality": "medium", - "rotateSpeed": 2, - "sampleLevel": 0, - "tooltip": true, - "workerDefault": true, - "zoomSpeed": 1.2 - }, - "_ngl_repr_dict": { - "0": { - "0": { - "params": { - "aspectRatio": 1.5, - "assembly": "default", - "bondScale": 0.3, - "bondSpacing": 0.75, - "clipCenter": { - "x": 0, - "y": 0, - "z": 0 - }, - "clipNear": 0, - "clipRadius": 0, - "colorMode": "hcl", - "colorReverse": false, - "colorScale": "", - "colorScheme": "element", - "colorValue": 9474192, - "cylinderOnly": false, - "defaultAssembly": "", - "depthWrite": true, - "diffuse": 16777215, - "diffuseInterior": false, - "disableImpostor": false, - "disablePicking": false, - "flatShaded": false, - "interiorColor": 2236962, - "interiorDarkening": 0, - "lazy": false, - "lineOnly": false, - "linewidth": 2, - "matrix": { - "elements": [ - 1, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 1 - ] - }, - "metalness": 0, - "multipleBond": "off", - "opacity": 1, - "openEnded": true, - "quality": "high", - "radialSegments": 20, - "radiusData": {}, - "radiusScale": 2, - "radiusSize": 0.15, - "radiusType": "size", - "roughness": 0.4, - "sele": "", - "side": "double", - "sphereDetail": 2, - "useInteriorColor": true, - "visible": true, - "wireframe": false - }, - "type": "ball+stick" - } - } - }, - "_ngl_serialize": false, - "_ngl_version": "2.0.0-dev.36", - "_ngl_view_id": [ - "9B97AA62-7A36-4D8B-870C-AFA05B27AC39" - ], - "_player_dict": {}, - "_scene_position": {}, - "_scene_rotation": {}, - "_synced_model_ids": [], - "_synced_repr_model_ids": [], - "_view_height": "", - "_view_width": "", - "background": "white", - "frame": 0, - "gui_style": null, - "layout": "IPY_MODEL_c1d4ffb6a62345d29fc4779680d9642e", - "max_frame": 0, - "n_components": 1, - "picked": {} - } - }, - "ca78176594414e46a0be8e1b13dc3174": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "34px" - } - }, - "cb8e617669b343e1bc7b7ac575199dc8": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "cc704e3ffa7a483f80e9ecbbb1136027": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "cccabfe168dd4ebe9b7fb0cc9eefa073": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_9f36f35dd0cd4c50b87b40313eb5220e", - "IPY_MODEL_353f9341148249cea1862a06367a02c4" - ], - "layout": "IPY_MODEL_b5362ee608ed45d28c8c318ee4198127" - } - }, - "cd4c7c153e2b475398f666f141151168": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonStyleModel", - "state": {} - }, - "d1faaffad56341c28c9da4095a28f5d8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_9d75834c00a94d828e7f1809d83aaa01", - "value" - ], - "target": [ - "IPY_MODEL_db6345639c3b4abc8bc70b85913b2a6c", - "frame" - ] - } - }, - "d4c5355705ac439f900ec4ac9c4226d7": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_a0d24f140921447f9f036b3add9136f4", - "value" - ], - "target": [ - "IPY_MODEL_39b0b2646f444c1baa98d12487a530e7", - "value" - ] - } - }, - "d50680e0adf047f4bcdbc1adc0bede5d": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "d8b037e6a6194cea9f06b2e1289eef4c": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "d9ccad4633d94100a476ea61783953b6": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_1964a5142c1544d2bb049800cd64be8e", - "IPY_MODEL_1466725088f64032bf963274418fe137" - ], - "layout": "IPY_MODEL_5387cc68c3624e59b090285931f76840" - } - }, - "db6345639c3b4abc8bc70b85913b2a6c": { - "model_module": "nglview-js-widgets", - "model_module_version": "2.7.1", - "model_name": "NGLModel", - "state": { - "_camera_orientation": [ - 7.589090548206325, - 0, - 0, - 0, - 0, - 7.589090548206325, - 0, - 0, - 0, - 0, - 7.589090548206325, - 0, - 0, - -0.52920001745224, - -0.52920001745224, - 1 - ], - "_camera_str": "orthographic", - "_gui_theme": null, - "_ibtn_fullscreen": "IPY_MODEL_efbeb746254d47009bc50d946c65493d", - "_igui": null, - "_iplayer": "IPY_MODEL_69620f0cf57748cbb4d698cd984aa939", - "_ngl_color_dict": {}, - "_ngl_coordinate_resource": {}, - "_ngl_full_stage_parameters": { - "ambientColor": 14540253, - "ambientIntensity": 0.2, - "backgroundColor": "white", - "cameraEyeSep": 0.3, - "cameraFov": 40, - "cameraType": "perspective", - "clipDist": 10, - "clipFar": 100, - "clipNear": 0, - "fogFar": 100, - "fogNear": 50, - "hoverTimeout": 0, - "impostor": true, - "lightColor": 14540253, - "lightIntensity": 1, - "mousePreset": "default", - "panSpeed": 1, - "quality": "medium", - "rotateSpeed": 2, - "sampleLevel": 0, - "tooltip": true, - "workerDefault": true, - "zoomSpeed": 1.2 - }, - "_ngl_msg_archive": [ - { - "args": [ - { - "binary": false, - "data": "\nQCElemental\n\n 3 2 0 0 0 0 0 0 0 0 0\n 0.0000 0.0000 0.0000 O 0 0 0 0 0 0 0 0\n 0.0000 0.0000 1.0584 H 0 0 0 0 0 0 0 0\n 0.0000 1.0584 0.0000 H 0 0 0 0 0 0 0 0\n 1 2 1 0 0 0 0\n 1 3 1 0 0 0 0\n", - "type": "blob" - } - ], - "kwargs": { - "defaultRepresentation": true, - "ext": "sdf" - }, - "methodName": "loadFile", - "reconstruc_color_scheme": false, - "target": "Stage", - "type": "call_method" - } - ], - "_ngl_original_stage_parameters": { - "ambientColor": 14540253, - "ambientIntensity": 0.2, - "backgroundColor": "white", - "cameraEyeSep": 0.3, - "cameraFov": 40, - "cameraType": "perspective", - "clipDist": 10, - "clipFar": 100, - "clipNear": 0, - "fogFar": 100, - "fogNear": 50, - "hoverTimeout": 0, - "impostor": true, - "lightColor": 14540253, - "lightIntensity": 1, - "mousePreset": "default", - "panSpeed": 1, - "quality": "medium", - "rotateSpeed": 2, - "sampleLevel": 0, - "tooltip": true, - "workerDefault": true, - "zoomSpeed": 1.2 - }, - "_ngl_repr_dict": { - "0": { - "0": { - "params": { - "aspectRatio": 1.5, - "assembly": "default", - "bondScale": 0.3, - "bondSpacing": 0.75, - "clipCenter": { - "x": 0, - "y": 0, - "z": 0 - }, - "clipNear": 0, - "clipRadius": 0, - "colorMode": "hcl", - "colorReverse": false, - "colorScale": "", - "colorScheme": "element", - "colorValue": 9474192, - "cylinderOnly": false, - "defaultAssembly": "", - "depthWrite": true, - "diffuse": 16777215, - "diffuseInterior": false, - "disableImpostor": false, - "disablePicking": false, - "flatShaded": false, - "interiorColor": 2236962, - "interiorDarkening": 0, - "lazy": false, - "lineOnly": false, - "linewidth": 2, - "matrix": { - "elements": [ - 1, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 1, - 0, - 0, - 0, - 0, - 1 - ] - }, - "metalness": 0, - "multipleBond": "off", - "opacity": 1, - "openEnded": true, - "quality": "high", - "radialSegments": 20, - "radiusData": {}, - "radiusScale": 2, - "radiusSize": 0.15, - "radiusType": "size", - "roughness": 0.4, - "sele": "", - "side": "double", - "sphereDetail": 2, - "useInteriorColor": true, - "visible": true, - "wireframe": false - }, - "type": "ball+stick" - } - } - }, - "_ngl_serialize": false, - "_ngl_version": "2.0.0-dev.36", - "_ngl_view_id": [ - "815A1452-BFD1-49BD-8378-830F0B5863C4" - ], - "_player_dict": {}, - "_scene_position": {}, - "_scene_rotation": {}, - "_synced_model_ids": [], - "_synced_repr_model_ids": [], - "_view_height": "", - "_view_width": "", - "background": "white", - "frame": 0, - "gui_style": null, - "layout": "IPY_MODEL_2fda95bb194a4d8c90fa602ef57b5b6d", - "max_frame": 0, - "n_components": 1, - "picked": {} - } - }, - "db8aca2c94734431ac49febea58c3955": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "PlayModel", - "state": { - "layout": "IPY_MODEL_aaa175b67e854cb999eb18367dfdc102", - "max": 0, - "style": "IPY_MODEL_a19030ff2bd749f8b79a1f56cd6771db" - } - }, - "e095a6b9fbde4238892a8d4f0beffa5a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "PlayModel", - "state": { - "layout": "IPY_MODEL_1b15c8c89d00426997fb4d5b1c6cde42", - "max": 0, - "style": "IPY_MODEL_52584e0ee2a44853ad0a6dbf4c9c5375" - } - }, - "e22dfa6992a7463386b3b5c0f66410f4": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "e626666f622f43599f6570cd450182ff": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "IntSliderModel", - "state": { - "layout": "IPY_MODEL_9f91d5c8f76c4d4f9d83925a4c172198", - "max": 0, - "style": "IPY_MODEL_3d32337d17534d5781a20a63faf8a2c6" - } - }, - "edeebd6d76584ae0980f86d8b71d7b0b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "icon": "compress", - "layout": "IPY_MODEL_ac25614ecb52486ea47a389d3f657458", - "style": "IPY_MODEL_8d3ee5bb32cd428c983b30bf57a7744d" - } - }, - "efbeb746254d47009bc50d946c65493d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "icon": "compress", - "layout": "IPY_MODEL_6c374326197e43efb60ba57531399d2d", - "style": "IPY_MODEL_cd4c7c153e2b475398f666f141151168" - } - }, - "fad931986afb4fba8abeabd0493c2568": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "LinkModel", - "state": { - "source": [ - "IPY_MODEL_db8aca2c94734431ac49febea58c3955", - "value" - ], - "target": [ - "IPY_MODEL_c9832fcaa6524780bc83513a2b22390e", - "frame" - ] - } - } - }, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} \ No newline at end of file diff --git a/docs/old_source/results.rst b/docs/old_source/results.rst deleted file mode 100644 index be334aa43..000000000 --- a/docs/old_source/results.rst +++ /dev/null @@ -1,95 +0,0 @@ -Results -======== - -A result is a single quantum chemistry method evaluation, which might be an energy, an analytic gradient or Hessian, or a property evaluation. -Collections of evaluations such -as finite-difference gradients, complete basis set extrapolation, or geometry -optimizations belong under the "Procedures" heading. - -Indices -------- - -A result can be found based off a unique tuple of ``(driver, program, molecule_id, keywords_set, method, basis)`` - -- ``driver`` - The type of calculation being evaluated (i.e. ``energy``, ``gradient``, ``hessian``, ``properties``) -- ``program`` - A lowercase string representation of the quantum chemistry program used (``gamess``, ``nwchem``, ``psi4``, etc.) -- ``molecule_id`` - The :term:`ObjectId` of the molecule used in the computation. -- ``keywords_set`` - The key to the options set stored in the database (e.g. ``default`` -> ``{"e_convergence": 1.e-7, "scf_type": "df", ...}``) -- ``method`` - A lowercase string representation of the method used in the computation (e.g. ``b3lyp``, ``mp2``, ``ccsd(t)``). -- ``basis`` - A lowercase string representation of the basis used in the computation (e.g. ``6-31g``, ``cc-pvdz``, ``def2-svp``) - -Schema ------- - -All results are stored using the `QCSchema `_ so that the storage is quantum chemistry program agnostic. An example of the QCSchema input is shown below: - -.. code-block:: python - - { - "schema_name": "qc_json_input", - "schema_version": 1, - "molecule": { - "geometry": [ - 0.0, 0.0, -0.1294, - 0.0, -1.4941, 1.0274, - 0.0, 1.4941, 1.0274 - ], - "symbols": ["O", "H", "H"] - }, - "driver": "energy", - "model": { - "method": "MP2", - "basis": "cc-pVDZ" - }, - "keywords": {}, - } - -This input would correspond to the following output: - -.. code-block:: python - - { - "schema_name": "qc_json_output", - "schema_version": 1, - "molecule": { - "geometry": [ - 0.0, 0.0, -0.1294, - 0.0, -1.4941, 1.0274, - 0.0, 1.4941, 1.0274 - ], - "symbols": ["O", "H", "H"] - }, - "driver": "energy", - "model": { - "method": "MP2", - "basis": "cc-pVDZ" - }, - "keywords": {}, - "provenance": { - "creator": "QM Program", - "version": "1.1", - "routine": "module.json.run_json" - }, - "return_result": -76.22836742810021, - "success": true, - "properties": { - "calcinfo_nbasis": 24, - "calcinfo_nmo": 24, - "calcinfo_nalpha": 5, - "calcinfo_nbeta": 5, - "calcinfo_natom": 3, - "return_energy": -76.22836742810021, - "scf_one_electron_energy": -122.44534536383037, - "scf_two_electron_energy": 37.62246494040059, - "nuclear_repulsion_energy": 8.80146205625184, - "scf_dipole_moment": [0.0, 0.0, 2.0954], - "scf_iterations": 10, - "scf_total_energy": -76.02141836717794, - "mp2_same_spin_correlation_energy": -0.051980792916251864, - "mp2_opposite_spin_correlation_energy": -0.15496826800602342, - "mp2_singles_energy": 0.0, - "mp2_doubles_energy": -0.20694906092226972, - "mp2_total_correlation_energy": -0.20694906092226972, - "mp2_total_energy": -76.22836742810021 - } - } diff --git a/docs/old_source/server_config.rst b/docs/old_source/server_config.rst deleted file mode 100644 index a64c0680c..000000000 --- a/docs/old_source/server_config.rst +++ /dev/null @@ -1,60 +0,0 @@ -Fractal Server Config -===================== - -This page documents the valid options for the YAML file inputs to the :doc:`Config File `. -This first section outlines each of the headers (top level objects) and a description for each one. -The final file will look like the following: - -.. code-block:: yaml - - common: - option_1: value_for1 - another_opt: 42 - server: - option_for_server: "some string" - -Command Invocation ------------------- - -.. code-block:: bash - - qcfractal-server config [] - -Command Description -------------------- - -Show the current config file at an optional location. - -Looks in the default location if no arg is provided - -Options -------- - -``--base-folder []`` - The QCFractal base directory to attach to. Default: ``~/.qca/qcfractal`` - -Config File Complete Options ----------------------------- - -The valid top-level YAML headers are the parameters of the ``FractalConfig`` class. - -.. autoclass:: qcfractal.config.FractalConfig - :members: - -``database`` -************ - -.. autoclass:: qcfractal.config.DatabaseSettings - :members: - -``fractal`` -*********** - -.. autoclass:: qcfractal.config.FractalServerSettings - :members: - -``view`` -******** - -.. autoclass:: qcfractal.config.ViewSettings - :members: diff --git a/docs/old_source/server_init.rst b/docs/old_source/server_init.rst deleted file mode 100644 index 6ab776dc3..000000000 --- a/docs/old_source/server_init.rst +++ /dev/null @@ -1,109 +0,0 @@ -Fractal Server Init -=================== - -The sub-command for the ``qcfractal-server`` CLI which initializes a new server instance, including configuring -the PostgreSQL database if it is not setup yet. - -Command Invocation ------------------- - -.. code-block:: bash - - qcfractal-server init [] - - -Command Description -------------------- - -This command will attempt to do the following actions for the user in default mode (no args): - -* Create the :term:`QCFractal Config directory` -* Create a blank :doc:`Fractal Config file` (assumes defaults) -* Create the folders for housing the PostgreSQL database file, which will be the home of Fractal's data. -* Initialize PostgreSQL's service at the database location from above -* Start the PostgreSQL server -* Populate the database tables and finalize everything for Fractal's operation - -In most cases, the user should not have to change any configurations if they are the system owners or admins. However, -if users want to do something different, they can write their own :doc:`Config File ` and -change the settings though the CLI to start the server. - -Options -------- - -**This is a set of GLOBAL level options which impact where the ``init`` command looks, and how it interacts with the config file** - -``--overwrite`` - Control whether the rest of the settings overwrite an existing config file in the - :term:`QCFractal Config directory` - -``--base-folder []`` - The QCFractal base directory to attach to. Default: ``~/.qca/qcfractal`` - -**This set of options pertain to the PostgreSQL database itself** and translate to the ``database`` header in the -:doc:`server_config`. - -``--db-port []`` - The PostgreSQL default port, Default ``5432`` - -``--db-host []`` - Default location for the Postgres server. If not ``localhost``, Fractal command lines cannot manage the instance. - and will have to be configured in the :doc:`Config File `. Default: ``localhost`` - -``--db-username []`` - The postgres username to default to. **Planned Feature - Currently inactive**. - -``--db-password []`` - The postgres password for the give user. **Planned Feature - Currently inactive**. - -``--db-directory []`` - "The physical location of the QCFractal instance data, defaults to the root - :term:`Config directory`. - -``--db-default-database []`` - The default database to connect to. Typically used if you already have a Fractal Database set up or you want to - use a different name for the database besides the default. Default ``qcfractal_default``. - -``--db-logfile []`` - The logfile to write postgres logs. Default ``qcfractal_postgres.log``. - -``--db-own (True|False)`` - If own is True, Fractal will control the database instance. If False Postgres will expect a booted server at the - database specification. Default ``True`` - - -**The settings below here pertain to the Fractal Server** and translate to the ``fractal`` header in the -:doc:`server_config`. - -``--name []`` - The Fractal server default name. Controls how the server presents itself to connected clients. - Default ``QCFractal Server`` - -``--port []`` - The Fractal default port. This is the port which Fractal listens to for client connections (and for the URI). - This is *separate* from the ``--db-port`` which is the port that PostgreSQL database is listening for. In general, - these should be separate. Default ``7777``. - -``--compres-response (True|False)`` - Compress REST responses or not, should be True unless behind a proxy. Default ``True``. - -``--allow-read (True|False)`` - Always allows read access to record tables. Default ``True`` - -``--security []`` - Optional security features. Not set by default. - -``--query-limit []`` - The maximum number of records to return per query. Default ``1000`` - -``--logfile []`` - The logfile the Fractal Server writes to. Default ``qcfractal_server.log`` - -``--service-frequency []`` - The frequency to update the Fractal services. Default ``60`` - -``--max-active-services []`` - The maximum number of concurrent active services. Default ``20`` - -``--heartbeat-frequency []`` - The frequency (in seconds) to check the heartbeat of :term:`Managers `. Default ``1800`` diff --git a/docs/old_source/server_start.rst b/docs/old_source/server_start.rst deleted file mode 100644 index c1fb04a7e..000000000 --- a/docs/old_source/server_start.rst +++ /dev/null @@ -1,66 +0,0 @@ -Fractal Server Start -==================== - -The sub-command for the ``qcfractal-server`` CLI which starts the Fractal server instance - -Command Invocation ------------------- - -.. code-block:: bash - - qcfractal-server start [] - - -Command Description -------------------- - -This command will attempt to do the following actions for the user in default mode (no args): - -* Read the :term:`QCFractal Config directory` -* Read the config file in that directory -* Connect to the previously created Fractal database created in the PostgreSQL service (see :doc:`server_init`). -* Start Fractal's periodic services. -* Create and provide SSL certificates. - -The options for the database and starting local compute on the same resources as the server can be controlled through -the flags below. Also see all the config file options in :doc:`Config File `. - -Options -------- - -``--base-folder []`` - The QCFractal base directory to attach to. Default: ``~/.qca/qcfractal`` - -``--port []`` - The Fractal default port. This is the port which Fractal listens to for client connections (and for the URI). - This is *separate* from the `the port that PostgreSQL database is listening for. In general, these should be - separate. Default ``7777``. - -``--logfile []`` - The logfile the Fractal Server writes to. Default ``qcfractal_server.log`` - -``--database-name []`` - The database to connect to, defaults to the default database name. Default ``qcfractal_default`` - -``--server-name []`` - The Fractal server default name. Controls how the server presents itself to connected clients. - Default ``QCFractal Server`` - -``--start-periodics (True|False)`` - **Expert Level Flag Only Warning!** Can disable periodic update (services, heartbeats) if False. Useful when - running behind a proxy. Default ``True`` - -``--disable-ssl (False|True)`` - Disables SSL if present, if ``False`` a SSL cert will be created for you. Default ``False`` - -``--tls-cert []`` - Certificate file for TLS (in PEM format) - -``--tls-key []`` - Private key file for TLS (in PEM format) - -``--local-manager []`` - Creates a local pool QueueManager attached to the server using the number of threads specified by the arg. - If this flag is set and no number is provided, 1 (one) thread will be spun up and running locally. If you - expect :term:`Fractal Managers` to connect to this server, then it is unlikely you need this. Related, if - no compute is expected to be done on this server, then it is unlikely this will be needed. diff --git a/docs/old_source/server_upgrade.rst b/docs/old_source/server_upgrade.rst deleted file mode 100644 index bdea5da3e..000000000 --- a/docs/old_source/server_upgrade.rst +++ /dev/null @@ -1,39 +0,0 @@ -Fractal Server Upgrade -====================== - -The sub-command for the ``qcfractal-server`` CLI which allows in-place upgrade of Fractal Databases to newer versions -through SQLAlchemy Alembic. - -Command Invocation ------------------- - -.. code-block:: bash - - qcfractal-server upgrade [] - - -Command Description -------------------- - -This command will attempt to upgrade an existing Fractal Database (stored in PostgreSQL) to a new version based on the -currently installed Fractal software version. Not every version of Fractal updates the database, so this command will -only need to be run when you know the database has changed (or attempting to start it tells you to). - -This command will attempt to do the following actions for the user in default mode (no args): - -* Read the database location from your :doc:`Config File ` in the default location (can be controlled) -* Determine the upgrade paths from your existing version to the version known by Alembic (update information is - shipped with the Fractal software) -* Stage update -* Commit update if no errors found - -You will then need to start the server again through :doc:`server_start` to bring the server back online. - -Caveat: This command will **not** initialize the Fractal Database for you from nothing. The database must exist for -this command to run. - -Options -------- - -``--base-folder []`` - The QCFractal base directory to attach to. Default: ``~/.qca/qcfractal`` diff --git a/docs/old_source/server_user.rst b/docs/old_source/server_user.rst deleted file mode 100644 index 99491eb10..000000000 --- a/docs/old_source/server_user.rst +++ /dev/null @@ -1,163 +0,0 @@ -Fractal Server User -==================== - -The sub-command for the ``qcfractal-server`` CLI which manages user permissions and passwords. - -Command Invocation ------------------- - -.. code-block:: bash - - qcfractal-server user [] - - -Top-level Options ------------------ - -``--base-folder []`` - The QCFractal base directory to attach to. Default: ``~/.qca/qcfractal``. - -Subcommand Summary ------------------- - -The ``qcfractal-server user`` CLI allows for manipulation of users through four subcommands: - -* ``add``: Add a new user. -* ``show``: Display a user's permissions. -* ``modify``: Change a user's permissions or password. -* ``remove``: Delete a user. - -.. _server_user_add: - -Add Subcommand --------------- - -Command Invocation -~~~~~~~~~~~~~~~~~~ - -.. code-block:: bash - - qcfractal-server user add [] - -Command Description -~~~~~~~~~~~~~~~~~~~ - -This command adds a new user, setting the user's password and permissions. The user must not already exist. - -Arguments -~~~~~~~~~ - -```` - The username to add. - -``--password []`` - The password for the user. - If this option is not provided, a password will be generated and printed. - -``--permissions []`` - Permissions for the user. - Allowed values: ``read``, ``write``, ``queue``, ``compute``, ``admin``. - Multiple values are allowed. - At least one value must be specified. - - -.. _server_user_show: - -Show Subcommand ---------------- - -Command Invocation -~~~~~~~~~~~~~~~~~~ - -.. code-block:: bash - - qcfractal-server user show - -Command Description -~~~~~~~~~~~~~~~~~~~ - -This command prints the permissions for a given user. - -Arguments -~~~~~~~~~ - -```` - The username for which to show permissions. - -.. _server_user_modify: - -Modify Subcommand ------------------ - -Command Invocation -~~~~~~~~~~~~~~~~~~ - -.. code-block:: bash - - qcfractal-server user modify [] - -Command Description -~~~~~~~~~~~~~~~~~~~ - -This command modifys a user's permissions or password. - -Arguments -~~~~~~~~~ - -```` - The username to modfiy. - -``--password []`` - Change the user's password to a given string. - This options excludes ``--reset-password``. - -``--reset-password`` - Change the user's password to an auto-generated value. - The new password will be printed. - This option excludes ``--password``. - -``--permissions []`` - Change the user's permissions to the given set. - Allowed values: ``read``, ``write``, ``queue``, ``compute``, ``admin``. - Multiple values are allowed. - See :ref:`server_user_permissions` for more information. - - -.. _server_user_remove: - -Remove Subcommand ------------------ - -Command Invocation -~~~~~~~~~~~~~~~~~~ - -.. code-block:: bash - - qcfractal-server user remove - -Command Description -~~~~~~~~~~~~~~~~~~~ - -This command removes a user. - -Arguments -~~~~~~~~~ - -```` - The username to remove. - -.. _server_user_permissions: - -User Permissions ----------------- - -Five permission types are available: - -* ``read`` allows read access to existing records. -* ``write`` allows write access to existing records and the ability to add new records. -* ``compute`` allows enqueuing new :term:`Tasks `. -* ``queue`` allows for consumption of compute :term:`Tasks `. - This permission is intended for use by a :term:`Manager`. -* ``admin`` allows all permissions. - - diff --git a/docs/old_source/server_view.rst b/docs/old_source/server_view.rst deleted file mode 100644 index d41728a4f..000000000 --- a/docs/old_source/server_view.rst +++ /dev/null @@ -1,32 +0,0 @@ -Server-side Dataset Views -========================= - -.. note:: - This is an experimental feature. - -HDF5 views of Datasets may be stored on the server to improve query performance. -To use views, first specify a path to store views in the :class:`qcfractal.config.ViewSettings`. - -Next, generate a view for the collection(s) of interest: - -.. code-block:: python - - import qcfractal.interface as ptl - ds = ptl.get_collection("ReactionDataset", "S22") - - # Note the server will look for views in the directory specified above, - # named {collection_id}.hdf5 - view = ptl.collections.HDF5View(viewpath / f"{ds.data.id}.hdf5") - view.write(ds) - -Finally, mark the collection as supporting views: - -.. code-block:: python - - # Update the dataset to indicate a view is available - ds.__dict__["view_available"] = True - ds.save() - - # Optionally, you may add a download URL for the view - ds.__dict__["view_url"] = "https://someserver.com/view.hdf5" - ds.save() diff --git a/docs/old_source/service-torsiondrive.rst b/docs/old_source/service-torsiondrive.rst deleted file mode 100644 index cf9b8d061..000000000 --- a/docs/old_source/service-torsiondrive.rst +++ /dev/null @@ -1,4 +0,0 @@ -TorsionDrive -============ - - diff --git a/docs/old_source/services.rst b/docs/old_source/services.rst deleted file mode 100644 index 38ffb5d20..000000000 --- a/docs/old_source/services.rst +++ /dev/null @@ -1,36 +0,0 @@ -Services -======== - -Services are unique workflows where there is an iterative component on the -server. A typical service workflow looks like the following: - -1. A client submits a new service request to the server. -2. A service is created on the server and placed in the service queue. -3. A service iteration is called that will spawn new tasks. -4. The service waits until all generated tasks are complete. -5. The service repeats 3 and 4 until the service iterations are complete. -6. The service cleans intermediate data, finalizes the data representation, and marks itself complete. - -The TorsionDrive service will be used as an example to illuminate the above -steps. The TorsionDrive service optimizes the geometry of a biomolecule at a -number of frozen dihedral angles to provide an energy profile of the rotation -of this dihedral bond. - -Consider the service using a concrete example of scanning the -hydrogen peroxide dihedral: - -1. A client submits a task to scan the HOOH molecule dihedral every 90 degrees as a service. -2. The service is received by the server, and the first 0-degree dihedral geometry optimization :term:`Task` is spawned. -3. The service waits until the 0-degree :term:`Task` is complete, and then generates 90 and -90-degree :term:`tasks` based off this 0-degree geometry. -4. The service waits for the two new :term:`tasks` to complete and spawns 0 and 180-degree tasks based on the 90 and - 90-degree geometries. -5. The service waits for the 90- and -90-degree :term:`tasks` to complete. Then it builds its final data structure for user querying and marks itself complete. - -The service technology allows the ``FractalServer`` to complete very complex -workflows of arbitrary design. To see a pictorial representation of this -process, please see the -:ref:`flowchart showing the pseudo-calls ` when a -service is added to the ``FractalServer`` - - -.. toctree:: - service-torsiondrive diff --git a/docs/old_source/setup_compute.rst b/docs/old_source/setup_compute.rst deleted file mode 100644 index ff3b4330b..000000000 --- a/docs/old_source/setup_compute.rst +++ /dev/null @@ -1,176 +0,0 @@ -Manager Setup -============= - -Once a QCFractal server is running, compute can be attached to it by spinning -up ``qcfractal-manager``. These ``qcfractal-manager`` connect to your -FractalServer instance, adds tasks to a distributed workflow manager, and -pushes complete tasks back to the ``qcfractal-server`` instance. These -``qcfractal-manager`` should be run on either the machine that is executing -the computations or on the head nodes of supercomputers and local clusters. - - -Distributed Workflow Engines ----------------------------- - -QCFractal supports a number of distributed workflow engines to execute -computations. Each of these has strengths and weaknesses depending on the -workload, task specifications, and resources that the compute will be executed -on. In general, we recommend the following: - -- For laptops and single nodes: ProcessPoolExecutor -- For local clusters: Dask or Parsl - -The ProcessPoolExecutor uses built-in Python types and requires no additional -libraries while Dask requires ``dask``, ``dask.distributed``, and -``dask_jobqueue`` (|DaskD|_, |DaskJQ|_); and Parsl requires ``parsl`` (|ParslDoc|_) - -Using the Command Line ----------------------- - -.. note:: - - The CLI + YAML config file is the current recommended way to start and run - Fractal Queue Managers - -At the moment only ProcessPoolExecutor ``qcfractal-manager`` can be spun up purely -from the command line as other distributed workflow managers require -additional setup through a YAML config file. - -For the full docs for setting up a :term:`Manager`, please see :doc:`the Manager documentation pages.` - -Launching a ``qcfractal-manager`` using a ProcessPoolExecutor: - -.. code-block:: console - - $ fractal-manager executor - [I 190301 10:45:50 managers:118] QueueManager: - [I 190301 10:45:50 managers:119] Version: v0.5.0 - - [I 190301 10:45:50 managers:122] Name Information: - [I 190301 10:45:50 managers:123] Cluster: unknown - [I 190301 10:45:50 managers:124] Hostname: qcfractal.local - [I 190301 10:45:50 managers:125] UUID: 0d2b7704-6ac0-4ef7-b831-00aa6afa8c1c - - [I 190301 10:45:50 managers:127] Queue Adapter: - [I 190301 10:45:50 managers:128] > - - [I 190301 10:45:50 managers:131] QCEngine: - [I 190301 10:45:50 managers:132] Version: v0.6.1 - - [I 190301 10:45:50 managers:150] Connected: - [I 190301 10:45:50 managers:151] Version: v0.5.0 - [I 190301 10:45:50 managers:152] Address: https://localhost:7777/ - [I 190301 10:45:50 managers:153] Name: QCFractal Server - [I 190301 10:45:50 managers:154] Queue tag: None - [I 190301 10:45:50 managers:155] Username: None - - [I 190301 10:45:50 managers:194] QueueManager successfully started. Starting IOLoop. - -The connected ``qcfractal-server`` instance can be controlled by: - -.. code-block:: console - - $ qcfractal-manager --fractal-uri=api.qcfractal.molssi.org:443 - -Only basic settings can be started through the CLI and most of the options require a YAML config file to get up and -going. You can check all valid YAML options in :doc:`the Manager documentation pages` or you can always -check the current schema from the CLI with: - -.. code-block:: console - - $ qcfractal-manager --schema - -The CLI has several options which can examined with:: - - qcfractal-manager --help - -Every option specified in the CLI has an equal option in the YAML config file (except for ``--help`` and ``--schema``), -but many YAML options are not present in the CLI due to their complex nature. Any option set in both places will -defer to the CLI's setting, allowing you to overwrite some of the common YAML config options on invocation. - - -.. note:: - - The ``--manager-name`` argument is useful to change the name of the manager - reported back to the :term:`Server` instance. In addition, the - ``--queue-tag`` will limit the acquisition of tasks to only the desired - :term:`Server` task tags. These settings can also all be set in the YAML - config file. - - -Using the Python API --------------------- - -``qcfractal-managers`` can also be created using the Python API. - -.. warning:: - - This is for advanced users and special care needs to be taken to ensure - that both the manager and the workflow tool need to understand the number - of cores and memory available to prevent over-subscription of compute. - -.. code-block:: python - - from qcfractal.interface import FractalClient - from qcfractal import QueueManager - - import dask import distributed - - fractal_client = FractalClient("localhost:7777") - workflow_client = distributed.Client("tcp://10.0.1.40:8786") - - ncores = 4 - mem = 2 - - # Build a manager - manager = QueueManager(fractal_client, workflow_client, cores_per_task=ncores, memory_per_task=mem) - - # Important for a calm shutdown - from qcfractal.cli.cli_utils import install_signal_handlers - install_signal_handlers(manager.loop, manager.stop) - - # Start or test the loop. Swap with the .test() and .start() method respectively - manager.start() - -Testing -------- - -A ``qcfractal-manager`` can be tested using the ``--test`` argument and does -not require an active ``qcfractal-manager``, this is very useful to check if -both the distributed workflow manager is setup correctly and correct -computational engines are found. - -.. code-block:: console - - $ qcfractal-manager --test - [I 190301 10:55:57 managers:118] QueueManager: - [I 190301 10:55:57 managers:119] Version: v0.5.0+52.g6eab46f - - [I 190301 10:55:57 managers:122] Name Information: - [I 190301 10:55:57 managers:123] Cluster: unknown - [I 190301 10:55:57 managers:124] Hostname: Daniels-MacBook-Pro.local - [I 190301 10:55:57 managers:125] UUID: 0cd257a6-c839-4743-bb33-fa55bebac1e1 - - [I 190301 10:55:57 managers:127] Queue Adapter: - [I 190301 10:55:57 managers:128] > - - [I 190301 10:55:57 managers:131] QCEngine: - [I 190301 10:55:57 managers:132] Version: v0.6.1 - - [I 190301 10:55:57 managers:158] QCFractal server information: - [I 190301 10:55:57 managers:159] Not connected, some actions will not be available - [I 190301 10:55:57 managers:389] Testing requested, generating tasks - [I 190301 10:55:57 managers:425] Found program rdkit, adding to testing queue. - [I 190301 10:55:57 managers:425] Found program torchani, adding to testing queue. - [I 190301 10:55:57 managers:425] Found program psi4, adding to testing queue. - [I 190301 10:55:57 base_adapter:124] Adapter: Task submitted rdkit - [I 190301 10:55:57 base_adapter:124] Adapter: Task submitted torchani - [I 190301 10:55:57 base_adapter:124] Adapter: Task submitted psi4 - [I 190301 10:55:57 managers:440] Testing tasks submitting, awaiting results. - - [I 190301 10:56:04 managers:444] Testing results acquired. - [I 190301 10:56:04 managers:451] All tasks retrieved successfully. - [I 190301 10:56:04 managers:456] rdkit - PASSED - [I 190301 10:56:04 managers:456] torchani - PASSED - [I 190301 10:56:04 managers:456] psi4 - PASSED - [I 190301 10:56:04 managers:465] All tasks completed successfully! diff --git a/docs/old_source/setup_quickstart.rst b/docs/old_source/setup_quickstart.rst deleted file mode 100644 index 8605913ac..000000000 --- a/docs/old_source/setup_quickstart.rst +++ /dev/null @@ -1,505 +0,0 @@ -Setup Overview -============== - -QCFractal comprises two components: - -1. The :term:`Server` (``qcfractal-server``), which accepts compute and data queries and maintains a database of :term:`tasks ` and results. The :term:`Server` should be run continuously on a persistent machine. -2. One or more :term:`Managers ` (``qcfractal-manager``). The :term:`Managers ` pull work from the :term:`Server`, use attached compute resources to complete the work, and report results back to the server. :term:`Managers ` may be turned off and on at any time. :term:`Managers ` connect to compute resources through :term:`Adapters `. - -In the :doc:`Quickstart Tutorial `, the above components were combined within a python environment using ``FractalSnowflake``. -In general, the :term:`Server` and :term:`Manager(s) ` are run separately in different processes, often on different machines. -For detailed information about the relationship between :term:`Server` and :term:`Manager`, see :doc:`managers`. - - -Common Use Cases ----------------- - -The table below lists some common use cases for QCFractal: - -.. list-table:: - :widths: 25 25 25 25 - :header-rows: 1 - - * - Use case - - ``qcfractal-server`` location - - ``qcfractal-manager`` location - - Recommended manager - * - :doc:`Demonstration/Exploration ` - - Snowflake - - Snowflake - - Snowflake - * - :ref:`Single Workstation ` - - Local - - Local - - Pool - * - :ref:`Private Cluster ` - - Head node - - Head node - - Parsl - * - :ref:`Shared Cluster/Supercomputer ` - - Personal server, head node (if permitted) - - Head node - - Parsl - * - :ref:`Multiple Clusters ` - - Personal server - - Head node of each cluster - - Parsl - * - :ref:`Cloud Compute ` - - Personal server or cloud instance - - Docker container - - Pool - -QCFractal is highly adaptable and is not limited to the above use cases. -For example, it possible to mix local, cluster, supercomputer, and cloud :term:`Managers ` simultaneously. -In addition, a cloud instance may provide a good option for running ``qcfractal-server`` when a persistent web-exposed server is not otherwise available. - -Quickstart Setups ------------------ -This section presents quickstart setup guides for the above common use cases. -The guides assume that QCFractal has been installed (see :doc:`install`). -General guides are also available: - -* :doc:`setup_server` -* :doc:`setup_compute` - -.. _quickstart-single-workstation: - -Single Workstation -++++++++++++++++++ - -This quickstart guide addresses QCFractal setup on a single computer which will be used for the :term:`Server`, :term:`Manager`, user client, and compute. -On the workstation, initialize the :term:`Server`:: - - qcfractal-server init - -Next, start the :term:`Server` and ProcessPoolExecutor :term:`Manager`:: - - nohup qcfractal-server start --local-manager 1 & - -The second command starts ``qcfractal-server`` in the background. -It also starts one :term:`Worker` which will pull :term:`tasks ` from the :term:`Server` and run them. - -Test if everything is setup by running a Hartree-Fock calculation on a single hydrogen molecule, -as in the :doc:`quickstart` (note this requires ``psi4``): - -.. code-block:: python - - python - - >>> import qcfractal.interface as ptl - - # Note that server TLS verification is turned off (verify=False) since all components are run locally. - >>> client = ptl.FractalClient(address="localhost:7777", verify=False) - >>> mol = ptl.Molecule(symbols=["H", "H"], geometry=[0, 0, 0, 0, 5, 0]) - >>> mol_id = client.add_molecules([mol])[0] - >>> r = client.add_compute("psi4", "HF", "STO-3G", "energy", None, [mol_id]) - - # Wait a minute for the job to complete - >>> proc = client.query_procedures(id=r.ids)[0] - >>> print(proc) - - >>> print(proc.properties.scf_total_energy) - -0.6865598095254312 - - -.. _quickstart-private-cluster: - -Private Cluster -+++++++++++++++ - -This quickstart guide addresses QCFractal setup on a private cluster comprising a head node and compute nodes, with a :term:`Scheduler` such as SLURM, PBS, or Torque. -This guide requires `Parsl `_ which may be installed with ``pip`` or ``conda``. - -Begin by initializing the :term:`Server` on the cluster head node:: - - qcfractal-server init - -Next, start the :term:`Server` in the background:: - - nohup qcfractal-server start & - -The :term:`Manager` must be configured before use. Create a configuration file (e.g. in ``~/.qca/qcfractal/my_manager.yaml``) based on the following template: - -.. code-block:: yaml - - common: - adapter: parsl - tasks_per_worker: 1 - cores_per_worker: 6 - memory_per_worker: 64 - max_workers: 5 - scratch_directory: "$TMPDIR" - - cluster: - node_exclusivity: True - scheduler: slurm - - parsl: - provider: - partition: CLUSTER - cmd_timeout: 30 - -You may need to modify these values to match the particulars of your cluster. In particular: - -* The ``scheduler`` and ``partition`` options should be set to match the details of your :term:`Scheduler` (e.g. SLURM, PBS, Torque). -* Options related to :term:`Workers ` should be set appropriately for the compute node on your cluster. - Note that Parsl requires that full nodes be allocated to each :term:`Worker` (i.e. ``node_exclusivity: True``). - -For more information on :term:`Manager` configuration, see :doc:`managers` and :doc:`managers_samples`. - -Finally, start the :term:`Manager` in the background on the cluster head node:: - - nohup qcfractal-manager --config-file --verify=False & - -Note that TLS certificate verification is disabled (``--verify=False``) because the :term:`Manager` and :term:`Server` are both run on the head node. - -Test if everything is setup by running a Hartree-Fock calculation on a single hydrogen molecule, -as in the :doc:`quickstart` (note this requires ``psi4``): - -.. code-block:: python - - python - - >>> import qcfractal.interface as ptl - - # Note that server TLS verification is turned off (verify=False) since all components are run locally. - >>> client = ptl.FractalClient(address="localhost:7777", verify=False) - >>> mol = ptl.Molecule(symbols=["H", "H"], geometry=[0, 0, 0, 0, 5, 0]) - >>> mol_id = client.add_molecules([mol])[0] - >>> r = client.add_compute("psi4", "HF", "STO-3G", "energy", None, [mol_id]) - - # Wait a minute for the job to complete - >>> proc = client.query_procedures(id=r.ids)[0] - >>> print(proc) - - >>> print(proc.properties.scf_total_energy) - -0.6865598095254312 - - -.. _quickstart-shared-cluster: - -Shared Clusters, Supercomputers, and Multiple Clusters -++++++++++++++++++++++++++++++++++++++++++++++++++++++ - -This quickstart guide addresses QCFractal setup on one or more shared cluster(s). -The :term:`Server` should be set up on a persistent server for which you have permission to expose ports. -For example, this may be a dedicated webserver, the head node of a private cluster, or a cloud instance. -The :term:`Manager` should be set up on each shared cluster. -In most cases, the :term:`Manager` may be run on the head node; -contact your system administrator if you are unsure. -This guide requires `Parsl `_ to be installed for the :term:`Manager`. It may be installed with ``pip`` or ``conda``. - -Begin by initializing the :term:`Server` on your persistent server:: - - qcfractal-server init - -The QCFractal server receives connections from :term:`Managers ` and clients on TCP port 7777. -You may optionally specify the ``--port`` option to choose a custom port. -You may need to configure your firewall to allow access to this port. - -Because the :term:`Server` will be exposed to the internet, -security should be enabled to control access. -Enable security by changing the YAML file (default: ``~/.qca/qcfractal/qcfractal_config.yaml``) -``fractal.security`` option to ``local``: - -.. code-block:: diff - - - security: null - + security: local - -Start the :term:`Server`:: - - nohup qcfractal-server start & - -.. note:: - - You may optionally provide a TLS certificate to enable host verification for the :term:`Server` - using the ``--tls-cert`` and ``--tls-key`` options. - If a TLS certificate is not provided, communications with the server will still be encrypted, - but host verification will be unavailable - (and :term:`Managers ` and clients will need to specify ``verify=False``). - -Next, add users for admin, the :term:`Manager`, and a user -(you may choose whatever usernames you like):: - - qcfractal-server user add admin --permissions admin - qcfractal-server user add manager --permissions queue - qcfractal-server user add user --permissions read write compute - -Passwords will be automatically generated and printed. You may instead specify a password with the ``--password`` option. -See :doc:`server_user` for more information. - -:term:`Managers ` should be set up on each shared cluster. -In most cases, the :term:`Manager` may be run on the head node; -contact your system administrator if you are unsure. - -The :term:`Manager` must be configured before use. -Create a configuration file (e.g. in ``~/.qca/qcfractal/my_manager.yaml``) based on the following template: - -.. code-block:: yaml - - common: - adapter: parsl - tasks_per_worker: 1 - cores_per_worker: 6 - memory_per_worker: 64 - max_workers: 5 - scratch_directory: "$TMPDIR" - - cluster: - node_exclusivity: True - scheduler: slurm - - parsl: - provider: - partition: CLUSTER - cmd_timeout: 30 - -You may need to modify these values to match the particulars of each cluster. In particular: - -* The ``scheduler`` and ``partition`` options should be set to match the details of your :term:`Scheduler` (e.g. SLURM, PBS, Torque). -* Options related to :term:`Workers ` should be set appropriately for the compute node on your cluster. - Note that Parsl requires that full nodes be allocated to each :term:`Worker` (i.e. ``node_exclusivity: True``). - -For more information on :term:`Manager` configuration, see :doc:`managers` and :doc:`managers_samples`. - -Finally, start the :term:`Manager` in the background on each cluster head node:: - - nohup qcfractal-manager --config-file --fractal-uri --username manager -password & - -If you did not specify a TLS certificate in the ``qcfractal-server start`` step, you will additionally need to specify ``--verify False`` in the above command. - -Test if everything is setup by running a Hartree-Fock calculation on a single hydrogen molecule, -as in the :doc:`quickstart` -(note this requires ``psi4`` to be installed on at least one compute resource). -This test may be run from any machine. - -.. code-block:: python - - python - - >>> import qcfractal.interface as ptl - - # Note that server TLS verification may need to be turned off if (verify=False). - # Note that the Server URL and the password for user will need to be filled in. - >>> client = ptl.FractalClient(address="URL:Port", username="user", password="***") - >>> mol = ptl.Molecule(symbols=["H", "H"], geometry=[0, 0, 0, 0, 5, 0]) - >>> mol_id = client.add_molecules([mol])[0] - >>> r = client.add_compute("psi4", "HF", "STO-3G", "energy", None, [mol_id]) - - # Wait a minute for the job to complete - >>> proc = client.query_procedures(id=r.ids)[0] - >>> print(proc) - - >>> print(proc.properties.scf_total_energy) - -0.6865598095254312 - - - -.. _quickstart-k8s: - -Cloud Compute -+++++++++++++ - -This quickstart guide addresses QCFractal setup using cloud resources for computation. -The :term:`Server` should be set up on a persistent server for which you have permission to expose ports. -For example, this may be a dedicated webserver, the head node of a private cluster, or a cloud instance. -The :term:`Manager` will be set up on a `Kubernetes `_ cluster as a -`Deployment `_. - -Begin by initializing the :term:`Server` on your persistent server:: - - qcfractal-server init - -The QCFractal server receives connections from :term:`Managers ` and clients on TCP port 7777. -You may optionally specify the ``--port`` option to choose a custom port. -You may need to configure your firewall to allow access to this port. - -Because the :term:`Server` will be exposed to the internet, -security should be enabled to control access. -Enable security by changing the YAML file (default: ``~/.qca/qcfractal/qcfractal_config.yaml``) -``fractal.security`` option to ``local``: - -.. code-block:: diff - - - security: null - + security: local - -Start the :term:`Server`:: - - nohup qcfractal-server start & - -.. note:: - - You may optionally provide a TLS certificate to enable host verification for the :term:`Server` - using the ``--tls-cert`` and ``--tls-key`` options. - If a TLS certificate is not provided, communications with the server will still be encrypted, - but host verification will be unavailable - (and :term:`Managers ` and clients will need to specify ``verify=False``). - -Next, add users for admin, the :term:`Manager`, and a user -(you may choose whatever usernames you like):: - - qcfractal-server user add admin --permissions admin - qcfractal-server user add manager --permissions queue - qcfractal-server user add user --permissions read write compute - -Passwords will be automatically generated and printed. You may instead specify a password with the ``--password`` option. -See :doc:`server_user` for more information. - -The :term:`Manager` will be set up on a `Kubernetes `_ cluster as a -`Deployment `_, running -Docker images which each contain QCEngine, QCFractal, and relevant programs. In this guide, -we use the `molssi/qcarchive_worker_openff `_ -Docker image. For execution, this image includes: - -* `Psi4 `_, `dftd3 `_, and `MP2D `_ -* `RDKit `_ -* `geomeTRIC `_ - - -.. note:: - - You may wish to set up a custom Docker image for your specific use case. The Dockerfile corresponding to the - `molssi/qcarchive_worker_openff `_ - image is included below as an example. - - .. code-block:: Docker - - FROM continuumio/miniconda3 - RUN conda install -c psi4/label/dev -c conda-forge psi4 dftd3 mp2d qcengine qcfractal rdkit geometric - RUN groupadd -g 999 qcfractal && \ - useradd -m -r -u 999 -g qcfractal qcfractal - USER qcfractal - ENV PATH /opt/local/conda/envs/base/bin/:$PATH - ENTRYPOINT qcfractal-manager --config-file /etc/qcfractal-manager/manager.yaml - -Create a manager configuration file (e.g. ``manager.yaml``) following the template below. - -.. code-block:: yaml - - common: - adapter: pool - tasks_per_worker: 1 - cores_per_worker: 4 # CHANGEME number of cores/worker - memory_per_worker: 16 # CHANGEME memory/worker in Gb - max_workers: 1 - scratch_directory: "$TMPDIR" - - server: - fractal_uri: api.qcarchive.molssi.org:443 # CHANGEME URI of your server goes here - username: manager - password: foo # CHANGEME manager password goes here - verify: True # False if TLS was skipped earlier - - manager: - manager_name: MyManager # CHANGEME name your manager - queue_tag: null - log_file_prefix: null - update_frequency: 30 - test: False - -Add the manager configuration as a secret in Kubernetes:: - - kubectl create secret generic manager-config-yaml --from-file=manager.yaml - -This allows us to pass the manager configuration into the Docker container securely. - -Next, create a Kubernetes deployment configuration file (e.g. ``deployment.yaml``) following the template below. -The ``cpu`` and ``memory`` fields of the deployment configuration should match the ``cores_per_worker`` -and ``memory_per_worker`` fields of the manager configuration. -In this setup, ``replicas`` determines the number of workers; the ``max_workers`` and ``tasks_per_worker`` fields -in the manager configuration should be set to 1. - -.. code-block:: yaml - - apiVersion: apps/v1 - kind: Deployment - metadata: - name: qcfractal-manager - labels: - k8s-app: qcfractal-manager - spec: - replicas: 4 # CHANGEME: number of images here - selector: - matchLabels: - k8s-app: qcfractal-manager - template: - metadata: - labels: - k8s-app: qcfractal-manager - spec: - containers: - - image: molssi/qcarchive_worker_openff # you may wish to specify your own Docker image here - name: qcfractal-manager-pod - resources: - limits: - cpu: 4 # CHANGEME number of cores/worker - memory: 16Gi # CHANGEME memory/worker - volumeMounts: - - name: manager-config-secret - mountPath: "/etc/qcfractal-manager" - readOnly: true - volumes: - - name: manager-config-secret - secret: - secretName: manager-config-yaml - -Start the deployment:: - - kubectl apply -f deployment.yaml - -.. note:: - - You can view the status of your deployment with:: - - kubectl get deployments - - You can view the status of individual "Pods" (Docker containers) with:: - - kubectl get pods --show-labels - - To get the output of invidual Managers:: - - kubectl logs - - To get Kubernetes metadata and status information about a Pod:: - - kubectl describe pod - - See the `Kubernetes Deployment documentation `_ - for more information. - -Test if everything is setup by running a Hartree-Fock calculation on a single hydrogen molecule, -as in the :doc:`quickstart` -(note this requires ``psi4`` to be installed on at least one compute resource). -This test may be run from any machine. - -.. code-block:: python - - python - - >>> import qcfractal.interface as ptl - - # Note that server TLS verification may need to be turned off if (verify=False). - # Note that the Server URL and the password for user will need to be filled in. - >>> client = ptl.FractalClient(address="URL:Port", username="user", password="***") - >>> mol = ptl.Molecule(symbols=["H", "H"], geometry=[0, 0, 0, 0, 5, 0]) - >>> mol_id = client.add_molecules([mol])[0] - >>> r = client.add_compute("psi4", "HF", "STO-3G", "energy", None, [mol_id]) - - # Wait a minute for the job to complete - >>> proc = client.query_procedures(id=r.ids)[0] - >>> print(proc) - - >>> print(proc.properties.scf_total_energy) - -0.6865598095254312 - - - -Other Use Cases ---------------- - -QCFractal is highly configurable and supports many use cases beyond those described here. -For more information, see the :doc:`Server ` and :doc:`Manager ` documentation sections. -You may also :ref:`contact us `. diff --git a/docs/old_source/setup_server.rst b/docs/old_source/setup_server.rst deleted file mode 100644 index 6f462d76c..000000000 --- a/docs/old_source/setup_server.rst +++ /dev/null @@ -1,98 +0,0 @@ -Server Setup -============ - -A ``qcfractal-server`` instance contains a record of all results, task queue, -and collection information and provides an interface to all FractalClients -and ``qcfractal-manager``\s. All data is stored in a PostgreSQL database which is often -handled transparently. A server -instance should be run on hardware that is for long periods stable (not -shutdown often), accessible from both compute resources and users via HTTP, -and have access to permanent storage. This location is often either research -groups local computers, a supercomputer with appropriately allocated -resources for this task, or the cloud. - - -Using the Command Line ----------------------- - -The command line is used for ``qcfractal-server`` instances that are long-term -data storage and task distribution engines. To begin, a ``qcfractal-server`` -is first initialized using the command line: - -.. code-block:: console - - >>> qcfractal-server init - -This initialization will create ``~/.qca/qcfractal`` folder (which can be -altered) which contains default specifications for the ``qcfractal-server`` -and for the underlying PostgreSQL database. The ``qcfractal-server init ---help`` CLI command will describe all parameterizations of this folder. In -addition to the specification information, a new PostgreSQL database will be -initialized and started in the background. The background PostgreSQL database -consumes virtually no resources when not in use and should not interfere with -your system. - -Once a ``qcfractal-server`` instance is initialized the server can then be run -with the ``start`` command: - -.. code-block:: console - - >>> qcfractal-server start - -The QCFractal server is now ready to accept new connections. - -Within a Python Script ----------------------- - -Canonical workflows can be run from a Python script using the ``FractalSnowflake`` -instance. With default options a ``FractalSnowflake`` will spin up a fresh database which -will be removed after shutdown. - -.. warning:: - - All data inside a ``FractalSnowflake`` is temporary and will be deleted when the - ``FractalSnowflake`` shuts down. - -.. code-block:: python - - >>> from qcfractal import FractalSnowflake - >>> server = FractalSnowflake() - - # Obtain a FractalClient to the server - >>> client = server.client() - -A standard ``FractalServer`` cannot be started in a Python script and then interacted with -as a ``FractalServer`` uses asynchronous programming by default. ``FractalServer.stop`` will -stop the script. - - -Within a Jupyter Notebook -------------------------- - -Due to the way Jupyter Notebooks work an interactive server needs to take a different approach -than the canonical Python script. To manipulate a server in a Jupyter Notebook a -``FractalSnowflakeHandler`` can be used much in the same way as a ``FractalSnowflake``. - -.. warning:: - - All data inside a ``FractalSnowflakeHandler`` is temporary and will be deleted when the - ``FractalSnowflakeHandler`` shuts down. - -.. code-block:: python - - >>> from qcfractal import FractalSnowflakeHandler - >>> server = FractalSnowflakeHandler() - - # Obtain a FractalClient to the server - >>> client = server.client() - - -Full Server Config Settings ---------------------------- - -The full CLI and configs for the Fractal Server can be found on the following pages: - -* Fractal Server Config file: :doc:`server_config` -* ``qcfractal-server init``: :doc:`server_init` -* ``qcfractal-server start``: :doc:`server_start` -* ``qcfractal-server upgrade``: :doc:`server_upgrade`