The amazing Reaction Mechanism Simulator for simulating large chemical kinetic mechanisms

Home Page: https://reactionmechanismgenerator.github.io/ReactionMechanismSimulator.jl

License: MIT License

Julia 36.40% Jupyter Notebook 63.60%

chemistry reactions kinetics simulator reactor

reactionmechanismsimulator.jl's Introduction

RMS - Reaction Mechanism Simulator

Description

RMS is a Julia package designed for simulating and analyzing large chemical reaction mechanisms.

RMS has been used in many applications:

Combustion:
- Ignition quality tester
- Rapid compression machine
- Shock tube
- Flow tube
Pharmaceutical degradation
Polymer film growth
Gas phase catalysis
Electrocatalytic reduction of Nitrogen to ammonia
Solid electrolyte interfaces in batteries
Liquid oxidation
Pyrolysis of heavy oils

Features

Ideal gas, dilute liquid and ideal surface phases.
Wide selection of domains including but not limited to constant temperature and pressure, constant volume, parameterized volume, constant temperature and volume and constant temperature, potential and area. All of these have analytic jacobians! Easy to add more!
Domains can be coupled to fixed interfaces such as inlets and outlets and also to dynamic interfaces such as surface-gas reactive interfaces between surface and gas phase domains.
Diffusion limited rates.
Forward and adjoint sensitivity analysis for all reactors.
Flux diagrams with molecular images (if molecular information is provided).
Handy plotting and other solution analysis tools.
Easy to add new phases, domains, interfaces and other new features.

How to cite

Please include the following citations for ReactionMechanismSimulator.jl in general and for transitory sensitivities and the automatic mechanism analysis toolkit respectively.

Johnson, M. S., Pang, H.-W., Payne, A. M., & Green, W. H. (2023). ReactionMechanismSimulator.jl: A Modern Approach to Chemical Kinetic Mechanism Simulation and Analysis. https://doi.org/10.26434/CHEMRXIV-2023-TJ34T
Johnson, M. S., McGill, C. J., & Green, W. H. (2022). Transitory Sensitivity in Automatic Chemical Kinetic Mechanism Analysis. https://doi.org/10.26434/CHEMRXIV-2022-ZSFJC

Installation

RMS can be installed with:

using Pkg
Pkg.add("ReactionMechanismSimulator")
Pkg.build("ReactionMechanismSimulator")

using ReactionMechanismSimulator

Detailed instructions and documentation are currently available here.

reactionmechanismsimulator.jl's People

Contributors

Stargazers

Watchers

reactionmechanismsimulator.jl's Issues

Thermo via Clapeyron.jl (OpenSAFT)

I created this issue, as mentioned in Juliacon, to track progress in integration of external thermo models to this package, via Clapeyron.jl. If I remember correctly, a volume solver is necessary. Also, for multicomponent mixtures, a dew and bubble pressure solver could be used to mark limits on zones where 2-phase mixtures could occur

Adaptive Preconditioner

Particularly for large simulations where the system is large enough you can't construct the jacobian explicitly and need to rely on methods like GMRES time spent in the solver (rather than in functional evaluations) can dominate. In this case it helps a lot to have a good preconditioner. Fortunately, this has already been studied here for chemical kinetic systems: https://doi.org/10.1016/j.proci.2014.05.113 the preconditioning interface for CVODE_BDF is described here: https://diffeq.sciml.ai/latest/solvers/ode_solve/#ode_solve_sundials-1.

Notes on the Installation and Update the Installation

I don't have access to editing the wiki page. So that I will open an issue page to note down my practice in installing RMS. I would recommend developers install from Github master branch since there is often a need to read the latest source code.

config conda environment for `rmg`

create and activate conda env

conda create -n conda_jl
conda activate conda_jl

install dependence rmg

noting that rmg is only compatible with python version < 3.8. Here we take python=3.7.7 as an example.

conda install -c defaults -c rmg -c rdkit -c cantera -c pytorch -c conda-forge python=3.7.7 rmg

Install the version in the master branch

using Pkg
ENV["PYTHON"] = "/home/weiqi/anaconda3/envs/conda_jl/bin/python"
Pkg.develop(PackageSpec(url="https://github.com/ReactionMechanismGenerator/ReactionMechanismSimulator.jl"))

Note

I am not sure whether we have to setup ENV["PYTHON"] = "/home/weiqi/anaconda3/envs/conda_jl/bin/python". To me, I don't want to install rmg with my base env since rmg depends on specific version of PyTorch and TensorFlow.

Adjoint Sensitivities for Multiple Domains

When I attempted to write adjoint sensitiviites for multiple domains I ran into #84 and another distinct issue with ConstantTPDomain. I had difficulty decoupling these issues so I think it's best to wait to resolve this until #84 is dealt with. The work I started on this is available on the multidomainsens branch.

Error in Reverse Mode AD

Code

using DifferentialEquations
using ReactionMechanismSimulator
using Flux, DiffEqFlux
using Plots

file_path = "../mech/superminimal.rms";
phaseDict = readinput(file_path); 

spcs = phaseDict["phase"]["Species"]; 
rxns = phaseDict["phase"]["Reactions"];

#######################    INPUT     #######################
T0 = 1400;     #[K]
P0 = 1.013e+5; #[Pa]
V0 = 8.314 * T0 / P0;  # [m^3] # Comparison with chemkin
H2 = 0.67;     #[mol]
O2 = 0.33;     #[mol]
N0 = H2 + O2;

# Define the phase
ig = IdealGas(spcs,rxns,name="phase");
ic = Dict(["T"=>T0, "P"=>P0, "H2"=>H2,"O2"=>O2]); 
domain, y0, p_true = ConstantPDomain(phase=ig,initialconds=ic);

p_pred = deepcopy(p_true);
ns = length(domain.phase.species)

p_pred[ns+1:end] .= 1
p_pred[ns+2] = 0.9

@show p_true[ns+2], p_pred[ns+2]

# solve to get data
t_end = 2.5e-3; #[s]
t = range(0, t_end, length=100)

react = Reactor(domain,y0,(0.0, t_end); p=p_pred);
solver = DifferentialEquations.CVODE_BDF();

abstol = 1e-6;
reltol = 1e-3;

y_true = solve(react.ode, solver, p=p_true, saveat=t, abstol=abstol, reltol=reltol);
y_pred = solve(react.ode, solver, p=p_pred, saveat=t, abstol=abstol, reltol=reltol);

