Scine-chemoton

Latest version: v4.0.0

Safety actively analyzes 682532 Python packages for vulnerabilities to keep your Python projects secure.

Scan your dependencies

Page 1 of 2

4.0.0

-------------

API Changes:
- Move network refinement to separate folder
- Move all filters to separate folder
- Move reaction rules to separate folder
- Remove deprecated database queries
- Removed some gear options such as `pre_refine_model` in favor of the default `model` field
- Set the default `model` option with `PlaceHolderModel` and check if it is still present before launching the gear to make sure that an intended model is used
- Small changes to the default arguments of the kinetic modeling gear to facilitate its use in SCINE Heron

New features
- Add StructureFilters derived from fitting AggregatesFilters.
- Assemble reactive complexes from two given molecules easily with an CLI.
- Elementary Step Gears can set up reaction trials for flasks.
- Almost all Aggregate and ReactiveSiteFilters are made suitable for flasks. If not, a note is included in the documentation.
- Add an AggregateFilter that filters based on substructure searches.
- Add an AggregateFilter that filters based on allowed / disallowed molecular charges.
- Add reverse option for some existing AggregateFilters.
- KineticsGear now has an option that allows to run it as many cycles as long as no new aggregates are activated and then stops itself.
- Add gear to carry out additional energy calculations.
- Kinetic modeling may now work with a mixture of electronic structure models.
- Energies may now be automatically referenced as formation energies from the atoms.
- The bond-based trial generator is now able to enable (enable exploration/analysis) the analysis of structures,
elementary steps, etc. in the results of already completed calculations, i.e., the trial generator detects that
it already set up a calculation previously. Instead of just continuing, it may then enable the results of this
calculation. This simulates a step-wise exploration of already existing data in the DB that was disabled before
and is intended to allow re-exploration with different reaction conditions such as temperature and pressure or
recycle existing data after changing the kinetics gear (or kinetic modeling, pathfinder etc.).
- Add a framework to filter reactions (analogous to the aggregates filters) and filter elementary steps. These
new filters can be applied to the refinement framework (e.g., barrier-screening, barrier-less reaction selection,
concentrations etc.).
- The refinement is now split into 3 gears:
- Calculation-based refinement looping over the calculations and refining elementary steps (structures etc).
- Reaction-based refinement looping over reactions and selects elementary steps to be refined for each reaction
(including energy window for the step selection).
- Aggregate-based refinement looping over aggregates and refining the structures of these aggregates (including
energy window for the selection of the structure).
- All refinement gears support the same enabling strategy as introduced to the bond-based trial generator.
- Add reaction filter-based kinetics gear.
- Add reaction filter to constrain the maximum energy encountered when exploring a single potential energy surface.
- Add an aggregate filter to enforce that the particle number is conserved during the exploration.
- Add feature that a running Network Expansion of the Steering Wheel can be interrupted and continued later.

Changes
- Rework the Engine / Gear interaction, by replacing the sent signals with shared memory members
- Add EngineHandler class to join any forked engines if a signal is sent, replacing the custom code in the main script; the class also allows for running all engines and stopping the processes gracefully
- Change the internal representation of some AggregateFilters from strings to enums in order to be faster.
- Add additional caches to some AggregateFilters for increased performance.
- Add more default settings.

Bugfixes
- The MinimalConnectivityKinetics and BasicBarrierHeightKinetics did not consider reactions where all reactants on the right hand side were available, which lead to fewer activated aggregates
- GearOptions of the NetworkExpansion did not consider that there could be multiple gears of the same type but with different options in a protocol, hence their datastructure (including access keys) are now changed.
- Fix type annotations in the documentation.

Technical changes
- `get_transition_state_free_energy` in the reaction_wrapper now returns `max(e_lhs, e_rhs)` if the reaction is
barrier-less.
- Add more typehints

3.1.0

-------------

New features
- Add SteeringWheel infrastructure for actively steering explorations.
- Add ThermoAggregateHousekeeping gear which allows sorting of structures with a frequency check.
- AtomPairFunctionalGroupFilter for specifying pairs of functional groups that are allowed to react.
- CentralSiteFilter to focus explorations on certain elements, suited well for homogeneous catalysis.
- New ElementaryStepGear to focus explorations on certain structures.
- New ReactiveSiteFilter based on substructures provided in .xyz or .mol files.
- The KineticModelingGear is now able to setup jobs for the puffin interface of the ReactionMechanismSimulator.

Changes
- Queries and utility functions related only to the database are moved to the `scine_database` package. The functionality here is deprecated and the unittests are removed.
- Update address in license

3.0.0

-------------

New features
- Add improved handling of kill (SIGINT) and terminate (SIGTERM) signals to engines,
including new breakpoints in existing gears.
- Add a gear that allows the re-running of calculations that failed (e.g., failure to locate a transition state).
- Allow to either exclude or include reactive sites based on rules.
- New PathfinderKinetics gear to activate compounds based on the compound costs obtained with Pathfinder.
- New TrialGenerator for ElementaryStepGears based on reaction templates.

