Release 4.0.0

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
• 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.
• 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.
• 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.
• 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

Release 3.1.0

Changes:

• 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.
• 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

Release 3.0.0

Changes:

• 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.
• 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.
• 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.
• 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.

Release 2.2.0

Changes:

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

Release 2.1.0

Changes:

• 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.

Release 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