h = plot(layout=(1,2), size=(600, 240))
plot!(t, y_true[end,:], subplot=1, line=(:solid), ylim=(1000, 3500), linecolor=1)
plot!(t, y_pred[end,:], subplot=1, line=(:dash),  ylim=(1000, 3500), linecolor=1)
plot!(t, y_true[1:end-1,:]', subplot=2, line=(:solid), ylim=(0, 1))
plot!(t, y_pred[1:end-1,:]', subplot=2, line=(:dash), ylim=(0,1))
display(h)

function loss()
    y_pred = solve(react.ode, solver, p=p_pred, saveat=t, abstol=abstol, reltol=reltol)
    sum((y_pred .- y_true).^2)
end

gs = gradient(() -> loss(), Flux.params(p_pred))

Error

Tried to add a tstop that is behind the current time. This is strictly forbidden

Stacktrace:
[1] error(::String) at ./error.jl:33
[2] add_tstop! at /home/weiqi/.julia/packages/Sundials/xAoTr/src/common_interface/integrator_utils.jl:133 [inlined]
[3] (::DiffEqCallbacks.var"#34#39"{DiffEqSensitivity.var"#94#96"{Base.RefValue{Int64},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}},DiffEqSensitivity.var"#95#97"{DiffEqSensitivity.var"#df#134"

Julia st

Status ~/.julia/environments/v1.4/Project.toml
[c52e3926] Atom v0.12.21
[aae7a2af] DiffEqFlux v1.22.0
[41bf760c] DiffEqSensitivity v6.31.5
[0c46a032] DifferentialEquations v6.15.0
[587475ba] Flux v0.11.1
[f6369f11] ForwardDiff v0.10.12
[e5e0dc1b] Juno v0.8.3
[429524aa] Optim v1.1.0
[1dea7af3] OrdinaryDiffEq v5.42.7
[91a5bcdd] Plots v1.6.3
[d330b81b] PyPlot v2.9.0
[c2d78dd2] ReactionMechanismSimulator v0.3.0 [~/.julia/dev/ReactionMechanismSimulator]
[c3572dad] Sundials v4.3.0
[856ac37a] UrlDownload v0.3.0
[e88e6eb3] Zygote v0.5.6
[8dfed614] Test

Register v0.3.1

@JuliaRegistrator register

Jupyter notebook kernel of Julia crashed

Hi,
When I was running Julia scripts (examples) with Jupyter, the kernel crashed or closed the connection before I want to run it. I don't know if it's the problem with the version I use now. May I check the version you are using? Do you have any experience with such an issue? By the way, I am using the Ubuntu subsystem on windows.
Looking forward to your reply!

Support Cantera Style YAML

RMS's current input .rms files are very convenient for reading in complex objects, but aren't as easy to manipulate by hand as Chemkin files. Ideally we would want to standardize to Cantera style .yml files that much like the .rms files solve many of issues with the Chemkin file format, but retain a bit more human readability, particularly in terms of the reactions in the file than the .rms files.

Clipping and normalization of mass fraction

I have a question regarding the clipping of mass fraction. I am wondering whether rms clip negative mass fraction, which happens in the large mechanism. In Cantera, the negative ass fraction is left as it is since clipping will affect the numerical Jacobian and make the solver super slow. Similarly, does rms normalize the mass fraction to unity?

It will be great if someone can point me the relevant source code?

FluxDiagram DimensionMismatch

Hi guys, hope you all are doing well!

I'm an RMG user but have just started using RMS. As a starter example, I was trying to do the same as Matt Johnson for the Propane Oxidation case. And everything went smoothly, but the getfluxdiagram function. I'm getting this error (the txt attached is showing the full out message):
JULIA: DimensionMismatch("arrays could not be broadcast to a common size; got a dimension with lengths 63 and 1112")

As I don't know how to figure out this, I decided to make this question here. What should I be looking for in order to solve the issue?
ErrorFluxDiagram.txt

Rate and thermo parameter fitting

When converting experimental data into rate coefficient estimates it's often very important to be able to fit a few parameters to the data. This is often very tricky to do properly for more than one parameter so it would be nice to be able to use JuMP in combination with a global optimizer such as: https://github.com/PSORLab/EAGO.jl.

Sparse Automatic Differentiation for Jacobians

This is a continues some discussion from #28. Most reactors in RMS can be formulated in a sparse format, but have dense columns and rows for the thermodynamic variables (volume, temperature, etc.). By using dense Reverse Mode automatic differentiation with ReverseDiff, Tracker or Zygote we should be able evaluate the dense rows of the jacobian and then use SparseDiffTools and Sparse Forward Mode Auto Diff to evaluate the rest of the jacobian. This should be much faster than finite differences or typical automatic differentiation and the improvement should scale with mechanism size. There was some discussion of an automatic tool for this: JuliaDiff/SparseDiffTools.jl#112, but it should be relatively easy to implement ourselves without that. Need to resolve #54 mostly first.

Do I need to learn RMG in order to run the simulation?

I have no experience with RMG. If I only want to simulate ignition process from a Chemkin or Cantera mechanism. Do I need to learn any knowledge about RMG? Or I can just read the Chemkin mechanism using the parse module?

Using ModelingToolkit.jl to get Optimized Symbolic Jacobians

ModelingToolkit.jl has the capability to take some julia derivative functions, extract the symbolic equations and symbolically generate an optimized and potentially multi-threaded version of the function. My guess is that given the size of the systems of equations we manipulate the symbolic manipulations are going to be time consuming enough it will be too clunky to use in most cases. However, if one is running a long enough calculation or a ton of calculations on the same system (uncertainty analysis or sensitivity analysis) the difference may be worth it.

We first need to explore if modeltoolkitize works on our derivative function, if not what it would take to make it work and second how long do the symbolic optimizations take and how much speed up does RMS get out of the optimizations.

If we get it working effectively the implementation itself should be relatively simple.

See: https://www.youtube.com/watch?v=UNkXNZZ3hSw and https://github.com/SciML/ModelingToolkit.jl

Increment version to 0.2.0

@JuliaRegistrator register()

TagBot trigger issue

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Register v0.3.0

@JuliaRegistrator register

Coverage dependent kinetics

Hi, it would be cool to be able to use coverage dependent kinetics in RMS.

The coverage dependent documentation for cantera can be found in the surface reactions section here for how it affects surface arrhenius, and the parameters are:

coverage-dependencies

    A mapping of species names to coverage dependence parameters, where these parameters are contained in a mapping with the fields:

    a
        Coefficient for exponential dependence on the coverage
    m
        Power-law exponent of coverage dependence
    E
        Activation energy dependence on coverage

and an example:

equation: 2 H(s) => H2 + 2 Pt(s)
rate-constant: {A: 3.7e21 cm^2/mol/s, b: 0, Ea: 67400 J/mol}
coverage-dependencies: {H(s): {a: 0, m: 0, E: -6000 J/mol}}

both of which can be found here

and in chemkin as an additional line under the reaction line, starting with COV /:

H2+X+X=>HX+HX             4.600E-02  0.000      0.000
    STICK
    COV / X                               0.000E+00  -1.000     -0.000 /

in the order of a, m, and E.

Analytic Jacobians

RMS currently uses default finite differences for domains with constant rate coefficients and forward mode automatic differentiation for domains where the rate coefficients are recomputed each evaluation. For individual domains it should be much faster to use an analytic jacobian which can be done with only a single evaluation of the rate coefficients and a single loop through the reactions/rxnarray. With the exception of the partials with respect to thermodynamic variables (particularly temperature whose column of the jacobian can be done as a single forward automatic differentiation evaluation instead of analytically) it should be relatively simple to derive the equations and it should be easy to test them against the current jacobian.

Shouldn't be done for domains still being reformulated as a part of #54.

Stoichiometric Reactions

Currently RMS doesn't support reactions that can't be represented in elementary form or with more than 4 reactants or products. I got an email asking about support for specifying stochiometric coefficients.

I think I properly laid out what needs done for the derivative functions:

In order to simulate non-elementary reactions (non-integer stoichiometric coefficients) the simplest thing to do I think is to write a new class of AbstractReaction, probably something like StoichiometricReaction in Reaction.jl with the same attributes as ElementaryReaction plus the stoichiometric coefficients. When the phase objects are constructed these reactions need to be separated out before processing and stored in a separate attribute on each phase object in Phase.jl. Then add a function analogous to addreactionratecontributions! in Reactor.jl that takes the list of stoichiometric reactions instead of the rarray (which is a list of the indices of reactants (first 3) and products(last 3) for each elementary reaction), it should end up looking something like fR = cs[rxn.reactantinds[1]]^rxn.reactantstoich[1]*cs[rxn.reactantinds[2]]^rxn.reactantstoich[2] and so on. Then a call to that function needs to be added within the two dydtreactor! functions next to the addreactionratecontributions! functions in Reactor.jl you can get the phase object from domain.phase.

But changes also need made to the analytic jacobians and downstream processing (Simulation.jl). I think the downstream processing should be relatively straightforward, but @hwpang what do you think it would take for the analytic jacobians to support stochiometric reactions?

Further Optimization of Rate Coefficient Calculations

#31 made a lot of improvements, but I believe there's still some performance improvements possible independent of better differentiation algorithms, perhaps related to how I handled broadcasting. It could use a new set of eyes. See the Julia performance tips: https://docs.julialang.org/en/v1/manual/performance-tips/index.html. This package is handy: https://github.com/kimikage/ProfileSVG.jl.

Getting Species Names off Fluxdiagrams

I would be convenient if name of each species in a flux diagram could be easily obtained so that a user can easily call up rate of production graphs and mole fraction plots etc. Currently if you're working off a fluxdiagram and you don't know and can't guess the name the simplest way I've found is to start from a species you know and follow the rate of production diagrams until you get to it. I see two primary solutions to this

Embed the species name in the structure image
If this could be done in pydot this might be the easiest route, but I'm not aware of a way to do it so simply. The name could be made part of the molecular structure image, but it's tricky to do this in a way that will keep both the structure and the name properly visible.
Hovertext for the structure image
So it's simple to add a tooltip in pydot node.set_tooltip(species.name). However this won't work with a .png. It should be possible embedding svg or html instead, but it would involve changes to how we display flux diagrams and may involve a modification to pyrms to maintain python compatibility.

Multi-domain simulations

So far RMS has been limited to simulations involving a single reaction domain. This precludes systems involving more than one reactor or more than one phase. Adding this feature should allow us to write interfaces between domains that would allow simulation of kinetics occuring in multi-phase reactors such as gas-liquid or gas-catalyst and also systems of reactors.

v0.4.0 Release

@JuliaRegistrator register

Sensitivity to Activation Energies

Some users are as interested in sensitivity to activation energies. It's relatively easy for constant rate coefficient domains to convert sensitivities to a rate constant to sensitivities to the activation energy (dLn(N_i)/dLn(k)dLn(k)/dE where dLn(k)/dE is constant). However for simulations with variable temperature this requires us to approximately double the parameters. It's worth noting this can be formulated as a simple perturbation on every rate kexp(-dE/(R*T)) which makes this not too difficult to implement. However, this would likely need implemented with some system that allows you to specify if these sensitivities are calculated or not see #58, although this wouldn't necessarily need implemented with #58.

Speed up Adjoint Sensitivities

The current implementation of adjoint sensitivities is functional, but very poorly optimized. Currently it just evaluates the full derivative function for the domain and then extracts the one derivative it needs from that in the function g. We then calculate gradients dgdu and dgdp using forward differentiation.

In this scheme in each evaluation of g we evaluate many reactions that are irrelevant to the calculation of the derivative of the species of interest. Ideally we should determine the reactions involving the species of interest and only evaluate those reactions. Additionally it should be much faster to calculate dgdu and dgdp using reverse mode differentiation with ReverseDiff, Tracker or Zygote than forward mode differentiation.

It should also be possible to do even better than the above for specific domains by using analytic dgdu and dgdp.

What need to do if we want to remove dependence of Python?

I am thinking of removing Python dependence to make the installation more smooth. I am trying to look into the code to figure out what need to do and what's the consequence.

Is there any slack channels at MIT to discuss RMS development?

Hi, Is there any slack channel where you guys discuss rms development? Is it possible to join it? I am from MechE.

Does RMS support sensitivity analysis?

For now, does rms support sensitivity analysis for zero-D simulations? What kind of sensitivity analysis algorithm it takes for now?

Interface for First Order Loss Outlet

In beam experiments often the delay between species creation and diffusion to the detector is modeled as a constant TP domain with a first order loss outlet. The first order loss outlet molar flow rate is some constant loss rate k times the moles in the constant TP reactor. Some of our users have requested this feature.

Refomulate Domains to Improve Sparsity

Many of the domains in RMS aren't formulated in a form that makes the Jacobian sparse because of coupling between the dN_i/dt and V = RT/P sum_i(N_i) and dN_i/dt and P = RT/V*sum_i(N_i). This should be fixed for ConstantTPDomain in #53, but ConstantVDomain, ParameterizedVDomain, ParameterizedTPDomain, ConstantPDomain and ParameterizedPDomain still have dense Jacobians. Integrating volume and pressure (when not constant) in these equations following the template from #53 should make the other domains sparse as well. This should be relatively simple to implement. This should mostly just involve adjustments in Domain.jl, but getT, getV, getP and getC methods in Simulation.jl may need tweaked for these domains.

No method matching species error

While trying to run the simulation for Steam methane reforming (examples/rmg/catalysis/methane_steam) example of RMG software using RMS in Jupyter notebook (Julia 1.6.0), the following error always pops up for the code;

Code:
phaseDict = readinput("rms/chem76.rms")

Error:
MethodError: no method matching Species(; index=23, name="site", adjlist="1 X u0 p0 c0\n\n", radicalelectrons=0, thermo=NASA{EmptyThermoUncertainty}
polys: Array{NASApolynomial}((2,))
unc: EmptyThermoUncertainty EmptyThermoUncertainty()
, smiles="[Pt]")

I have attached the word document of the rms file. Can someone guide me?
Chem76 file:
chem76.docx

Direct Decoupled Method for Sensitivities

Theoretically it wouldn't be too difficult to implement the method Chemkin uses for sensitivities. Fundamentally in this method you run the simulation and then you discretize the sensitivity equations into finite differences between each time point. These can be solved sequentially time step to time step and the sensitivity to each parameter is independent so it's simply a matter of posing the set of equations for sensitivity to a single parameter for a single time step, solving the equations and then reapplying that for each parameter and time step. Parallelization would probably be handy. Some care probably needed to let users decide what sensitivities to save. See https://aip.scitation.org/doi/pdf/10.1063/1.447938

Test issue integration

getconcentrationsensitivities not working for ConstantPDomain

I'm trying to add forward SA adapters for T3. The code below works fine for ConstantVDomain and ConstantTPDomain, but gives different errors for ConstantPDomain depending on how abstol is defined as shown below. Let me know if there is a better method to obtain SA coefficients.

from diffeqpy import de
from pyrms import rms

phaseDict = rms.readinput("/home/gridsan/kspieker/RMG/ReactionMechanismSimulator.jl/src/testing/superminimal.rms")
spcs = phaseDict["phase"]["Species"]
rxns = phaseDict["phase"]["Reactions"]
ig = rms.IdealGas(spcs,rxns,name="gas")

initialconds = {"T":1000.0,"P":1e5,"H2":0.67,"O2":0.33}
domain,y0,p = rms.ConstantPDomain(phase=ig,initialconds=initialconds)
solver = de.CVODE_BDF()

react = rms.Reactor(domain, y0, (0.0, 150.1), forwardsensitivities=True, p=p)

# 1) try SA with scalars
sol = de.solve(react.ode, solver, abstol=1e-16, reltol=1e-8)

# 2) try SA with simulation variables and SA variables having different absolute tolerances
atol = [1e-16]*domain.indexes[2]    # set atol for the simulation
total_variables = domain.indexes[2] + len(p)*domain.indexes[2]
atol.extend([1e-6]*(total_variables-domain.indexes[2]))  # set atol for the SA 
sol = de.solve(react.ode, solver, abstol=atol, reltol=1e-6)

bsol = rms.Simulation(sol,domain)

rms.getconcentrationsensitivity(bsol, 'OH', 'H2', 0.0001)

For 1) the error is

RuntimeError: Julia exception: type StandardODEProblem has no field sensealg
Stacktrace:
 [1] getproperty(::DiffEqBase.StandardODEProblem, ::Symbol) at ./Base.jl:33
 [2] extract_local_sensitivities(::DiffEqBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,DiffEqBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},DiffEqBase.ODEFunction{true,ReactionMechanismSimulator.var"#dydt#405"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,ReactionMechanismSimulator.var"#jacy!#406"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,ReactionMechanismSimulator.var"#jacp!#407"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},DiffEqBase.StandardODEProblem},Sundials.CVODE_BDF{:Newton,:Dense,Nothing,Nothing},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Array{Float64,1},1},Array{Array{Float64,1},1}},DiffEqBase.DEStats}, ::Float64, ::Val{false}) at /home/gridsan/kspieker/.conda/envs/t3_env/share/julia/site/packages/DiffEqSensitivity/CtcvA/src/local_sensitivity/forward_sensitivity.jl:191 (repeats 2 times)
 [3] getconcentrationsensitivity(::ReactionMechanismSimulator.Simulation{DiffEqBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,DiffEqBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},DiffEqBase.ODEFunction{true,ReactionMechanismSimulator.var"#dydt#405"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,ReactionMechanismSimulator.var"#jacy!#406"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,ReactionMechanismSimulator.var"#jacp!#407"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},DiffEqBase.StandardODEProblem},Sundials.CVODE_BDF{:Newton,:Dense,Nothing,Nothing},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Array{Float64,1},1},Array{Array{Float64,1},1}},DiffEqBase.DEStats},ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{String,1},ReactionMechanismSimulator.var"#F#411"{DiffEqBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,DiffEqBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},DiffEqBase.ODEFunction{true,ReactionMechanismSimulator.var"#dydt#405"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,ReactionMechanismSimulator.var"#jacy!#406"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,ReactionMechanismSimulator.var"#jacp!#407"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},DiffEqBase.StandardODEProblem},Sundials.CVODE_BDF{:Newton,:Dense,Nothing,Nothing},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Array{Float64,1},1},Array{Array{Float64,1},1}},DiffEqBase.DEStats},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Float64,2},Array{Float64,2}}},Array{Float64,2}}, ::String, ::String, ::Float64) at /home/gridsan/kspieker/.conda/envs/t3_env/share/julia/site/packages/ReactionMechanismSimulator/PV6pn/src/Simulation.jl:183

