def test_fetch_rows_single(self):
test_db = generate_db_name()
test_table_name = 'test_table'
test_table = db.Table(test_db, test_table_name, testing=True)
kwargs = {
'mechanism': 'gri30.cti',
'initial_temp': 300,
'initial_press': 101325,
'fuel': 'CH4',
'oxidizer': 'N2O',
'equivalence': 1,
'diluent': 'N2',
'diluent_mol_frac': 0.1,
'inert': 'None',
'cj_speed': 1986.12354679687543,
'ind_len_west': 1,
'ind_len_gav': 2,
'ind_len_ng': 3,
'cell_size_west': 4,
'cell_size_gav': 5,
'cell_size_ng': 6
}
test_table.store_test_row(**kwargs)
test_rows = test_table.fetch_test_rows()
checks = []
for key, value in test_rows.items():
if 'date' not in key and 'rxn_table_id' not in key:
if isinstance(kwargs[key], str) or isinstance(
kwargs[key], int):
checks.append(kwargs[key] == value[0])
else:
checks.append(isclose(kwargs[key], value[0]))
assert all(checks)
def test_check_for_stored_base_data(self):
test_db = generate_db_name()
test_table_name = 'test_table'
test_table = db.Table(test_db, test_table_name, testing=True)
kwargs_init = {
'mechanism': 'gri30.cti',
'initial_temp': 300,
'initial_press': 101325,
'fuel': 'CH4',
'oxidizer': 'N2O',
'equivalence': 1,
'diluent': 'N2',
'diluent_mol_frac': 0.1,
'inert': 'None',
'cj_speed': 1986.12354679687543,
'ind_len_west': 1,
'ind_len_gav': 2,
'ind_len_ng': 3,
'cell_size_west': 4,
'cell_size_gav': 5,
'cell_size_ng': 6
}
rxn_table_id = test_table.store_test_row(**kwargs_init)
test_false = test_table.check_for_stored_base_data(rxn_table_id)
gas = ct.Solution(kwargs_init['mechanism'])
gas.TP = kwargs_init['initial_temp'], kwargs_init['initial_press']
gas.set_equivalence_ratio(kwargs_init['equivalence'],
kwargs_init['fuel'], kwargs_init['oxidizer'])
test_table.store_base_rxn_table(rxn_table_id, gas)
test_true = test_table.check_for_stored_base_data(rxn_table_id)
assert all([test_true, not test_false])
def test_store_and_check_existing_test(self):
kwargs = {
'mechanism': 'gri30.cti',
'initial_temp': 300,
'initial_press': 101325,
'fuel': 'CH4',
'oxidizer': 'N2O',
'equivalence': 1,
'diluent': 'N2',
'diluent_mol_frac': 0.1,
'inert': 'None',
}
test_db = generate_db_name()
test_table_name = 'test_table'
test_table = db.Table(test_db, test_table_name, testing=True)
test_table.store_test_row(
**{
**kwargs, 'cj_speed': 456,
'ind_len_west': 1,
'ind_len_gav': 2,
'ind_len_ng': 3,
'cell_size_west': 4,
'cell_size_gav': 5,
'cell_size_ng': 6
})
assert test_table._check_existing_test(**kwargs)
def test__create_base_table(self):
test_db = generate_db_name()
test_table_name = 'test_table'
test_table = db.Table(test_db, test_table_name, testing=True)
test_table.store_test_row(mechanism='gri30.cti',
initial_temp=300,
initial_press=101325,
fuel='CH4',
oxidizer='N2O',
equivalence=1,
diluent='N2',
diluent_mol_frac=0.1,
inert='None',
cj_speed=1986.12354679687543,
ind_len_west=1,
ind_len_gav=2,
ind_len_ng=3,
cell_size_west=4,
cell_size_gav=5,
cell_size_ng=6)
info = test_table.fetch_test_rows(
mechanism='gri30.cti',
initial_temp=300,
initial_press=101325,
fuel='CH4',
oxidizer='N2O',
equivalence=1,
diluent='N2',
diluent_mol_frac=0.1,
)
[rxn_id] = info['rxn_table_id']
actual_columns = set(test_table.base_columns(rxn_id))
assert not {'rxn_no', 'rxn', 'k_i'}.difference(actual_columns)
def test_fetch_rows_multiple(self):
test_db = generate_db_name()
test_table_name = 'test_table'
test_table = db.Table(test_db, test_table_name, testing=True)
kwargs = [{
'mechanism': 'gri30.cti',
'initial_temp': 300,
'initial_press': 101325,
'fuel': 'CH4',
'oxidizer': 'N2O',
'equivalence': 1,
'diluent': 'N2',
'diluent_mol_frac': 0.1,
'inert': 'None',
'cj_speed': 1986.12354679687543,
'ind_len_west': 1,
'ind_len_gav': 2,
'ind_len_ng': 3,
'cell_size_west': 4,
'cell_size_gav': 5,
'cell_size_ng': 6
}, {
'mechanism': 'Mevel2017.cti',
'initial_temp': 550,
'initial_press': 2 * 101325,
'fuel': 'H2',
'oxidizer': 'O2',
'equivalence': 1.125,
'diluent': 'None',
'diluent_mol_frac': 0,
'inert': 'N2',
'cj_speed': 2112,
'ind_len_west': 2.1,
'ind_len_gav': 2.2,
'ind_len_ng': 2.3,
'cell_size_west': 2.4,
'cell_size_gav': 2.5,
'cell_size_ng': 2.6
}]
for kw in kwargs:
test_table.store_test_row(**kw)
test_rows = test_table.fetch_test_rows()
checks = []
good_answer = {
key: [value, kwargs[1][key]]
for key, value in kwargs[0].items()
}
for key, value in test_rows.items():
if 'date' not in key and 'rxn_table_id' not in key:
if (isinstance(kwargs[0][key], str)
or isinstance(kwargs[0][key], int)):
for good, test in zip(good_answer[key], test_rows[key]):
checks.append(test == good)
else:
checks.append(allclose(good_answer[key], value))
assert all(checks)
def test_fetch_rows_blank_table(self):
test_db = generate_db_name()
test_table_name = 'test_table'
test_table = db.Table(test_db, test_table_name, testing=True)
test_rows = test_table.fetch_test_rows()
assert all([
not set(db.Table._test_table_args).difference(set(
test_rows.keys())),
*[item == [] for item in test_rows.values()]
])
def test_delete_test(self):
test_db = generate_db_name()
test_table_name = 'test_table'
test_table = db.Table(test_db, test_table_name, testing=True)
rxn_table_id = test_table.store_test_row(mechanism='gri30.cti',
initial_temp=300,
initial_press=101325,
fuel='CH4',
oxidizer='N2O',
equivalence=1,
diluent='N2',
diluent_mol_frac=0.1,
inert='None',
cj_speed=1986.12354679687543,
ind_len_west=1,
ind_len_gav=2,
ind_len_ng=3,
cell_size_west=4,
cell_size_gav=5,
cell_size_ng=6)
test_table.delete_test(rxn_table_id)
empties = []
with test_table.con as con:
cur = con.cursor()
cur.execute("""
SELECT * FROM {:s} WHERE rxn_table_id='{:s}';
""".format(test_table_name, rxn_table_id))
empties.append(cur.fetchall())
cur.execute("""
SELECT name FROM sqlite_master WHERE type='table' AND
name LIKE 'PERT_%';
""")
empties.append(cur.fetchall())
cur.execute("""
SELECT name FROM sqlite_master WHERE type='table' AND
name LIKE 'BASE_%';
""".format(test_db))
empties.append(cur.fetchall())
assert all([len(chk) == 0 for chk in empties])
def test_store_base_table(self):
test_db = generate_db_name()
test_table_name = 'test_table'
test_table = db.Table(test_db, test_table_name, testing=True)
kwargs_init = {
'mechanism': 'gri30.cti',
'initial_temp': 300,
'initial_press': 101325,
'fuel': 'CH4',
'oxidizer': 'N2O',
'equivalence': 1,
'diluent': 'N2',
'diluent_mol_frac': 0.1,
'inert': 'None',
'cj_speed': 1986.12354679687543,
'ind_len_west': 1,
'ind_len_gav': 2,
'ind_len_ng': 3,
'cell_size_west': 4,
'cell_size_gav': 5,
'cell_size_ng': 6
}
rxn_table_id = test_table.store_test_row(**kwargs_init)
gas = ct.Solution(kwargs_init['mechanism'])
gas.TP = kwargs_init['initial_temp'], kwargs_init['initial_press']
gas.set_equivalence_ratio(kwargs_init['equivalence'],
kwargs_init['fuel'], kwargs_init['oxidizer'])
test_table.store_base_rxn_table(rxn_table_id, gas)
test_rows = test_table.fetch_base_rxn_table(rxn_table_id)
checks = [gas.n_reactions == len(test_rows)]
for row in test_rows:
current_tests = [
gas.reaction_equation(row[0]) == row[1],
isclose(gas.forward_rate_constants[row[0]], row[2])
]
checks.append(current_tests)
assert all(checks)
def test_fetch_single_base_rxn(self):
test_db = generate_db_name()
test_table_name = 'test_table'
test_table = db.Table(test_db, test_table_name, testing=True)
kwargs_init = {
'mechanism': 'gri30.cti',
'initial_temp': 300,
'initial_press': 101325,
'fuel': 'CH4',
'oxidizer': 'N2O',
'equivalence': 1,
'diluent': 'N2',
'diluent_mol_frac': 0.1,
'inert': 'None',
'cj_speed': 1986.12354679687543,
'ind_len_west': 1,
'ind_len_gav': 2,
'ind_len_ng': 3,
'cell_size_west': 4,
'cell_size_gav': 5,
'cell_size_ng': 6
}
rxn_table_id = test_table.store_test_row(**kwargs_init)
gas = ct.Solution(kwargs_init['mechanism'])
gas.TP = kwargs_init['initial_temp'], kwargs_init['initial_press']
gas.set_equivalence_ratio(kwargs_init['equivalence'],
kwargs_init['fuel'], kwargs_init['oxidizer'])
test_table.store_base_rxn_table(rxn_table_id, gas)
checks = []
rates = gas.forward_rate_constants
for idx in range(gas.n_reactions):
test_rxn = test_table.fetch_single_base_rxn(rxn_table_id, idx)
checks.append([
test_rxn[0] == idx, test_rxn[1] == gas.reaction_equation(idx),
test_rxn[2] == rates[idx]
])
def test_store_pert_row_update(self):
test_db = generate_db_name()
test_table_name = 'test_table'
test_table = db.Table(test_db, test_table_name, testing=True)
test_kwargs = {
'mechanism': 'gri30.cti',
'initial_temp': 300,
'initial_press': 101325,
'fuel': 'CH4',
'oxidizer': 'N2O',
'equivalence': 1,
'diluent': 'N2',
'diluent_mol_frac': 0.1,
'inert': 'None',
'cj_speed': 1986.12354679687543,
'ind_len_west': 1,
'ind_len_gav': 2,
'ind_len_ng': 3,
'cell_size_west': 4,
'cell_size_gav': 5,
'cell_size_ng': 6
}
pert_kwargs_init = {
'rxn_no': 100,
'rxn': '3 food + 1 stomach => 1 poop',
'k_i': 1.2e12,
'ind_len_west': 1.1,
'ind_len_gav': 2.2,
'ind_len_ng': 3.3,
'cell_size_west': 4.4,
'cell_size_gav': 5.5,
'cell_size_ng': 6.6,
'sens_ind_len_west': 8.8,
'sens_ind_len_gav': 9.9,
'sens_ind_len_ng': 0.0,
'sens_cell_size_west': 1.1,
'sens_cell_size_gav': 2.2,
'sens_cell_size_ng': 3.3,
}
pert_kwargs_repl = {
'rxn_no': 100,
'rxn': '3 food + 1 stomach => 1 poop',
'k_i': 1.2e12,
'ind_len_west': 11.1,
'ind_len_gav': 12.2,
'ind_len_ng': 13.3,
'cell_size_west': 14.4,
'cell_size_gav': 15.5,
'cell_size_ng': 16.6,
'sens_ind_len_west': 18.8,
'sens_ind_len_gav': 19.9,
'sens_ind_len_ng': 10.0,
'sens_cell_size_west': 11.1,
'sens_cell_size_gav': 12.2,
'sens_cell_size_ng': 13.3,
}
table_id = test_table.store_test_row(**test_kwargs)
test_table.store_perturbed_row(rxn_table_id=table_id,
**pert_kwargs_init)
test_table.store_perturbed_row(
rxn_table_id=table_id,
overwrite_existing=True,
**pert_kwargs_repl,
)
test_table.store_perturbed_row(
rxn_table_id=table_id,
overwrite_existing=False,
**pert_kwargs_init,
)
test_rows = test_table.fetch_pert_table(rxn_table_id=table_id,
**pert_kwargs_repl)
checks = []
for key, value in test_rows.items():
if 'date' not in key:
if (isinstance(pert_kwargs_repl[key], str)
or isinstance(pert_kwargs_repl[key], int)):
checks.append(pert_kwargs_repl[key] == value[0])
else:
checks.append(isclose(pert_kwargs_repl[key], value[0]))
assert all(checks)
_inert = 'None'
# _mechanism = 'Mevel2017.cti'
# _mechanism = 'aramco2.cti'
_inert_species = [_inert]
_mechanism = "gri30.cti"
_initial_temp = 300
_initial_press = 101325
_equivalence = 1
_fuel = 'C3H8'
_oxidizer = 'O2:1 N2:3.76'
# diluent = 'AR'
_diluent = 'None'
_diluent_mol_frac = 0
_perturbation_fraction = 1e-2
t = db.Table('sensitivity.sqlite', 'data')
exist_check = t.fetch_test_rows(mechanism=_mechanism,
initial_temp=_initial_temp,
initial_press=_initial_press,
fuel=_fuel,
oxidizer=_oxidizer,
equivalence=_equivalence,
diluent=_diluent,
diluent_mol_frac=_diluent_mol_frac,
inert=_inert)['rxn_table_id']
# if len(exist_check) > 0:
# t.delete_test(exist_check[0])
reactions = []
# noinspection PyCallByClass,PyArgumentList
for rxn in ct.Reaction.listFromFile(_mechanism):
def perform_study(mech, init_temp, init_press, equivalence, fuel, oxidizer,
diluent, diluent_mol_frac, inert, perturbation_fraction,
perturbed_reaction_no, db_lock):
CellSize = cell_size.CellSize()
gas = cell_size.solution_with_inerts(mech, inert)
gas.TP = init_temp, init_press
gas.set_equivalence_ratio(equivalence, fuel, oxidizer)
db_name = 'sensitivity.sqlite'
table_name = 'data'
current_table = db.Table(database=db_name, table_name=table_name)
with db_lock:
# check for stored cj speed
stored_cj = check_stored_base_cj_speed(
table=current_table,
mechanism=mech,
initial_temp=init_temp,
initial_press=init_press,
fuel=fuel,
oxidizer=oxidizer,
equivalence=equivalence,
diluent=diluent,
diluent_mol_frac=diluent_mol_frac,
inert=inert)
if not stored_cj:
# calculate and store cj speed
cj_speed = sd.postshock.CJspeed(P1=init_press,
T1=init_temp,
q=gas.mole_fraction_dict(),
mech=mech)
rxn_table_id = current_table.store_test_row(
mechanism=mech,
initial_temp=init_temp,
initial_press=init_press,
fuel=fuel,
oxidizer=oxidizer,
equivalence=equivalence,
diluent=diluent,
diluent_mol_frac=diluent_mol_frac,
inert=inert,
cj_speed=cj_speed,
ind_len_west=0,
ind_len_gav=0,
ind_len_ng=0,
cell_size_west=0,
cell_size_gav=0,
cell_size_ng=0,
overwrite_existing=False)
else:
# stored cj speed exists
current_data = current_table.fetch_test_rows(
mechanism=mech,
initial_temp=init_temp,
initial_press=init_press,
fuel=fuel,
oxidizer=oxidizer,
equivalence=equivalence,
diluent=diluent,
diluent_mol_frac=diluent_mol_frac,
inert=inert)
[rxn_table_id] = current_data['rxn_table_id']
[cj_speed] = current_data['cj_speed']
del current_data
del stored_cj
# check for stored base reaction data
stored_rxns = current_table.check_for_stored_base_data(rxn_table_id)
if not stored_rxns:
current_table.store_base_rxn_table(rxn_table_id=rxn_table_id,
gas=gas)
del stored_rxns
stored_base_calcs = check_stored_base_calcs(
table=current_table,
mechanism=mech,
initial_temp=init_temp,
initial_press=init_press,
fuel=fuel,
oxidizer=oxidizer,
equivalence=equivalence,
diluent=diluent,
diluent_mol_frac=diluent_mol_frac,
inert=inert)
if not stored_base_calcs:
# calculate base cell size
base_cell_calcs = CellSize(
base_mechanism=mech,
cj_speed=cj_speed,
initial_temp=init_temp,
initial_press=init_press,
fuel=fuel,
oxidizer=oxidizer,
equivalence=equivalence,
diluent=diluent,
diluent_mol_frac=diluent_mol_frac,
inert=inert,
)
base_ind_len = CellSize.induction_length
current_table.store_test_row(
mechanism=mech,
initial_temp=init_temp,
initial_press=init_press,
fuel=fuel,
oxidizer=oxidizer,
equivalence=equivalence,
diluent=diluent,
diluent_mol_frac=diluent_mol_frac,
inert=inert,
cj_speed=cj_speed,
ind_len_west=base_ind_len['Westbrook'],
ind_len_gav=base_ind_len['Gavrikov'],
ind_len_ng=base_ind_len['Ng'],
cell_size_west=base_cell_calcs['Westbrook'],
cell_size_gav=base_cell_calcs['Gavrikov'],
cell_size_ng=base_cell_calcs['Ng'],
overwrite_existing=True)
else:
# look up base calcs from db
current_data = current_table.fetch_test_rows(
mechanism=mech,
initial_temp=init_temp,
initial_press=init_press,
fuel=fuel,
oxidizer=oxidizer,
equivalence=equivalence,
diluent=diluent,
diluent_mol_frac=diluent_mol_frac,
inert=inert)
base_ind_len = {
'Westbrook': current_data['ind_len_west'][0],
'Gavrikov': current_data['ind_len_gav'][0],
'Ng': current_data['ind_len_ng'][0],
}
base_cell_calcs = {
'Westbrook': current_data['cell_size_west'][0],
'Gavrikov': current_data['cell_size_gav'][0],
'Ng': current_data['cell_size_ng'][0],
}
del current_data
del stored_base_calcs
# calculate perturbed cell size
pert_cell_calcs = CellSize(base_mechanism=mech,
cj_speed=cj_speed,
initial_temp=init_temp,
initial_press=init_press,
fuel=fuel,
oxidizer=oxidizer,
equivalence=equivalence,
diluent=diluent,
diluent_mol_frac=diluent_mol_frac,
inert=inert,
perturbed_reaction=perturbed_reaction_no)
pert_ind_len = CellSize.induction_length
# calculate sensitivities
sens_ind_len_west = (pert_ind_len['Westbrook'] -
base_ind_len['Westbrook']) / \
(base_ind_len['Westbrook'] * perturbation_fraction)
sens_cell_size_west = (pert_cell_calcs['Westbrook'] -
base_cell_calcs['Westbrook']) / \
(base_cell_calcs['Westbrook'] * perturbation_fraction)
sens_ind_len_gav = (pert_ind_len['Gavrikov'] -
base_ind_len['Gavrikov']) / \
(base_ind_len['Gavrikov'] * perturbation_fraction)
sens_cell_size_gav = (pert_cell_calcs['Gavrikov'] -
base_cell_calcs['Gavrikov']) / \
(base_cell_calcs['Gavrikov'] * perturbation_fraction)
sens_ind_len_ng = (pert_ind_len['Ng'] -
base_ind_len['Ng']) / \
(base_ind_len['Ng'] * perturbation_fraction)
sens_cell_size_ng = (pert_cell_calcs['Ng'] -
base_cell_calcs['Ng']) / \
(base_cell_calcs['Ng'] * perturbation_fraction)
with db_lock:
current_table.store_perturbed_row(
rxn_table_id=rxn_table_id,
rxn_no=perturbed_reaction_no,
rxn=CellSize.base_gas.reaction_equation(perturbed_reaction_no),
k_i=CellSize.base_gas.
forward_rate_constants[perturbed_reaction_no],
ind_len_west=pert_ind_len['Westbrook'],
ind_len_gav=pert_ind_len['Gavrikov'],
ind_len_ng=pert_ind_len['Ng'],
cell_size_west=pert_cell_calcs['Westbrook'],
cell_size_gav=pert_cell_calcs['Gavrikov'],
cell_size_ng=pert_cell_calcs['Ng'],
sens_ind_len_west=sens_ind_len_west,
sens_ind_len_gav=sens_ind_len_gav,
sens_ind_len_ng=sens_ind_len_ng,
sens_cell_size_west=sens_cell_size_west,
sens_cell_size_gav=sens_cell_size_gav,
sens_cell_size_ng=sens_cell_size_ng,
overwrite_existing=True)