Improvements
- Many gears and also filters now use local caches for enhanced performance.
- All gears have an Options object holding at least a Model.
- All ElementaryStepGears and TrialGenerators expose a public method that allows access to the calculations
that would be set-up in the next run.
- Add option to ElementaryStepGear and TrialGenerator that allows to check all existing calculations for
an exact settings match, so that elementary step trials can be enhanced with more inclusive options.
- Allow to get all valid compounds for the BruteForceConformersGear
- Add caches to ElementaryStepGear and BasicBarrierHeightKinetics
- More gears can be limited with an AggregateFilter.
- Add type checking of reaction rules at runtime.
- More options to chose for building a graph with Pathfinder and more robust determination of compound costs.
- Allow restriction of compounds based on maximum reaction energy of reactions leading to them.

Changes
- Separate the reaction rule definitions from the reactive site filters and structure them.
- Redefine the FunctionalGroupRule.
- Rename CompoundFilter to AggregateFilter.
- Consider the explore status of each aggregate/reaction for the Thermo gear and add setting to allow to ignore
the status.
- Increase default number of optimization cycles for reactive complex optimization to find a potential
barrierless elementary step.

Bug Fixes:
- Add the calculation status to the safety query of the AggregateHousekeeping gear if the found structure is
the result of a minimization to avoid false positives due to race conditions with the results-adding puffin.
- Fix lastmodified query to correctly handle time zones.
- Fix bug in attack direction cache of the reactive complex generator.
- Fix bug in BasicBarrierHeightKinetics leading to too many activations in certain network arrangements.

2.2.0

-------------

New features
- Introduce Pathfinder, a graph-based approach to analyze how compounds are connected via reactions while considering
kinetic and stoichiometric constraints.

2.1.0

-------------

New features
- Introduce Flasks to the reaction networks (aggregates of stable non-bonded complexes)
- Elementary-step gear that uses the current minimum-energy conformer for reaction trial generation.
- Added a gear that sets up kinetic modeling jobs.
- Allow the refinement of a subset of elementary steps per reaction. The subset is given through an energy cut-off
above the lowest lying transition state.
- Introduce possibility to efficiently explore barrierless dissociations.

2.0.0

-------------

Python rewrite, and open source release with the following initial features:
- Scriptable framework including a base set of features for the automated
exploration of chemical reaction networks
- Initial chemical reaction networks consisting of
- Structures aggregated into Compounds
- Elementary Steps aggregated into Reactions
- Properties tagged to Structures
- Calculations that generated the network
- Definitions of ``Engines`` with perpetually running ``Gears`` to continuously
perform tasks with chemical reaction networks (see list below)
- Storage and expansion of chemical reaction networks in a SCINE Database
- Automated job set up and execution via SCINE Puffin
- Definitions of basic filters to reduce number of Elementary Step trials
(see list below)

Initial ``Engines``/``Gears``:
- Basic bookkeeping jobs:
- Sorting Structures into Compounds (BasicCompoundHousekeeping)
- Sorting Elementary Steps into Reactions (BasicReactionHousekeeping)
- Basic Scheduling and prioritization of Calculations (Scheduler)
- Data completion jobs:
- Conformer generation per compound (BruteForceConformers)
- Hessian generation per transition state and minimum energy Structure
(BasicThermoDataCompletion)
- Elementary Step exploration based on existing Compounds:
- For one Structure per Compound (MinimalElementarySteps):
- Based on atoms/fragments (AFIR, NT1)
- Based on bonds (NT2)
- For all combinations of Structures per Compounds (BruteForceElementarySteps):
- Based on atoms/fragments (AFIR, NT1)
- Based on bonds (NT2)
- Steering of network growth via simple kinetic analyses:
- Based on connectivity to user input (MinimalConnectivityKinetics)
- Based on barrier heights of Elementary Steps (BasicBarrierHeightKinetics)

Initial set of filters:
- Compound filtering possible:
- Base class, allows all compounds (CompoundFilter)
- By element counts (ElementCountFilter, ElementSumCountFilter)
- By atom counts or molecular weights (MolecularWeightFilter, AtomNumberFilter)
- By database IDs (IDFilter, OneCompoundIDFilter, SelectedCompoundIDFilter)
- By context (SelfReactionFilter)
- By Hessian evaluation (TrueMinimumFilter)
- By composition (CatalystFilter)
- Reactive site filtering possible:
- Base class, allows all reactive sites (ReactiveSiteFilter)
- By fixed, simple rankings (SimpleRankingFilter, MasmChemicalRankingFilter)
- By custom user rules (AtomRuleBasedFilter, FunctionalGroupRule)
- By atom types (ElementWiseReactionCoordinateFilter)
- All filters of the same type can be chained with logical operations to
tailor the behaviour

Page 1 of 2

© 2024 Safety CLI Cybersecurity Inc. All Rights Reserved.