For 2) the error is

RuntimeError: Julia exception: type ConstantPDomain has no field T
Stacktrace:
 [1] getproperty(::ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}}, ::Symbol) at ./Base.jl:33
 [2] getconcentrationsensitivity(::ReactionMechanismSimulator.Simulation{DiffEqBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,DiffEqBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},DiffEqSensitivity.ODEForwardSensitivityFunction{true,DiffEqBase.ODEFunction{true,ReactionMechanismSimulator.var"#dydt#405"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,ReactionMechanismSimulator.var"#jacy!#406"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,ReactionMechanismSimulator.var"#jacp!#407"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing},Nothing,Nothing,ReactionMechanismSimulator.var"#jacy!#406"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing,ReactionMechanismSimulator.var"#jacp!#407"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing,DiffEqBase.UJacobianWrapper{DiffEqBase.ODEFunction{true,ReactionMechanismSimulator.var"#dydt#405"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,ReactionMechanismSimulator.var"#jacy!#406"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,ReactionMechanismSimulator.var"#jacp!#407"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing},Float64,Array{Float64,1}},DiffEqBase.ParamJacobianWrapper{DiffEqBase.ODEFunction{true,ReactionMechanismSimulator.var"#dydt#405"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,ReactionMechanismSimulator.var"#jacy!#406"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,ReactionMechanismSimulator.var"#jacp!#407"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing},Float64,Array{Float64,1}},Tuple{Array{ForwardDiff.Dual{typeof(DiffEqSensitivity.jacobianvec!),Float64,1},1},Array{ForwardDiff.Dual{typeof(DiffEqSensitivity.jacobianvec!),Float64,1},1}},Nothing,DiffEqSensitivity.ForwardSensitivity{0,true,Val{:central}},Array{Float64,1},Nothing,Array{Float64,2},LinearAlgebra.UniformScaling{Bool},Nothing},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},DiffEqSensitivity.ODEForwardSensitivityProblem{true,DiffEqSensitivity.ForwardSensitivity{0,true,Val{:central}}}},Sundials.CVODE_BDF{:Newton,:Dense,Nothing,Nothing},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Array{Float64,1},1},Array{Array{Float64,1},1}},DiffEqBase.DEStats},ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{String,1},ReactionMechanismSimulator.var"#F#411"{DiffEqBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,DiffEqBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},DiffEqSensitivity.ODEForwardSensitivityFunction{true,DiffEqBase.ODEFunction{true,ReactionMechanismSimulator.var"#dydt#405"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,ReactionMechanismSimulator.var"#jacy!#406"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,ReactionMechanismSimulator.var"#jacp!#407"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing},Nothing,Nothing,ReactionMechanismSimulator.var"#jacy!#406"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing,ReactionMechanismSimulator.var"#jacp!#407"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing,DiffEqBase.UJacobianWrapper{DiffEqBase.ODEFunction{true,ReactionMechanismSimulator.var"#dydt#405"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,ReactionMechanismSimulator.var"#jacy!#406"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,ReactionMechanismSimulator.var"#jacp!#407"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing},Float64,Array{Float64,1}},DiffEqBase.ParamJacobianWrapper{DiffEqBase.ODEFunction{true,ReactionMechanismSimulator.var"#dydt#405"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,ReactionMechanismSimulator.var"#jacy!#406"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,ReactionMechanismSimulator.var"#jacp!#407"{ReactionMechanismSimulator.ConstantPDomain{ReactionMechanismSimulator.IdealGas{Tuple{},SparseArrays.SparseMatrixCSC{Float64,Int64}},Int64,Float64,Float64,StaticArrays.SArray{Tuple{3},Int64,1,3}},Array{Any,1}},Nothing,Nothing},Float64,Array{Float64,1}},Tuple{Array{ForwardDiff.Dual{typeof(DiffEqSensitivity.jacobianvec!),Float64,1},1},Array{ForwardDiff.Dual{typeof(DiffEqSensitivity.jacobianvec!),Float64,1},1}},Nothing,DiffEqSensitivity.ForwardSensitivity{0,true,Val{:central}},Array{Float64,1},Nothing,Array{Float64,2},LinearAlgebra.UniformScaling{Bool},Nothing},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},DiffEqSensitivity.ODEForwardSensitivityProblem{true,DiffEqSensitivity.ForwardSensitivity{0,true,Val{:central}}}},Sundials.CVODE_BDF{:Newton,:Dense,Nothing,Nothing},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Array{Float64,1},1},Array{Array{Float64,1},1}},DiffEqBase.DEStats},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Float64,2},Array{Float64,2}}},Array{Float64,2}}, ::String, ::String, ::Float64) at /home/gridsan/kspieker/.conda/envs/t3_env/share/julia/site/packages/ReactionMechanismSimulator/PV6pn/src/Simulation.jl:188

