Added new chemked schema for new experiment types

pyked/chemked.py

@@ -627,7 +627,8 @@ class DataPoint(object):
     """
     value_unit_props = [
         'ignition-delay', 'first-stage-ignition-delay', 'temperature', 'pressure',
-        'pressure-rise',
+        'pressure-rise', 'laminar-burning-velocity', 'distance', 'flow-rate',
+        'residence-time', 'volumetric-flow-in-reference-state',
     ]
 
     rcm_data_props = [
@@ -656,19 +657,49 @@ def __init__(self, properties):
         else:
             self.rcm_data = None
 
-        self.composition_type = properties['composition']['kind']
-        composition = {}
-        for species in properties['composition']['species']:
-            species_name = species['species-name']
-            amount = self.process_quantity(species['amount'])
-            InChI = species.get('InChI')
-            SMILES = species.get('SMILES')
-            atomic_composition = species.get('atomic-composition')
-            composition[species_name] = Composition(
-                species_name=species_name, InChI=InChI, SMILES=SMILES,
-                atomic_composition=atomic_composition, amount=amount)
-
-        setattr(self, 'composition', composition)
+        if 'composition' in properties:
+            self.composition_type = properties['composition']['kind']
+            composition = {}
+            for species in properties['composition']['species']:
+                species_name = species['species-name']
+                amount = self.process_quantity(species['amount'])
+                InChI = species.get('InChI')
+                SMILES = species.get('SMILES')
+                atomic_composition = species.get('atomic-composition')
+                composition[species_name] = Composition(
+                    species_name=species_name, InChI=InChI, SMILES=SMILES,
+                    atomic_composition=atomic_composition, amount=amount)
+            setattr(self, 'composition', composition)
+        else:
+            self.composition_type = None
+            self.composition = {}
+
+        # Measured composition (for JSR, OCM, BSFSM experiment types)
+        if 'measured-composition' in properties:
+            self.measured_composition_type = properties['measured-composition']['kind']
+            measured = {}
+            for species in properties['measured-composition']['species']:
+                species_name = species['species-name']
+                amount = self.process_quantity(species['amount'])
+                InChI = species.get('InChI')
+                SMILES = species.get('SMILES')
+                atomic_composition = species.get('atomic-composition')
+                measured[species_name] = Composition(
+                    species_name=species_name, InChI=InChI, SMILES=SMILES,
+                    atomic_composition=atomic_composition, amount=amount)
+            self.measured_composition = measured
+        else:
+            self.measured_composition_type = None
+            self.measured_composition = {}
+
+        # Concentration profiles (for concentration time profile measurement)
+        self.concentration_profiles = []
+        if 'concentration-profiles' in properties:
+            for profile in properties['concentration-profiles']:
+                self.concentration_profiles.append(profile)
+
+        # Time shift (for concentration time profile measurement)
+        self.time_shift = properties.get('time-shift')
 
         self.equivalence_ratio = properties.get('equivalence-ratio')
         self.ignition_type = deepcopy(properties.get('ignition-type'))

pyked/converters.py

@@ -19,7 +19,9 @@
 
 # Valid properties for ReSpecTh dataGroup
 datagroup_properties = ['temperature', 'pressure', 'ignition delay',
-                        'pressure rise',
+                        'pressure rise', 'laminar burning velocity',
+                        'distance', 'flow rate', 'residence time',
+                        'volumetric flow in reference state',
                         ]
 """`list`: Valid properties for a ReSpecTh dataGroup"""
 
@@ -159,20 +161,38 @@ def get_experiment_kind(root):
         properties (`dict`): Dictionary with experiment type and apparatus information.
     """
     properties = {}
-    if root.find('experimentType').text == 'Ignition delay measurement':
-        properties['experiment-type'] = 'ignition delay'
-    else:
-        raise NotImplementedError(root.find('experimentType').text + ' not (yet) supported')
+
+    exp_type_text = getattr(root.find('experimentType'), 'text', '')
+    exp_type_map = {
+        'Ignition delay measurement': 'ignition delay',
+        'Laminar burning velocity measurement': 'laminar burning velocity measurement',
+        'Concentration time profile measurement': 'concentration time profile measurement',
+        'Jet stirred reactor measurement': 'jet stirred reactor measurement',
+        'Outlet concentration measurement': 'outlet concentration measurement',
+        'Burner stabilized flame speciation measurement': 'burner stabilized flame speciation measurement',
+    }
+    matched_type = exp_type_map.get(exp_type_text)
+    if matched_type is None:
+        # Try case-insensitive match
+        for key, val in exp_type_map.items():
+            if key.lower() == exp_type_text.lower():
+                matched_type = val
+                break
+    if matched_type is None:
+        raise NotImplementedError(exp_type_text + ' not (yet) supported')
+    properties['experiment-type'] = matched_type
 
     properties['apparatus'] = {'kind': '', 'institution': '', 'facility': ''}
     kind = getattr(root.find('apparatus/kind'), 'text', False)
     # Test for missing attribute or empty string
     if not kind:
         raise MissingElementError('apparatus/kind')
