def test_carbon_black_stochastoc(carbon_black_cuds: Cuds, flask_client,
mocker) -> None:
wrapper = _case_runner(case_cuds=carbon_black_cuds,
engine=CarbonBlackEngine(),
model_flag=KineticsSession.CB_STOCHASIC,
client=flask_client,
mocker=mocker)
# Find all the output CUDS
part_num_dens = cuds_search.find_cuds_objects_by_oclass(
oclass=CMCL.PARTICLE_NUMBER_DENSITIES, root=wrapper, rel=None)
part_num_size_classes = cuds_search.find_cuds_objects_by_oclass(
oclass=CMCL.PARTICLE_SIZE_CLASSES, root=wrapper, rel=None)
prim_num_dens = cuds_search.find_cuds_objects_by_oclass(
oclass=CMCL.PRIMARY_PARTICLE_NUMBER_DENSITIES, root=wrapper, rel=None)
prim_num_size_classes = cuds_search.find_cuds_objects_by_oclass(
oclass=CMCL.PRIMARY_PARTICLE_SIZE_CLASSES, root=wrapper, rel=None)
part_fract_dim = cuds_search.find_cuds_objects_by_oclass(
oclass=CMCL.PARTICLE_MEAN_FRACTAL_DIMENSION, root=wrapper, rel=None)
# check all the output CUDS
assert len(part_num_dens) == 1
assert part_num_dens[0].value_string != ""
assert len(part_num_size_classes) == 1
assert part_num_size_classes[0].value_string != ""
assert len(prim_num_dens) == 1
assert prim_num_dens[0].value_string != ""
assert len(prim_num_size_classes) == 1
assert prim_num_size_classes[0].value_string != ""
assert len(part_fract_dim) == 1
assert part_fract_dim[0].value != 0.0
def test_carbon_black_momic(carbon_black_cuds: Cuds, flask_client,
mocker) -> None:
wrapper = _case_runner(case_cuds=carbon_black_cuds,
engine=CarbonBlackEngine(),
model_flag=KineticsSession.CB_MOMIC,
client=flask_client,
mocker=mocker)
# Find all the output CUDS
mean_part_size = cuds_search.find_cuds_objects_by_oclass(
oclass=CMCL.MEAN_PARTICLE_SIZE, root=wrapper, rel=None)
part_num_dens = cuds_search.find_cuds_objects_by_oclass(
oclass=CMCL.PARTICLE_NUMBER_DENSITY, root=wrapper, rel=None)
part_vol_frac = cuds_search.find_cuds_objects_by_oclass(
oclass=CMCL.PARTICLE_VOLUME_FRACTION, root=wrapper, rel=None)
# check all the output CUDS
assert len(mean_part_size) == 1
assert mean_part_size[0].value != 0.0
assert len(part_num_dens) == 1
assert part_num_dens[0].value != 0.0
assert len(part_vol_frac) == 1
assert part_vol_frac[0].value != 0.0
def determineTemplate(self, root_cuds_object, modelFlag) -> str:
"""Determines which simulation template to use based on the input
CUDS data.
Arguments:
root_cuds_object -- Root CUDS object representing input data
modelFlag -- Integer for model (see KineticsSession for values)
Returns:
Appropriate simulation template name
"""
# Find the EAT Process object
eat_process = search.find_cuds_objects_by_oclass(CMCL.EAT_PROCESS,
root_cuds_object,
rel=CMCL.HAS_PART)[0]
if modelFlag == KineticsSession.EAT_GPF:
# GPF
simulation_template = agent_cases.EAT_GPF
# Find GPF object
gpf = search.find_cuds_objects_by_oclass(
CMCL.GPF, eat_process, rel=CMCL.HAS_PROPER_PARTICIPANT)[0]
# Add outputs
gpf.add(CMCL.PM_FILTRATION_EFFICIENCY(value=0.0, unit="-"),
CMCL.PN_FILTRATION_EFFICIENCY(value=0., unit="-"),
rel=CMCL.HAS_QUANTITATIVE_PROPERTY)
elif modelFlag == KineticsSession.EAT_TWC:
# TWC
simulation_template = agent_cases.EAT_TWC
# Find TWC object
twc = search.find_cuds_objects_by_oclass(
CMCL.TWC, eat_process, rel=CMCL.HAS_PROPER_PARTICIPANT)[0]
# Add outputs
twc.add(CMCL.NOX_CAPTURE_EFFICIENCY(value=0.0, unit="-"),
CMCL.CO_CAPTURE_EFFICIENCY(value=0.0, unit="-"),
CMCL.CXHY_CAPTURE_EFFICIENCY(value=0.0, unit="-"),
rel=CMCL.HAS_QUANTITATIVE_PROPERTY)
else:
return "ERROR"
print("Detected simulation template as %s" %
(simulation_template.template))
return simulation_template
def registerOutput(root_cuds_object, json_out_list, json_inp_dict, outSemSynMap, synEntityToCUDSmap):
"""Registers the passed quantity as an output within the input list.
Arguments:
root_cuds_object -- Root of CUDS object representing inputs
json_out_list -- JSON list that would store a given output
json_inp_dict -- JSON inputs dictionary - used for special transformations
outSemSynMap -- object providing semantic-syntactic mapping for a given output
synEntityToCUDSmap -- Dictionary which stores a mapping between syntacitc (key) output
representation that engine understands and the concrete CUDS
instance that the it is associated with
"""
# Use the oclass name/type associated with a given input from inp_dict_loc dictionary to find the concrete cuds instance
# that represents this input
outputCUDS = search.find_cuds_objects_by_oclass(outSemSynMap.semEntity, root_cuds_object, rel=None)
if not outputCUDS:
return
outputCUDS = outputCUDS[0]
# Get syntactic output keys
synValueEntities = outSemSynMap.synValueEntity
# Register the outputs
json_out_list.extend(synValueEntities)
# Update synEntityToCUDSmap
CUDSAdaptor.updateOutputsCudsMap(outputCUDS, outSemSynMap, json_inp_dict, synEntityToCUDSmap)
def _create_input(self, sims, **kwargs):
with open(self._file_path_root + self._session._input_file, "w+") as f:
for s in sims:
total_energy = simple_search.find_cuds_objects_by_oclass(
oclass=QE.TotalEnergy, root=s, rel=QE.HAS_PART)[0].value
volume = simple_search.find_cuds_objects_by_oclass(
oclass=QE.Volume, root=s, rel=QE.HAS_PART)[0].value
f.write(f"{volume} {total_energy}\n")
self.params = {
"Lattice parameter": "au",
"type": "noncubic",
"equation of state": self._session._calculation_type,
"Input": self._file_path_root + self._session._input_file,
"Output": self._file_path_root + self._session._output_file,
}
super()._modify_input(sim, **kwargs)
def test_eat_gpf(eat_gpf_cuds: Cuds, flask_client, mocker) -> None:
wrapper = _case_runner(case_cuds=eat_gpf_cuds,
engine=EATEngine(),
model_flag=KineticsSession.EAT_GPF,
client=flask_client,
mocker=mocker)
# Find all the output CUDS
pm_eff = cuds_search.find_cuds_objects_by_oclass(
oclass=CMCL.PM_FILTRATION_EFFICIENCY, root=wrapper, rel=None)
pn_eff = cuds_search.find_cuds_objects_by_oclass(
oclass=CMCL.PN_FILTRATION_EFFICIENCY, root=wrapper, rel=None)
# check all the output CUDS
assert len(pm_eff) == 1
assert pm_eff[0].value != 0.0
assert len(pn_eff) == 1
assert pn_eff[0].value != 0.0
def test_find_cuds_objects_by_oclass(self):
"""Test find by cuba key."""
c, p1, p2, p3, n1, n2, s1 = get_test_city()
self.assertEqual(
find_cuds_objects_by_oclass(city.City, c, cuba.activeRelationship),
[c],
)
found = find_cuds_objects_by_oclass(city.Citizen, c,
cuba.activeRelationship)
self.assertEqual(len(found), 3)
self.assertEqual(set(found), {p1, p2, p3})
found = find_cuds_objects_by_oclass(city.Neighborhood, c,
cuba.activeRelationship)
self.assertEqual(set(found), {n1, n2})
self.assertEqual(len(found), 2)
self.assertEqual(
find_cuds_objects_by_oclass(city.Street, c,
cuba.activeRelationship),
[s1],
)
found = find_cuds_objects_by_oclass(cuba.Entity, c, cuba.relationship)
self.assertEqual(set(found), {c, p1, p2, p3, n1, n2, s1})
def registerInput(root_cuds_object, json_inp_dict, inpSemSynMap):
"""Registers the passed quantity as an input within the input JSON dict.
Arguments:
root_cuds_object -- Root of CUDS object representing inputs
json_inp_dict -- JSON dictionary that would store a given input syntactic representation
inpSemSynMap -- object providing semantic-syntactic mapping for a given input
"""
# Use the semEntity type associated with a given input from inpSemSynMap object to find the concrete cuds instance
# that represents this input
if inpSemSynMap.transFunc is not None:
inputValue, inputUnit = CUDSAdaptor.getTransformedInput(root_cuds_object, inpSemSynMap, json_inp_dict)
else:
inputCUDS = search.find_cuds_objects_by_oclass(inpSemSynMap.semEntity, root_cuds_object, rel=None)
if not inputCUDS:
return
inputCUDS = inputCUDS[0]
# Store input cuds value and unit. the engine only accepts the string values, hence the conversion
inputUnit = inputCUDS.unit
# NOTE in order to support two possible values in ontological entities (float and string) there
# are two "VALUE" cuds entities introduced: "VALUE" and "VALUE_STRING". These are further attached
# to appropriate cuds entities as attribtues. In order to check if a given cuds has either former
# or latter attribtue all its attributes names are put into a list below and are inspected.
# NOTE this code will likely change in the future once a proper vector datatype support is added
# to the simphony core
inputCUDSattributeNames = [str(attr_name).lower() for attr_name in inputCUDS.get_attributes().keys()]
if any('value_string' in attr_name for attr_name in inputCUDSattributeNames):
# this cuds value is stored via "value_string" attribute
inputValue = str(inputCUDS.value_string)
else:
inputValue = str(inputCUDS.value)
# Not a valid input parameter, do not register
if (inputValue == None) or (type(inputValue) is list and len(inputValue) == 0):
return
if inputValue == "":
return
# Register the input
# Get the syntactic description of this input value and unit keys that the engine will understand
inputSynValueKey = inpSemSynMap.synValueEntity
inputSynUnitKey = inpSemSynMap.synUnitEntity
json_inp_dict[inputSynValueKey] = inputValue
# update the unit key only once
if inputSynUnitKey is not None and inputSynUnitKey not in json_inp_dict:
json_inp_dict[inputSynUnitKey] = inputUnit
def test_eat_twc(eat_twc_cuds: Cuds, flask_client, mocker) -> None:
wrapper = _case_runner(case_cuds=eat_twc_cuds,
engine=EATEngine(),
model_flag=KineticsSession.EAT_TWC,
client=flask_client,
mocker=mocker)
# Find all the output CUDS
nox_capt_eff = cuds_search.find_cuds_objects_by_oclass(
oclass=CMCL.NOX_CAPTURE_EFFICIENCY, root=wrapper, rel=None)
co_capt_eff = cuds_search.find_cuds_objects_by_oclass(
oclass=CMCL.CO_CAPTURE_EFFICIENCY, root=wrapper, rel=None)
cxhy_capt_eff = cuds_search.find_cuds_objects_by_oclass(
oclass=CMCL.CXHY_CAPTURE_EFFICIENCY, root=wrapper, rel=None)
# check all the output CUDS
assert len(nox_capt_eff) == 1
assert nox_capt_eff[0].value != 0.0
assert len(co_capt_eff) == 1
assert co_capt_eff[0].value != 0.0
assert len(cxhy_capt_eff) == 1
assert cxhy_capt_eff[0].value != 0.0
def getTransformedInput(root_cuds_object, inpSemSynMap, json_inp_dict):
"""Transforms the value of a given input by
applying the transform function associated wits this input
in the inp_dict_loc dictionary.
Arguments:
root_cuds_object -- Root of CUDS object representing inputs
inpSemSynMap -- object providing semantic-syntactic mapping for a given input
json_inp_dict -- JSON dictionary that would store a given input
Returns:
transf_value -- value after the transform operation
transf_unit -- unit after the transform operation
"""
# get the transform function handle
transf_func = inpSemSynMap.transFunc
# assess all oclasses and their corresponding cuds instances needed
# for the transformation
transf_args_values = []
for semEntity in inpSemSynMap.semEntity:
inputCuds = search.find_cuds_objects_by_oclass(semEntity, root_cuds_object, rel=None)
if not inputCuds:
return
inputCuds = inputCuds[0]
# lookup the function arguments values and create the arguments array to be passed
# to the function
inputCUDSattributeNames = [str(attr_name).lower() for attr_name in inputCuds.get_attributes().keys()]
if any('value_string' in attr_name for attr_name in inputCUDSattributeNames):
# this cuds value is stored via "value_string" attribute
transf_args_values.append(inputCuds.value_string)
else:
transf_args_values.append(inputCuds.value)
# if defined, add extra arguments coming from transform function dependency on input values
if inpSemSynMap.transFuncInpDep is not None:
for inputDependencyKey in inpSemSynMap.transFuncInpDep:
transf_args_values.append(json_inp_dict[inputDependencyKey])
# call the transform function
transf_value, transf_unit = transf_func(*transf_args_values)
return transf_value, transf_unit
def determineTemplate(self, root_cuds_object, modelFlag) -> str:
"""Determines which simulation template to use based on the input
CUDS data.
Arguments:
root_cuds_object -- Root CUDS object representing input data
modelFlag -- Integer for model (see KineticsSession for values)
Returns:
Appropriate simulation template name
"""
# Find the CB Synthesis object
cb_synthesis = search.find_cuds_objects_by_oclass(
CMCL.CB_SYNTHESIS_PROCESS, root_cuds_object, rel=CMCL.HAS_PART)[0]
# Find the CB Powder object
cb_powder = search.find_cuds_objects_by_oclass(
CMCL.CARBON_BLACK_POWDER,
cb_synthesis,
rel=CMCL.HAS_PROPER_PARTICIPANT)[0]
if modelFlag == KineticsSession.CB_STOCHASIC:
# Stochastic
simulation_template = agent_cases.STOCH
# Initialise the relevant outputs
particle_psd = CMCL.PARTICLE_SIZE_DISTRIBUTION()
particle_psd.add(CMCL.PARTICLE_NUMBER_DENSITIES(value_string="",
unit=""),
CMCL.PARTICLE_SIZE_CLASSES(value_string="",
unit=""),
rel=CMCL.HAS_QUANTITATIVE_PROPERTY)
primary_psd = CMCL.PRIMARY_PARTICLE_SIZE_DISTRIBUTION()
primary_psd.add(CMCL.PRIMARY_PARTICLE_NUMBER_DENSITIES(
value_string="", unit=""),
CMCL.PRIMARY_PARTICLE_SIZE_CLASSES(value_string="",
unit=""),
rel=CMCL.HAS_QUANTITATIVE_PROPERTY)
# Add the outputs
cb_powder.add(CMCL.PARTICLE_MEAN_FRACTAL_DIMENSION(value=0.0,
unit=""),
particle_psd,
primary_psd,
rel=CMCL.HAS_QUANTITATIVE_PROPERTY)
elif modelFlag == KineticsSession.CB_MOMIC:
# MoMIC
simulation_template = agent_cases.MOMIC
# Add new outputs
cb_powder.add(CMCL.MEAN_PARTICLE_SIZE(value=0.0, unit=""),
CMCL.PARTICLE_NUMBER_DENSITY(value=0.0, unit=""),
CMCL.PARTICLE_VOLUME_FRACTION(value=0.0, unit=""),
rel=CMCL.HAS_QUANTITATIVE_PROPERTY)
else:
return "ERROR"
print("Detected simulation template as %s" %
(simulation_template.template))
return simulation_template
def findo(oclass, depth):
return simple_search.find_cuds_objects_by_oclass(oclass=oclass,
root=sim,
rel=QE.HAS_PART)
def _get_count(oclass):
count = 0
for i in simple_search.find_cuds_objects_by_oclass(
oclass=oclass, root=sim, rel=QE.HAS_PART):
count += 1
return count