Forward Sensitivity Analysis Optimization

Forward sensitivities tend to give solver errors if they're fed analytic or forward diff jacobians, but work fine with jacobians not specified. I plan to make that adjustment shortly. The mode forward sensitivities operate in when jacobians aren't specified is discussed here: https://diffeq.sciml.ai/stable/extras/sensitivity_math/. I'm unsure if using the analytic jacobians should be faster than that mode currently, but once we have fast parameter jacobians I would think it should be faster to use the analytic jacobians.

Vectorize Diffusion Limited Rate Calculations

Currently unlike normal rate calculations diffusion limited rate calculations are done in a loop rather than in a vectorized fashion, this should speed up liquid simulations.

release v0.2.1

@JuliaRegistrator register

ARC Directory Confusion

I keep getting errors for every TS like the below. ARC seems to expect the TS files to be in the Species directory, but it puts them in the separate TSs directory. So far copying over the folders from the TSs directory to the Species folder every time this happens seems to get around this.

Traceback (most recent call last):
  File "/Users/mattjohnson/RMGCODE/ARC/arc/job/ssh.py", line 196, in download_file
    localpath=local_file_path)
  File "/opt/anaconda3/envs/arc_env/lib/python3.7/site-packages/paramiko/sftp_client.py", line 801, in get
    with open(localpath, "wb") as fl:
FileNotFoundError: [Errno 2] No such file or directory: '/Users/mattjohnson/RMGCODE/ARC/Projects/explorer2/calcs/Species/TS2/composite_a3412/output.out'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "../../ARC.py", line 69, in <module>
    main()
  File "../../ARC.py", line 65, in main
    arc_object.execute()
  File "/Users/mattjohnson/RMGCODE/ARC/arc/main.py", line 564, in execute
    fine_only=self.fine_only,
  File "/Users/mattjohnson/RMGCODE/ARC/arc/scheduler.py", line 461, in __init__
    self.schedule_jobs()
  File "/Users/mattjohnson/RMGCODE/ARC/arc/scheduler.py", line 555, in schedule_jobs
    successful_server_termination = self.end_job(job=job, label=label, job_name=job_name)
  File "/Users/mattjohnson/RMGCODE/ARC/arc/scheduler.py", line 836, in end_job
    job.determine_job_status()  # also downloads output file
  File "/Users/mattjohnson/RMGCODE/ARC/arc/job/job.py", line 1348, in determine_job_status
    self._check_job_ess_status()  # populates self.job_status[1], and downloads the output file
  File "/Users/mattjohnson/RMGCODE/ARC/arc/job/job.py", line 1442, in _check_job_ess_status
    self._download_output_file()  # also downloads the check file and orbital file if exist
  File "/Users/mattjohnson/RMGCODE/ARC/arc/job/job.py", line 1238, in _download_output_file
    ssh.download_file(remote_file_path=remote_file_path, local_file_path=self.local_path_to_output_file)
  File "/Users/mattjohnson/RMGCODE/ARC/arc/job/ssh.py", line 200, in download_file
    raise ServerError(f'Could not download file {remote_file_path} from {self.server}. ')
arc.exceptions.ServerError: Could not download file runs/ARC_Projects/explorer2/TS2/composite_a3412/input.log from c3ddb01.

Forward Sensitivity Analysis Flexibility

Currently forward sensitivity analysis can only be run on all of the thermochemistry and all of the rates. However it can be useful to run forward sensitivity on a specified set of parameters instead of all of them. This is mostly a logistical matter, the users need a way to input what species and rates they want sensitivities for and RMS needs to track and handle this internally when it processes the parameters in Domain.jl. A little bit of extra care is needed to make sure this won't slow things that are currently fast down particularly in the constant rate coefficient simulations...but at worst that should be able to be handled pretty well with an if statement.

`getfluxdiagram` throws PyError

I got the following error message after running getfluxdiagram(bsol,0.5, centralspecieslist=["OH(D)"],radius=5) in the ConstantTPH2Combustion.ipynb file

PyError ($(Expr(:escape, :(ccall(#= /home/ampayne/.julia/packages/PyCall/0jMpb/src/pyfncall.jl:44 =# @pysym(:PyObject_Call), PyPtr, (PyPtr, PyPtr, PyPtr), o, pyargsptr, kw))))) <type 'exceptions.Exception'>
Exception('"dot" not found in path.',)
  File "build/bdist.linux-x86_64/egg/pydot.py", line 1675, in <lambda>
    self.create(format=f, prog=prog))
  File "build/bdist.linux-x86_64/egg/pydot.py", line 1876, in create
    prog=prog))


Stacktrace:
 [1] pyerr_check at /home/ampayne/.julia/packages/PyCall/0jMpb/src/exception.jl:60 [inlined]
 [2] pyerr_check at /home/ampayne/.julia/packages/PyCall/0jMpb/src/exception.jl:64 [inlined]
 [3] macro expansion at /home/ampayne/.julia/packages/PyCall/0jMpb/src/exception.jl:84 [inlined]
 [4] __pycall!(::PyCall.PyObject, ::Ptr{PyCall.PyObject_struct}, ::PyCall.PyObject, ::PyCall.PyObject) at /home/ampayne/.julia/packages/PyCall/0jMpb/src/pyfncall.jl:44
 [5] _pycall!(::PyCall.PyObject, ::PyCall.PyObject, ::Tuple{}, ::Int64, ::PyCall.PyObject) at /home/ampayne/.julia/packages/PyCall/0jMpb/src/pyfncall.jl:22
 [6] _pycall!(::PyCall.PyObject, ::PyCall.PyObject, ::Tuple{}, ::Base.Iterators.Pairs{Symbol,String,Tuple{Symbol},NamedTuple{(:prog,),Tuple{String}}}) at /home/ampayne/.julia/packages/PyCall/0jMpb/src/pyfncall.jl:11
 [7] #call#89 at /home/ampayne/.julia/packages/PyCall/0jMpb/src/pyfncall.jl:89 [inlined]
 [8] (::getfield(PyCall, Symbol("#kw#PyObject")))(::NamedTuple{(:prog,),Tuple{String}}, ::PyCall.PyObject) at ./none:0
 [9] #makefluxdiagrams#183(::Array{String,1}, ::Bool, ::Int64, ::Int64, ::Float64, ::Float64, ::Float64, ::Float64, ::Int64, ::Int64, ::String, ::typeof(makefluxdiagrams), ::Simulation{ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Array{Any,1},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},false,Nothing,ODEFunction{false,getfield(RMS, Symbol("#dydt#177")){ConstantTPDomain{IdealGas{ElementaryReaction},Int64,Float64,Float64,Union{},StaticArrays.SArray{Tuple{2},Int64,1,2}}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem},CVODE_BDF{:Newton,:Dense},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Array{Float64,1},1},Array{Array{Float64,1},1}}},ConstantTPDomain{IdealGas{ElementaryReaction},Int64,Float64,Float64,Union{},StaticArrays.SArray{Tuple{2},Int64,1,2}},Array{String,1},getfield(RMS, Symbol("#F#181")){ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Array{Any,1},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},false,Nothing,ODEFunction{false,getfield(RMS, Symbol("#dydt#177")){ConstantTPDomain{IdealGas{ElementaryReaction},Int64,Float64,Float64,Union{},StaticArrays.SArray{Tuple{2},Int64,1,2}}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem},CVODE_BDF{:Newton,:Dense},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Array{Float64,1},1},Array{Array{Float64,1},1}}},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Float64,2},Array{Float64,2}}},Array{Float64,2}}, ::Array{Float64,1}) at /home/ampayne/.julia/packages/RMS/JnBwS/src/fluxdiagrams.jl:241
 [10] #makefluxdiagrams at ./none:0 [inlined]
 [11] #getfluxdiagram#182(::Array{String,1}, ::Bool, ::Int64, ::Int64, ::Float64, ::Float64, ::Float64, ::Float64, ::Int64, ::Int64, ::String, ::typeof(getfluxdiagram), ::Simulation{ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Array{Any,1},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},false,Nothing,ODEFunction{false,getfield(RMS, Symbol("#dydt#177")){ConstantTPDomain{IdealGas{ElementaryReaction},Int64,Float64,Float64,Union{},StaticArrays.SArray{Tuple{2},Int64,1,2}}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem},CVODE_BDF{:Newton,:Dense},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Array{Float64,1},1},Array{Array{Float64,1},1}}},ConstantTPDomain{IdealGas{ElementaryReaction},Int64,Float64,Float64,Union{},StaticArrays.SArray{Tuple{2},Int64,1,2}},Array{String,1},getfield(RMS, Symbol("#F#181")){ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Array{Any,1},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},false,Nothing,ODEFunction{false,getfield(RMS, Symbol("#dydt#177")){ConstantTPDomain{IdealGas{ElementaryReaction},Int64,Float64,Float64,Union{},StaticArrays.SArray{Tuple{2},Int64,1,2}}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem},CVODE_BDF{:Newton,:Dense},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Array{Float64,1},1},Array{Array{Float64,1},1}}},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Float64,2},Array{Float64,2}}},Array{Float64,2}}, ::Float64) at /home/ampayne/.julia/packages/RMS/JnBwS/src/fluxdiagrams.jl:71
 [12] (::getfield(RMS, Symbol("#kw##getfluxdiagram")))(::NamedTuple{(:centralspecieslist, :radius),Tuple{Array{String,1},Int64}}, ::typeof(getfluxdiagram), ::Simulation{ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Array{Any,1},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},false,Nothing,ODEFunction{false,getfield(RMS, Symbol("#dydt#177")){ConstantTPDomain{IdealGas{ElementaryReaction},Int64,Float64,Float64,Union{},StaticArrays.SArray{Tuple{2},Int64,1,2}}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem},CVODE_BDF{:Newton,:Dense},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Array{Float64,1},1},Array{Array{Float64,1},1}}},ConstantTPDomain{IdealGas{ElementaryReaction},Int64,Float64,Float64,Union{},StaticArrays.SArray{Tuple{2},Int64,1,2}},Array{String,1},getfield(RMS, Symbol("#F#181")){ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Array{Any,1},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},false,Nothing,ODEFunction{false,getfield(RMS, Symbol("#dydt#177")){ConstantTPDomain{IdealGas{ElementaryReaction},Int64,Float64,Float64,Union{},StaticArrays.SArray{Tuple{2},Int64,1,2}}},LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem},CVODE_BDF{:Newton,:Dense},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Array{Float64,1},1},Array{Array{Float64,1},1}}},DiffEqBase.HermiteInterpolation{Array{Float64,1},Array{Float64,2},Array{Float64,2}}},Array{Float64,2}}, ::Float64) at ./none:0
 [13] top-level scope at In[18]:1