-    elif kind in ['shock tube', 'rapid compression machine']:
-        properties['apparatus']['kind'] = kind
     else:
-        raise NotImplementedError(kind + ' experiment not (yet) supported')
+        properties['apparatus']['kind'] = kind
+
+    mode = getattr(root.find('apparatus/mode'), 'text', None)
+    if mode:
+        properties['apparatus']['mode'] = mode
 
     return properties
 
@@ -503,25 +523,28 @@ def ReSpecTh_to_ChemKED(filename_xml, file_author='', file_author_orcid='', *, v
     # Get properties shared across the file
     properties['common-properties'] = get_common_properties(root)
 
-    # Determine definition of ignition delay
-    properties['common-properties']['ignition-type'] = get_ignition_type(root)
+    # Determine definition of ignition delay (only for ignition delay experiments)
+    if properties['experiment-type'] == 'ignition delay':
+        properties['common-properties']['ignition-type'] = get_ignition_type(root)
 
-    # Now parse ignition delay datapoints
+    # Now parse datapoints
     properties['datapoints'] = get_datapoints(root)
 
-    # Ensure inclusion of pressure rise or volume history matches apparatus.
-    has_pres_rise = ('pressure-rise' in properties['common-properties'] or
-                     any([True for dp in properties['datapoints'] if 'pressure-rise' in dp])
-                     )
-    if has_pres_rise and properties['apparatus']['kind'] == 'rapid compression machine':
-        raise KeywordError('Pressure rise cannot be defined for RCM.')
-
-    has_vol_hist = any(
-        [t.get('type') == 'volume' for dp in properties['datapoints']
-         for t in dp.get('time-histories', [{}])]
-    )
-    if has_vol_hist and properties['apparatus']['kind'] == 'shock tube':
-        raise KeywordError('Volume history cannot be defined for shock tube.')
+    # Ensure inclusion of pressure rise or volume history matches apparatus
+    # (only relevant for ignition delay experiments)
+    if properties['experiment-type'] == 'ignition delay':
+        has_pres_rise = ('pressure-rise' in properties['common-properties'] or
+                         any([True for dp in properties['datapoints'] if 'pressure-rise' in dp])
+                         )
+        if has_pres_rise and properties['apparatus']['kind'] == 'rapid compression machine':
+            raise KeywordError('Pressure rise cannot be defined for RCM.')
+
+        has_vol_hist = any(
+            [t.get('type') == 'volume' for dp in properties['datapoints']
+             for t in dp.get('time-histories', [{}])]
+        )
+        if has_vol_hist and properties['apparatus']['kind'] == 'shock tube':
+            raise KeywordError('Volume history cannot be defined for shock tube.')
 
     # add any additional file authors
     if file_author_orcid and not file_author:

pyked/schemas/burner_stabilized_flame_speciation_measurement_schema.yaml

@@ -0,0 +1,16 @@
+# Schema for burner stabilized flame speciation measurement datapoints
+burner-stabilized-flame-speciation-measurement-schema: &burner-stabilized-flame-speciation-measurement-schema
+  type: list
+  minlength: 1
+  schema:
+    type: dict
+    schema:
+      pressure: *value-unit-required
+      temperature: *value-unit-required
+      composition: *composition
+      equivalence-ratio:
+        type: float
+        min: 0.0
+      distance: *value-unit-required
+      flow-rate: *value-unit-optional
+      measured-composition: *composition

pyked/schemas/chemked_schema.yaml

@@ -7,6 +7,11 @@
 !include value_unit_schema.yaml
 !include composition_schema.yaml
 !include ignition_delay_schema.yaml
+!include laminar_burning_velocity_measurement_schema.yaml
+!include concentration_time_profile_measurement_schema.yaml
+!include jet_stirred_reactor_measurement_schema.yaml
+!include outlet_concentration_measurement_schema.yaml
+!include burner_stabilized_flame_speciation_measurement_schema.yaml
 ######################################################
 
 # Common reference for authors' information
@@ -26,9 +31,16 @@ common-properties:
   type: dict
   schema:
     pressure: *value-unit-optional
+    temperature: *value-unit-optional
     ignition-type: *ignition-type
     composition: *composition
     pressure-rise: *value-unit-optional
+    residence-time: *value-unit-optional
+    reactor-volume: *value-unit-optional
+    flow-rate: *value-unit-optional
+    equivalence-ratio:
+      type: float
+      min: 0.0
 
 apparatus:
   required: true
@@ -38,8 +50,37 @@ apparatus:
       allowed:
         - shock tube
         - rapid compression machine
+        - stirred reactor
+        - stirred reactor (quartz)
+        - stirred reactor (fused silica)
+        - stirred reaction
+        - jet stirred reactor
+        - flow reactor
+        - flow reactor (quartz)
+        - flow reactor (alumina)
+        - flow reactor (recrystallized alumina)
+        - flame
+        - outwardly propagating spherical flame
+        - heat flux burner
       required: true
       type: string
+    mode:
+      type: string
+      allowed:
+        - reflected shock
+        - incident shock
+        - laminar
+        - burner stabilized
+        - constant volume combustion chamber
+        - premixed
+        - unstretched
+        - extrapolation method to zero stretch : LS
+        - extrapolation method to zero stretch : NQ
+        - counterflow
+        - OPF
+        - HFM
+        - CTF
+        - SFF
     institution:
       type: string
     facility:
@@ -48,6 +89,11 @@ datapoints:
   required: true
   oneof:
     - *ignition-delay-schema
+    - *laminar-burning-velocity-measurement-schema
+    - *concentration-time-profile-measurement-schema
+    - *jet-stirred-reactor-measurement-schema
+    - *outlet-concentration-measurement-schema
+    - *burner-stabilized-flame-speciation-measurement-schema
 reference:
   required: true
   type: dict
@@ -93,6 +139,11 @@ chemked-version:  # TODO: Implement proper version comparison
 experiment-type:
   allowed:
     - ignition delay
+    - laminar burning velocity measurement
+    - concentration time profile measurement
+    - jet stirred reactor measurement
+    - outlet concentration measurement
+    - burner stabilized flame speciation measurement
   required: true
   type: string
 file-authors:

pyked/schemas/concentration_time_profile_measurement_schema.yaml

@@ -0,0 +1,70 @@
+# Schema for concentration time profile measurement datapoints
+#
+# time-shift defines the t=0 reference for the profile
+time-shift: &time-shift
+  type: dict
+  schema:
+    target:
+      required: true
+      type: string
+    type:
+      required: true
+      type: string
+      allowed:
+        - half decrease
+        - relative decrease
+    amount: *value-unit-optional
+
+concentration-time-profile-measurement-schema: &concentration-time-profile-measurement-schema
+  type: list
+  minlength: 1
+  schema:
+    type: dict
+    schema:
+      pressure: *value-unit-required
+      temperature: *value-unit-required
+      composition: *composition
+      equivalence-ratio:
+        type: float
+        min: 0.0
+      concentration-profiles:
+        type: list
+        required: true
+        minlength: 1
+        schema:
+          type: dict
+          schema:
+            species-name:
+              type: string
+              required: true
+            InChI:
+              type: string
+            SMILES:
+              type: string
+            quantity:
+              required: true
+              type: dict
+              schema:
+                units:
+                  required: true
+                  type: string
+            time:
+              required: true
+              type: dict
+              schema:
+                units:
+                  required: true
+                  type: string
+            values:
+              required: true
+              type: list
+              minlength: 2
+              schema:
+                type: list
+                oneof_items:
+                  - - type: float
+                    - type: float
+                  - - type: float
+                    - type: float
+                    - type: float
+      time-shift: *time-shift

pyked/schemas/jet_stirred_reactor_measurement_schema.yaml

@@ -0,0 +1,14 @@
+# Schema for jet stirred reactor measurement datapoints
+jet-stirred-reactor-measurement-schema: &jet-stirred-reactor-measurement-schema
+  type: list
+  minlength: 1
+  schema:
+    type: dict
+    schema:
+      pressure: *value-unit-required
+      temperature: *value-unit-required
+      composition: *composition
+      equivalence-ratio:
+        type: float
+        min: 0.0
+      measured-composition: *composition

pyked/schemas/laminar_burning_velocity_measurement_schema.yaml

@@ -0,0 +1,15 @@
+# Schema for laminar burning velocity measurement datapoints
+laminar-burning-velocity-measurement-schema: &laminar-burning-velocity-measurement-schema
+  type: list
+  minlength: 1
+  schema:
+    type: dict
+    schema:
+      pressure: *value-unit-required
+      temperature: *value-unit-required
+      laminar-burning-velocity: *value-unit-required
+      pressure-rise: *value-unit-optional
+      composition: *composition
+      equivalence-ratio:
+        type: float
+        min: 0.0