Multithreading in RMS

I'm curious whether we can get some extra speed up by multithreading certain tasks, particularly in rate coefficient/equilibrium constant calculations, or in constant rate coefficient domains adding the reaction rate contributions, or maybe in analytic Jacobian calculations. See https://docs.julialang.org/en/v1/base/multi-threading/.

using DifferentialEquations does not pre-compile in jupyter notebook

I tried going through some of the examples in the iJulia folder in RMS. Weirdly, running the first cell with using DifferentialEquations gives the error based below. Essentially, it failes to precompile DifferentialEquations, which I find odd since running using DifferentialEquations in terminal works just fine. This is running on a linux machine with only one copy of the LTS Julia v1.0.5

Running using Sundials instead allows me to access the same CVODE_BDF() solver and ultimately allows me to run the notebooks. I just wanted to document this here in case we find a solution to this issue in the future.

Info: Precompiling DifferentialEquations [0c46a032-eb83-5123-abaf-570d42b7fbaa]
└ @ Base loading.jl:1192
ERROR: LoadError: ArgumentError: Package NLSolversBase does not have DiffEqDiffTools in its dependencies:
- If you have NLSolversBase checked out for development and have
  added DiffEqDiffTools as a dependency but haven't updated your primary
  environment's manifest file, try `Pkg.resolve()`.
- Otherwise you may need to report an issue with NLSolversBase
Stacktrace:
 [1] require(::Module, ::Symbol) at ./loading.jl:836
 [2] include at ./boot.jl:317 [inlined]
 [3] include_relative(::Module, ::String) at ./loading.jl:1044
 [4] include(::Module, ::String) at ./sysimg.jl:29
 [5] top-level scope at none:2
 [6] eval at ./boot.jl:319 [inlined]
 [7] eval(::Expr) at ./client.jl:393
 [8] top-level scope at ./none:3
in expression starting at /home/kspieker/.julia/packages/NLSolversBase/NsXIC/src/NLSolversBase.jl:5
ERROR: LoadError: Failed to precompile NLSolversBase [d41bc354-129a-5804-8e4c-c37616107c6c] to /home/kspieker/.julia/compiled/v1.0/NLSolversBase/NEDD6.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1203
 [3] _require(::Base.PkgId) at ./loading.jl:960
 [4] require(::Base.PkgId) at ./loading.jl:858
 [5] require(::Module, ::Symbol) at ./loading.jl:853
 [6] include at ./boot.jl:317 [inlined]
 [7] include_relative(::Module, ::String) at ./loading.jl:1044
 [8] include(::Module, ::String) at ./sysimg.jl:29
 [9] top-level scope at none:2
 [10] eval at ./boot.jl:319 [inlined]
 [11] eval(::Expr) at ./client.jl:393
 [12] top-level scope at ./none:3
in expression starting at /home/kspieker/.julia/packages/NLsolve/ZBTu4/src/NLsolve.jl:6
ERROR: LoadError: Failed to precompile NLsolve [2774e3e8-f4cf-5e23-947b-6d7e65073b56] to /home/kspieker/.julia/compiled/v1.0/NLsolve/KFCNP.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1203
 [3] _require(::Base.PkgId) at ./loading.jl:960
 [4] require(::Base.PkgId) at ./loading.jl:858
 [5] require(::Module, ::Symbol) at ./loading.jl:853
 [6] include at ./boot.jl:317 [inlined]
 [7] include_relative(::Module, ::String) at ./loading.jl:1044
 [8] include(::Module, ::String) at ./sysimg.jl:29
 [9] top-level scope at none:2
 [10] eval at ./boot.jl:319 [inlined]
 [11] eval(::Expr) at ./client.jl:393
 [12] top-level scope at ./none:3
in expression starting at /home/kspieker/.julia/packages/SteadyStateDiffEq/q0UMK/src/SteadyStateDiffEq.jl:6
ERROR: LoadError: Failed to precompile SteadyStateDiffEq [9672c7b4-1e72-59bd-8a11-6ac3964bc41f] to /home/kspieker/.julia/compiled/v1.0/SteadyStateDiffEq/lsCSw.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1203
 [3] _require(::Base.PkgId) at ./loading.jl:960
 [4] require(::Base.PkgId) at ./loading.jl:858
 [5] require(::Module, ::Symbol) at ./loading.jl:853
 [6] include at ./boot.jl:317 [inlined]
 [7] include_relative(::Module, ::String) at ./loading.jl:1044
 [8] include(::Module, ::String) at ./sysimg.jl:29
 [9] top-level scope at none:2
 [10] eval at ./boot.jl:319 [inlined]
 [11] eval(::Expr) at ./client.jl:393
 [12] top-level scope at ./none:3
in expression starting at /home/kspieker/.julia/packages/DifferentialEquations/9ez1L/src/DifferentialEquations.jl:9

Failed to precompile DifferentialEquations [0c46a032-eb83-5123-abaf-570d42b7fbaa] to /home/kspieker/.julia/compiled/v1.0/DifferentialEquations/UQdwS.ji.

Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] compilecache(::Base.PkgId, ::String) at ./loading.jl:1203
 [3] _require(::Base.PkgId) at ./loading.jl:960
 [4] require(::Base.PkgId) at ./loading.jl:858
 [5] require(::Module, ::Symbol) at ./loading.jl:853
 [6] top-level scope at In[1]:1

Analytic Parameter Jacobians

Forward sensitivity speeds are currently held back by the parameter jacobian evaluations, which can be enormously expensive to compute for our problems (lots of parameters) without sparse differentiation. For simple problems the fastest way to do this should be by adding analytic parameter jacobians. This should be easier to program than the variable jacobians as they should be more consistent between reactors.

Failed to install rmgpy

[ Info: Installing rmgpy.molecule via the Conda rmgpy package...
[ Info: Running `conda config --add channels rmg --file /Users/weiqi/miniconda3/envs/conda_jl/condarc-julia.yml --force` in root environment
Warning: 'rmg' already in 'channels' list, moving to the top
[ Info: Running `conda install -y rmgpy` in root environment
Collecting package metadata (current_repodata.json): done
Solving environment: failed with initial frozen solve. Retrying with flexible solve.
Collecting package metadata (repodata.json): done
Solving environment: failed with initial frozen solve. Retrying with flexible solve.

PackagesNotFoundError: The following packages are not available from current channels:

  - rmgpy

Current channels:

  - https://conda.anaconda.org/rmg/osx-64
  - https://conda.anaconda.org/rmg/noarch
  - https://repo.anaconda.com/pkgs/main/osx-64
  - https://repo.anaconda.com/pkgs/main/noarch
  - https://repo.anaconda.com/pkgs/r/osx-64
  - https://repo.anaconda.com/pkgs/r/noarch
  - https://conda.anaconda.org/conda-forge/osx-64
  - https://conda.anaconda.org/conda-forge/noarch
  - https://conda.anaconda.org/anaconda-fusion/osx-64
  - https://conda.anaconda.org/anaconda-fusion/noarch

To search for alternate channels that may provide the conda package you're
looking for, navigate to

    https://anaconda.org

and use the search bar at the top of the page.


ERROR: InitError: failed process: Process(setenv(`/Users/weiqi/miniconda3/envs/conda_jl/bin/conda install -y rmgpy`,["XPC_FLAGS=0x0", "_CE_M=", "PATH=/usr/local/opt/ruby/bin:/Users/weiqi/miniconda3/bin:/Users/weiqi/miniconda3/condabin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin", "PWD=/Users/weiqi/Box Sync/Energy-COVID-19/Data Combined for Analysis/Model_Combined", "XPC_SERVICE_NAME=0", "TERM_PROGRAM=Apple_Terminal", "SHELL=/bin/zsh", "__CF_USER_TEXT_ENCODING=0x1F6:0x0:0x0", "LD_LIBRARY_PATH=/Users/weiqi/.julia/conda/3/lib", "MKL_INTERFACE_LAYER=LP64,GNU"  …  "SSH_AUTH_SOCK=/private/tmp/com.apple.launchd.3BzDhK9N1F/Listeners", "OLDPWD=/Users/weiqi/Box Sync/Energy-COVID-19/Data Combined for Analysis/Model_Combined", "_=/usr/local/bin/julia", "_CE_CONDA=", "USER=weiqi", "TERM=xterm-256color", "HOME=/Users/weiqi", "TERM_PROGRAM_VERSION=433", "OPENBLAS_MAIN_FREE=1", "PYTHONIOENCODING=UTF-8"]), ProcessExited(1)) [1]

Stacktrace:
 [1] pipeline_error at ./process.jl:525 [inlined]
 [2] run(::Cmd; wait::Bool) at ./process.jl:440
 [3] run at ./process.jl:438 [inlined]
 [4] runconda(::Cmd, ::String) at /Users/weiqi/.julia/packages/Conda/3rPhK/src/Conda.jl:114
 [5] add(::String, ::String; channel::String) at /Users/weiqi/.julia/packages/Conda/3rPhK/src/Conda.jl:188
 [6] add at /Users/weiqi/.julia/packages/Conda/3rPhK/src/Conda.jl:187 [inlined] (repeats 2 times)
 [7] pyimport_conda(::String, ::String, ::String) at /Users/weiqi/.julia/packages/PyCall/zqDXB/src/PyCall.jl:699
 [8] __init__() at /Users/weiqi/.julia/packages/ReactionMechanismSimulator/2Y0hL/src/ReactionMechanismSimulator.jl:20
 [9] _include_from_serialized(::String, ::Array{Any,1}) at ./loading.jl:697
 [10] _require_from_serialized(::String) at ./loading.jl:748
 [11] _require(::Base.PkgId) at ./loading.jl:1039
 [12] require(::Base.PkgId) at ./loading.jl:927
 [13] require(::Module, ::Symbol) at ./loading.jl:922
during initialization of module ReactionMechanismSimulator
caused by [exception 1]
PyError (PyImport_ImportModule

The Python package rmgpy.molecule could not be found by pyimport. Usually this means
that you did not install rmgpy.molecule in the Python version being used by PyCall.

PyCall is currently configured to use the Julia-specific Python distribution
installed by the Conda.jl package.  To install the rmgpy.molecule module, you can
use `pyimport_conda("rmgpy.molecule", PKG)`, where PKG is the Anaconda
package the contains the module rmgpy.molecule, or alternatively you can use the
Conda package directly (via `using Conda` followed by `Conda.add` etcetera).

Alternatively, if you want to use a different Python distribution on your
system, such as a system-wide Python (as opposed to the Julia-specific Python),
you can re-configure PyCall with that Python.   As explained in the PyCall
documentation, set ENV["PYTHON"] to the path/name of the python executable
you want to use, run Pkg.build("PyCall"), and re-launch Julia.

) <class 'ModuleNotFoundError'>
ModuleNotFoundError("No module named 'rmgpy'")

Stacktrace:
 [1] pyimport(::String) at /Users/weiqi/.julia/packages/PyCall/zqDXB/src/PyCall.jl:536
 [2] pyimport_conda(::String, ::String, ::String) at /Users/weiqi/.julia/packages/PyCall/zqDXB/src/PyCall.jl:694
 [3] __init__() at /Users/weiqi/.julia/packages/ReactionMechanismSimulator/2Y0hL/src/ReactionMechanismSimulator.jl:20
 [4] _include_from_serialized(::String, ::Array{Any,1}) at ./loading.jl:697
 [5] _require_from_serialized(::String) at ./loading.jl:748
 [6] _require(::Base.PkgId) at ./loading.jl:1039
 [7] require(::Base.PkgId) at ./loading.jl:927
 [8] require(::Module, ::Symbol) at ./loading.jl:922

Efficient sensitivity trick for ignition delay times

There is a trick that can make the sensitivity analysis of ignition delay time super fast with reverse-model adjoint sensitivity analysis. By recognizing that the sensitivity (direction) is the same as the sensitivity of temperature at ignition point. Then one can take the loss g = u[index of ignition].

Hi @mjohnson541 Do you have large reaction mechanisms that have been tested in rms. I would like to try a mechanism with the size comparable to LLNL iso-octane mechanisms, that contain> 5 k reaction steps. Currently, the rms GitHub repo only contains an ethane mechanism. I can pull a Chemkin mechanism, but it will be great to have one that has been tested.

Reference: Ji, Weiqi, Zhuyin Ren, and Chung K. Law. "Evolution of sensitivity directions during autoignition." Proceedings of the Combustion Institute 37.1 (2019): 807-815.

Startup issues with method definitions

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.NASA{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty}, ReactionMechanismSimulator.NASA{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASA{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty})(ReactionMechanismSimulator.NASA{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty, Base.AbstractDict{K, V} where V where K) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASA{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty})(ReactionMechanismSimulator.NASA{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty, Tuple{Symbol, Any}...) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition show(IO, ReactionMechanismSimulator.NASA{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @unpack_NASA(LineNumberNode, Module, Any) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @pack_NASA(LineNumberNode, Module) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition selectPoly(ReactionMechanismSimulator.NASA{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty, N<:Real) where {N<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:101 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:101.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getHeatCapacity(ReactionMechanismSimulator.NASA{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty, N<:Number) where {N<:Number} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:114 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:114.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getEntropy(ReactionMechanismSimulator.NASA{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty, N<:Number) where {N<:Number} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:115 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:115.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getEnthalpy(ReactionMechanismSimulator.NASA{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty, N<:Number) where {N<:Number} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:116 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:116.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getGibbs(ReactionMechanismSimulator.NASA{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty, N<:Number) where {N<:Number} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:117 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:117.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcHSCpdless(ReactionMechanismSimulator.NASA{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty, N<:Real) where {N<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:118 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:118.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M}})() where {N, Q, T, P, U, R, M} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M}}) where {N, Q, T, P, U, R, M} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M}})(Any, Any, Any, Any, Any, Any, Any) where {N, Q, T, P, U, R, M} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N})(N, T, Array{Q, 1}, P, U, R<:Number, M<:ReactionMechanismSimulator.AbstractThermoUncertainty) where {N, Q, T, P, U, R<:Number, M<:ReactionMechanismSimulator.AbstractThermoUncertainty} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N})(ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N}, ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N})(ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N, Base.AbstractDict{K, V} where V where K) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N})(ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N, Tuple{Symbol, Any}...) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition show(IO, ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @unpack_Wilhoit(LineNumberNode, Module, Any) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @pack_Wilhoit(LineNumberNode, Module) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getHeatCapacity(ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N, N<:Number) where {N<:Number} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:131 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:131.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getEnthalpy(ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N, N<:Number) where {N<:Number} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:136 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:136.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getEntropy(ReactionMechanismSimulator.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N, N<:Number) where {N<:Number} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:147 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:147.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantG{B, J}})() where {B, J} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ConstantG{B, J}}) where {B, J} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantG{B, J}})(Any, Any) where {B, J} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantG{B, J} where J where B<:Number})(B<:Number, J) where {B<:Number, J} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantG{B, J} where J where B<:Number})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ConstantG{B, J} where J where B<:Number}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantG{B, J} where J where B<:Number})(ReactionMechanismSimulator.ConstantG{B, J} where J where B<:Number) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ConstantG{B, J} where J where B<:Number}, ReactionMechanismSimulator.ConstantG{B, J} where J where B<:Number) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantG{B, J} where J where B<:Number})(ReactionMechanismSimulator.ConstantG{B, J} where J where B<:Number, Base.AbstractDict{K, V} where V where K) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantG{B, J} where J where B<:Number})(ReactionMechanismSimulator.ConstantG{B, J} where J where B<:Number, Tuple{Symbol, Any}...) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition show(IO, ReactionMechanismSimulator.ConstantG{B, J} where J where B<:Number) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @unpack_ConstantG(LineNumberNode, Module, Any) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @pack_ConstantG(LineNumberNode, Module) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getGibbs(ReactionMechanismSimulator.ConstantG{B, J} where J where B<:Number, B<:Number) where {B<:Number} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:158 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:158.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASApolynomialvec})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:468 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:468.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.NASApolynomialvec}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:468 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:468.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASApolynomialvec})(Any, Any, Any) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:480 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:480.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASApolynomialvec})(ReactionMechanismSimulator.NASApolynomialvec) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.NASApolynomialvec}, ReactionMechanismSimulator.NASApolynomialvec) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASApolynomialvec})(ReactionMechanismSimulator.NASApolynomialvec, Base.AbstractDict{K, V} where V where K) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASApolynomialvec})(ReactionMechanismSimulator.NASApolynomialvec, Tuple{Symbol, Any}...) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition show(IO, ReactionMechanismSimulator.NASApolynomialvec) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @unpack_NASApolynomialvec(LineNumberNode, Module, Any) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @pack_NASApolynomialvec(LineNumberNode, Module) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASAvec{T}})() where {T} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.NASAvec{T}}) where {T} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASAvec{T}})(Any, Any) where {T} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty})(Any, T<:ReactionMechanismSimulator.AbstractThermoUncertainty) where {T<:ReactionMechanismSimulator.AbstractThermoUncertainty} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty})(ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty}, ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty})(ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty, Base.AbstractDict{K, V} where V where K) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty})(ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty, Tuple{Symbol, Any}...) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition show(IO, ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @unpack_NASAvec(LineNumberNode, Module, Any) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @pack_NASAvec(LineNumberNode, Module) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty})(B<:(Array{T, N} where N where T)) where {B<:(Array{T, N} where N where T)} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermovec.jl:18 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermovec.jl:18.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition selectPoly(ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty, N<:Real) where {N<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermovec.jl:63 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermovec.jl:63.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcHSCpdless(ReactionMechanismSimulator.NASApolynomialvec, X<:Real) where {X<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermovec.jl:76 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermovec.jl:76.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcHSCpdless(ReactionMechanismSimulator.NASAvec{T} where T<:ReactionMechanismSimulator.AbstractThermoUncertainty, X<:Real) where {X<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermovec.jl:121 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermovec.jl:121.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantGvec{B, J}})() where {B, J} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ConstantGvec{B, J}}) where {B, J} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantGvec{B, J}})(Any, Any) where {B, J} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantGvec{B, J} where J where B})(B, J) where {B, J} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantGvec{B, J} where J where B})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ConstantGvec{B, J} where J where B}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantGvec{B, J} where J where B})(ReactionMechanismSimulator.ConstantGvec{B, J} where J where B) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ConstantGvec{B, J} where J where B}, ReactionMechanismSimulator.ConstantGvec{B, J} where J where B) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantGvec{B, J} where J where B})(ReactionMechanismSimulator.ConstantGvec{B, J} where J where B, Base.AbstractDict{K, V} where V where K) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantGvec{B, J} where J where B})(ReactionMechanismSimulator.ConstantGvec{B, J} where J where B, Tuple{Symbol, Any}...) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition show(IO, ReactionMechanismSimulator.ConstantGvec{B, J} where J where B) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @unpack_ConstantGvec(LineNumberNode, Module, Any) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @pack_ConstantGvec(LineNumberNode, Module) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getGibbs(ReactionMechanismSimulator.ConstantGvec{B, J} where J where B, B) where {B} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermovec.jl:132 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermovec.jl:132.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5}})() where {T, Q, V1, V2, V3, V4, V5} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5}}) where {T, Q, V1, V2, V3, V4, V5} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5}})(Any, Any, Any, Any, Any, Any, Any, Any, Any, Any) where {T, Q, V1, V2, V3, V4, V5} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5} where V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where Q<:Integer where T<:ReactionMechanismSimulator.AbstractRate})(Q<:Integer, V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple), V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple), V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple), V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple), T<:ReactionMechanismSimulator.AbstractRate, Any, Any, Any, V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple)) where {T<:ReactionMechanismSimulator.AbstractRate, Q<:Integer, V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple), V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple), V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple), V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple), V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple)} in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5} where V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where Q<:Integer where T<:ReactionMechanismSimulator.AbstractRate})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5} where V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where Q<:Integer where T<:ReactionMechanismSimulator.AbstractRate}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5} where V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where Q<:Integer where T<:ReactionMechanismSimulator.AbstractRate})(ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5} where V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where Q<:Integer where T<:ReactionMechanismSimulator.AbstractRate) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5} where V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where Q<:Integer where T<:ReactionMechanismSimulator.AbstractRate}, ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5} where V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where Q<:Integer where T<:ReactionMechanismSimulator.AbstractRate) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5} where V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where Q<:Integer where T<:ReactionMechanismSimulator.AbstractRate})(ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5} where V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where Q<:Integer where T<:ReactionMechanismSimulator.AbstractRate, Base.AbstractDict{K, V} where V where K) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5} where V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where Q<:Integer where T<:ReactionMechanismSimulator.AbstractRate})(ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5} where V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where Q<:Integer where T<:ReactionMechanismSimulator.AbstractRate, Tuple{Symbol, Any}...) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition show(IO, ReactionMechanismSimulator.ElementaryReaction{T, Q, V1, V2, V3, V4, V5} where V5<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V4<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V3<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V2<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where V1<:(StaticArrays.StaticArray{S, T, N} where N where T where S<:Tuple) where Q<:Integer where T<:ReactionMechanismSimulator.AbstractRate) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @unpack_ElementaryReaction(LineNumberNode, Module, Any) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @pack_ElementaryReaction(LineNumberNode, Module) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getrxnstr(T<:ReactionMechanismSimulator.AbstractReaction) where {T<:ReactionMechanismSimulator.AbstractReaction} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:21 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:21.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition show(IO, T<:ReactionMechanismSimulator.AbstractReaction) where {T<:ReactionMechanismSimulator.AbstractReaction} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:23 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:23.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition print(T<:ReactionMechanismSimulator.AbstractReaction) where {T<:ReactionMechanismSimulator.AbstractReaction} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:24 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:24.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition println(T<:ReactionMechanismSimulator.AbstractReaction) where {T<:ReactionMechanismSimulator.AbstractReaction} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:25 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:25.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getpairs(T<:ReactionMechanismSimulator.AbstractReaction) where {T<:ReactionMechanismSimulator.AbstractReaction} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:31 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:31.
  ** incremental compilation may be fatally broken for this module **

┌ Warning: Replacing docs for `ReactionMechanismSimulator.getpairs :: Tuple{T} where T<:ReactionMechanismSimulator.AbstractReaction` in module `ReactionMechanismSimulator`
└ @ Base.Docs docs/Docs.jl:227
WARNING: Method definition getsimilarity(T<:ReactionMechanismSimulator.AbstractSpecies, T2<:ReactionMechanismSimulator.AbstractSpecies) where {T<:ReactionMechanismSimulator.AbstractSpecies, T2<:ReactionMechanismSimulator.AbstractSpecies} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:62 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:62.
  ** incremental compilation may be fatally broken for this module **

┌ Warning: Replacing docs for `ReactionMechanismSimulator.getsimilarity :: Union{Tuple{T2}, Tuple{T}, Tuple{T,T2}} where T2<:ReactionMechanismSimulator.AbstractSpecies where T<:ReactionMechanismSimulator.AbstractSpecies` in module `ReactionMechanismSimulator`
└ @ Base.Docs docs/Docs.jl:227
WARNING: Method definition choosepairs(T<:ReactionMechanismSimulator.AbstractReaction) where {T<:ReactionMechanismSimulator.AbstractReaction} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:83 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:83.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition length(T<:ReactionMechanismSimulator.AbstractReaction) where {T<:ReactionMechanismSimulator.AbstractReaction} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:92 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Reaction.jl:92.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple})(Any, Any) in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Phase.jl:34 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Phase.jl:37.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple}, Any, Any) in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Phase.jl:34 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Phase.jl:37.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.IdealDiluteSolution{W, W2, W3} where W3 where W2 where W<:Tuple})(Any, Any, Any) in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Phase.jl:74 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Phase.jl:76.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.IdealDiluteSolution{W, W2, W3} where W3 where W2 where W<:Tuple}, Any, Any, Any) in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Phase.jl:74 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Phase.jl:76.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantTPDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:41.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ConstantTPDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:41.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantVDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:118.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ConstantVDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:118.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantPDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:185.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ConstantPDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:185.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ParametrizedTPDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:253.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ParametrizedTPDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:253.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ParametrizedVDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:332.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ParametrizedVDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:332.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ParametrizedPDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:408.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ParametrizedPDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:408.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantTVDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:492.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ConstantTVDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:492.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ParametrizedTConstantVDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:567.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ParametrizedTConstantVDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:567.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.ConstantTAPhiDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase})() in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:643.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.ConstantTAPhiDomain{N, S, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real where S<:Integer where N<:ReactionMechanismSimulator.AbstractPhase}) in module ReactionMechanismSimulator at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:643.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ConstantTPDomain{W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J, Q) where {W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J, Q} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:781 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:805.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ConstantVDomain{W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:826 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:855.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ConstantVDomain{W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:855 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:885.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ConstantPDomain{W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:915 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:943.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ConstantPDomain{W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:943 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:976.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ParametrizedVDomain{W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1005 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1034.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ParametrizedVDomain{W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1034 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1064.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ParametrizedPDomain{W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1094 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1123.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ParametrizedPDomain{W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1123 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1152.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ParametrizedTConstantVDomain{W<:(ReactionMechanismSimulator.IdealDiluteSolution{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealDiluteSolution{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1182 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1207.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ParametrizedTConstantVDomain{W<:(ReactionMechanismSimulator.IdealDiluteSolution{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealDiluteSolution{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1207 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1233.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ParametrizedTPDomain{W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1259 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1288.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ParametrizedTPDomain{W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealGas{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1288 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1318.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ConstantTVDomain{W<:(ReactionMechanismSimulator.IdealDiluteSolution{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealDiluteSolution{W, W2, W3} where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1348 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1426.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcthermo(ReactionMechanismSimulator.ConstantTAPhiDomain{W<:(ReactionMechanismSimulator.IdealSurface{W, W2, W3, W4, W5} where W5 where W4 where W3 where W2 where W<:Tuple), Y<:Integer, W, W2, I, Q} where Q<:(AbstractArray{T, N} where N where T) where I<:Integer where W2<:Real where W<:Real, J<:(AbstractArray{T, N} where N where T), Q<:Real) where {W<:(ReactionMechanismSimulator.IdealSurface{W, W2, W3, W4, W5} where W5 where W4 where W3 where W2 where W<:Tuple), Y<:Integer, J<:(AbstractArray{T, N} where N where T), Q<:Real} in module ReactionMechanismSimulator at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1447 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Domain.jl:1506.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getGibbs(P<:ReactionMechanismSimulator.Calc.AbstractThermo, N<:Number) where {N<:Number, P<:ReactionMechanismSimulator.Calc.AbstractThermo} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:6 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:6.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.NASApolynomial})() in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:468 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:468.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Calc.NASApolynomial}) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:468 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:468.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.NASApolynomial})(Any, Any, Any) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:480 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:480.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.NASApolynomial})(ReactionMechanismSimulator.Calc.NASApolynomial) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Calc.NASApolynomial}, ReactionMechanismSimulator.Calc.NASApolynomial) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.NASApolynomial})(ReactionMechanismSimulator.Calc.NASApolynomial, Base.AbstractDict{K, V} where V where K) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.NASApolynomial})(ReactionMechanismSimulator.Calc.NASApolynomial, Tuple{Symbol, Any}...) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition show(IO, ReactionMechanismSimulator.Calc.NASApolynomial) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @unpack_NASApolynomial(LineNumberNode, Module, Any) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @pack_NASApolynomial(LineNumberNode, Module) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcHSCpdless(ReactionMechanismSimulator.Calc.NASApolynomial, X<:Real) where {X<:Real} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:17 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:17.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getHeatCapacity(ReactionMechanismSimulator.Calc.NASApolynomial, N<:Number) where {N<:Number} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:65 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:65.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getEntropy(ReactionMechanismSimulator.Calc.NASApolynomial, N<:Number) where {N<:Number} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:75 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:75.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getEnthalpy(ReactionMechanismSimulator.Calc.NASApolynomial, N<:Number) where {N<:Number} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:85 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:85.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.NASA{T}})() where {T} in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Calc.NASA{T}}) where {T} in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.NASA{T}})(Any, Any) where {T} in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty})(Any, T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty) where {T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty} in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty})() in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty}) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty})(ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty}, ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty})(ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty, Base.AbstractDict{K, V} where V where K) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty})(ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty, Tuple{Symbol, Any}...) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition show(IO, ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @unpack_NASA(LineNumberNode, Module, Any) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @pack_NASA(LineNumberNode, Module) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition selectPoly(ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty, N<:Real) where {N<:Real} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:101 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:101.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getHeatCapacity(ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty, N<:Number) where {N<:Number} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:114 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:114.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getEntropy(ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty, N<:Number) where {N<:Number} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:115 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:115.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getEnthalpy(ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty, N<:Number) where {N<:Number} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:116 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:116.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getGibbs(ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty, N<:Number) where {N<:Number} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:117 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:117.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition calcHSCpdless(ReactionMechanismSimulator.Calc.NASA{T} where T<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty, N<:Real) where {N<:Real} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:118 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:118.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M}})() where {N, Q, T, P, U, R, M} in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M}}) where {N, Q, T, P, U, R, M} in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M}})(Any, Any, Any, Any, Any, Any, Any) where {N, Q, T, P, U, R, M} in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N})(N, T, Array{Q, 1}, P, U, R<:Number, M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty) where {N, Q, T, P, U, R<:Number, M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty} in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N})() in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N}) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N})(ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N}, ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N})(ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N, Base.AbstractDict{K, V} where V where K) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N})(ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N, Tuple{Symbol, Any}...) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition show(IO, ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @unpack_Wilhoit(LineNumberNode, Module, Any) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @pack_Wilhoit(LineNumberNode, Module) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getHeatCapacity(ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N, N<:Number) where {N<:Number} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:131 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:131.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getEnthalpy(ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N, N<:Number) where {N<:Number} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:136 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:136.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getEntropy(ReactionMechanismSimulator.Calc.Wilhoit{N, Q, T, P, U, R, M} where M<:ReactionMechanismSimulator.Calc.AbstractThermoUncertainty where R<:Number where U where P where T where Q where N, N<:Number) where {N<:Number} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:147 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:147.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.ConstantG{B, J}})() where {B, J} in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Calc.ConstantG{B, J}}) where {B, J} in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:466.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.ConstantG{B, J}})(Any, Any) where {B, J} in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:478.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.ConstantG{B, J} where J where B<:Number})(B<:Number, J) where {B<:Number, J} in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:501.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.ConstantG{B, J} where J where B<:Number})() in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Calc.ConstantG{B, J} where J where B<:Number}) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:520.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.ConstantG{B, J} where J where B<:Number})(ReactionMechanismSimulator.Calc.ConstantG{B, J} where J where B<:Number) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition Type##kw(Any, Type{ReactionMechanismSimulator.Calc.ConstantG{B, J} where J where B<:Number}, ReactionMechanismSimulator.Calc.ConstantG{B, J} where J where B<:Number) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:530.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.ConstantG{B, J} where J where B<:Number})(ReactionMechanismSimulator.Calc.ConstantG{B, J} where J where B<:Number, Base.AbstractDict{K, V} where V where K) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:533.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition (::Type{ReactionMechanismSimulator.Calc.ConstantG{B, J} where J where B<:Number})(ReactionMechanismSimulator.Calc.ConstantG{B, J} where J where B<:Number, Tuple{Symbol, Any}...) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:534.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition show(IO, ReactionMechanismSimulator.Calc.ConstantG{B, J} where J where B<:Number) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:542.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @unpack_ConstantG(LineNumberNode, Module, Any) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:577.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition @pack_ConstantG(LineNumberNode, Module) in module Calc at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564 overwritten at /home/crackauc/.julia/packages/Parameters/CVyBv/src/Parameters.jl:564.
  ** incremental compilation may be fatally broken for this module **

WARNING: Method definition getGibbs(ReactionMechanismSimulator.Calc.ConstantG{B, J} where J where B<:Number, B<:Number) where {B<:Number} in module Calc at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:158 overwritten at /home/crackauc/.julia/dev/ReactionMechanismSimulator/src/Calculators/Thermo.jl:158.
  ** incremental compilation may be fatally broken for this module **

Just a lot of method definitions need to get cleaned up.

Error reading .inp files

Hi, I'm new to use RMS and trying to readinput(file.inp) but I get the following errors, Could anyone please relate where the problem might be?

PyError ($(Expr(:escape, :(ccall(#= /home/abdallah/.julia/packages/PyCall/BcTLp/src/pyfncall.jl:43 =# @pysym(:PyObject_Call), PyPtr, (PyPtr, PyPtr, PyPtr), o, pyargsptr, kw))))) <class 'rmgpy.exceptions.ChemkinError'>
ChemkinError('Unknown unit type "kjoules/mole"')
  File "rmgpy/chemkin.pyx", line 909, in rmgpy.chemkin.load_chemkin_file
  File "rmgpy/chemkin.pyx", line 931, in rmgpy.chemkin.load_chemkin_file
  File "rmgpy/chemkin.pyx", line 1251, in rmgpy.chemkin.read_reactions_block


Stacktrace:
 [1] pyerr_check at /home/abdallah/.julia/packages/PyCall/BcTLp/src/exception.jl:62 [inlined]
 [2] pyerr_check at /home/abdallah/.julia/packages/PyCall/BcTLp/src/exception.jl:66 [inlined]
 [3] _handle_error(::String) at /home/abdallah/.julia/packages/PyCall/BcTLp/src/exception.jl:83
 [4] macro expansion at /home/abdallah/.julia/packages/PyCall/BcTLp/src/exception.jl:97 [inlined]
 [5] #110 at /home/abdallah/.julia/packages/PyCall/BcTLp/src/pyfncall.jl:43 [inlined]
 [6] disable_sigint at ./c.jl:446 [inlined]
 [7] __pycall! at /home/abdallah/.julia/packages/PyCall/BcTLp/src/pyfncall.jl:42 [inlined]
 [8] _pycall!(::PyCall.PyObject, ::PyCall.PyObject, ::Tuple{String}, ::Int64, ::Ptr{Nothing}) at /home/abdallah/.julia/packages/PyCall/BcTLp/src/pyfncall.jl:29
 [9] _pycall! at /home/abdallah/.julia/packages/PyCall/BcTLp/src/pyfncall.jl:11 [inlined]
 [10] #_#117 at /home/abdallah/.julia/packages/PyCall/BcTLp/src/pyfncall.jl:86 [inlined]
 [11] (::PyCall.PyObject)(::String) at /home/abdallah/.julia/packages/PyCall/BcTLp/src/pyfncall.jl:86
 [12] convertchemkin2yml(::String; spcdictpath::String, output::String) at /home/abdallah/.julia/dev/ReactionMechanismSimulator/src/yml.jl:5
 [13] readinput(::String; spcdict::String, output::String) at /home/abdallah/.julia/dev/ReactionMechanismSimulator/src/Parse.jl:209
 [14] readinput(::String) at /home/abdallah/.julia/dev/ReactionMechanismSimulator/src/Parse.jl:204
 [15] top-level scope at In[27]:1

Adjoint Sensitivities don't work properly for domains that aren't ConstantTPDomain

After some discrepancies between sensitivities from forward sensitivity analysis and adjoint I suspect ReverseDiffVJP(true) isn't suitable for systems where the rate coefficients change, the catch is that ReverseDiffVJP(false) always gives me NaNs and TrackerVJP has some typing issues. There also seems to be a separate typing issue for ConstantTVDomain. The typing issues shouldn't be too difficult to resolve, it's worth noting that ReverseDiffVJP(false) is expected to be fastest for these cases so it's worth trying to get it to work properly. This has made it very clear we need a solid set of tests for adjoint sensitivities.

Calculate Thermodynamic Columns Analytically

For ParameterizedVDomain jacobiany evaluation we get:

Note that the little zeros bit on the left won't show up normally since we use in-place evaluation.

Most of our time is spent calculating the dn_i/dT and dn_i/dP columns using ForwardDiff. However it isn't too hard to derive analytic equations down to the dGf/dT, dkf/dT and dkf/dP level. dGf/dT for NASA polynomials is the derivative of the polynomial expressions we already have formulas for. dkf/dT and dkf/dP are trivial for arrhenius reusing kf from the calculation: dkf/dT = kf*((n*Ea)/(RT^3)) and dkf/dP = 0, which represents the vast majority of our rates. The next-most common kf(T) for RMG mechanisms is Chebyshev, which is a bit more tricky, but I think it should be possible to write nice analytic expressions for. This isn't hard to do for 3rd body and even Lindemann forms. PdepArrhenius shouldn't be hard either. Troe is a bit difficult, but doing a few of these numerically shouldn't be a big deal compared to the original calcthermo evaluation. If we add functions associated with calculating dkf/dT and dkf/dP for most kinetics objects and then fallback to something numerical I suspect we can get rid of most of the jacobianytherm! evaluation time and get ~2x speed up from doing this.

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.

reactionmechanismgenerator / reactionmechanismsimulator.jl Goto Github PK

reactionmechanismsimulator.jl's Introduction

RMS - Reaction Mechanism Simulator

Description

Features

How to cite

Installation

reactionmechanismsimulator.jl's People

Contributors

Stargazers

Watchers

Forkers

reactionmechanismsimulator.jl's Issues

config conda environment for rmg

create and activate conda env

install dependence rmg

Install the version in the master branch

Note

Code

Error

Julia st

Recommend Projects

Recommend Topics

Recommend Org

config conda environment for `rmg`