Update docs, test fixtures, and test loader

Adjust docs and mkdocs config (switch Simulation emoji token and enable pymdownx.emoji with twemoji/svg). Add Reaction-001 fixture, remove Simulation-001, and normalize/update Characterization-001 and Synthesis-001 YAML fixtures (IDs, units, new fields like realized_plan/evaluated_entity/had_input_entity, clearer descriptions). Refactor tests/test_data.py to import src.catcore.datamodel.catcore and use linkml_runtime.yaml_loader.load for loading target classes, removing the previous custom polymorphic-instantiation logic and yaml dependency. These changes align test data with the loader/schema and simplify test loading.

Author: HendrikBorgelt

docs/overview.md

@@ -19,7 +19,7 @@ description: Comprehensive Metadata Guidelines for Catalysis Research Data
 
     Eight reactor design types, flattened operation parameter slots, and product identification links.
 
--   :material-cpu-64-bit: **Simulation**
+-   :octicons-cpu-16: **Simulation**
 
     Four computational methods (DFT, MD, Microkinetics, Monte Carlo) with 12 calculated property classes.
 

mkdocs.yml

@@ -70,3 +70,6 @@ markdown_extensions:
   - md_in_html
   - admonition
   - attr_list
+  - pymdownx.emoji:
+      emoji_index: !!python/name:material.extensions.emoji.twemoji
+      emoji_generator: !!python/name:material.extensions.emoji.to_svg

tests/data/valid/Characterization-001.yaml

@@ -1,14 +1,31 @@
 ---
-# Complete Characterization Instance
-# This represents a Characterization object as defined in the schema
+# Characterization-001 -- Powder XRD of 5 wt% Pt/Al2O3
+# Target class: Characterization
+#
+# NOTE: realized_plan range is CharacterizationTechnique (abstract, no domain slots).
+# Technique parameters from catcore_common (atmosphere, temperature, step_size, etc.)
+# are accepted directly on Characterization. XRD-specific slots (xray_source etc.)
+# live on PowderXRD subclass — not reachable by the loader, so omitted here.
+# realized_plan: title/description only.
 
-identifier: "CHAR_001_Pt_Al2O3"
-equipment: ["Bruker D8 Advance diffractometer"]
-sample_state: ["powder"]
-sample_description: ["5 wt% Pt/Al2O3 catalyst after calcination at 450C"]
-detector_type: ["Lynxeye detector"]
-sample_preparation: ["pressed into sample holder without binder"]
-sample_pretreatment: ["calcined at 450C for 4 hours"]
+id: "catcore:CHAR_001_PXRD_Pt_Al2O3"
+equipment:
+  - "Bruker D8 Advance diffractometer"
+sample_state:
+  - "powder"
+sample_description:
+  - "5 wt% Pt/Al2O3 catalyst after calcination at 450 deg C"
+detector_type:
+  - "Lynxeye XE-T detector"
+sample_preparation:
+  - "pressed into flat sample holder without binder"
+sample_pretreatment:
+  - "calcined at 450 deg C for 4 hours in static air"
+  
+evaluated_entity:
+  - id: "catcore:CATSAMPLE_001_Pt_Al2O3"
+    title: "5 wt% Pt/Al2O3 catalyst"
 
-characterization_technique:
-  - identifier: "CHAR_TECH_001"
+realized_plan:
+  title: "powder XRD, Cu Kalpha, 5-80 deg 2theta"
+  description: "Bruker D8 Advance, Cu Kalpha 40kV/40mA, Ni beta-filter, Lynxeye detector"

tests/data/valid/Reaction-001.yaml

@@ -0,0 +1,31 @@
+---
+# Reaction-001 -- CO oxidation over 5 wt% Pt/Al2O3 in a fixed bed reactor
+# Target class: Reaction
+# carried_out_by:              list, keyed by id (ReactorDesignType is_a Device/AgenticEntity, keyed)
+# product_identification_method: list, no id (ProductIdentificationMethod is_a Plan, not keyed)
+
+id: "catcore:REACT_001_CO_oxidation_Pt_Al2O3"
+catalyst_quantity:
+  - 0.1
+catalyst_type:
+  - "heterogeneous catalyst"
+reactant:
+  - "CO, 1 vol% in N2"
+  - "O2, 2 vol% in N2"
+atmosphere:
+  - "1 vol% CO, 2 vol% O2, balance N2"
+feed_composition_range:
+  - "1 vol% CO, 2 vol% O2, balance N2"
+reactor_temperature_range:
+  - "100-300 deg C"
+experiment_pressure:
+  - 1.0
+experiment_duration:
+  - 5.0
+
+carried_out_by:
+  - id: "catcore:REACTOR_001_fixedbed"
+    title: "quartz fixed bed reactor, 6 mm inner diameter"
+
+product_identification_method:
+  - title: "online GC-MS analysis of reactor effluent"

tests/data/valid/Simulation-001.yaml

@@ -1,20 +1,30 @@
 ---
-# Complete Synthesis Instance
-# This represents a Synthesis object as defined in the schema
+# Synthesis-001 -- Incipient wetness impregnation of 5 wt% Pt/Al2O3
+# Target class: Synthesis
+#
+# NOTE: realized_plan range is PreparationMethod (abstract, no domain slots).
+# Domain synthesis parameters that live on catcore_common ARE accepted on Synthesis directly.
+# realized_plan: title/description only — the loader cannot dispatch to Impregnation subclass.
 
+id: "catcore:SYNTH_001_Pt_Al2O3"
+nominal_composition:
+  - "5 wt% Pt/Al2O3"
+catalyst_measured_properties:
+  - "BET surface area: 185 m2/g, Pt particle size: 2.3 nm (TEM), Pt loading: 4.8 wt% (ICP-AES)"
+storage_conditions:
+  - "stored in desiccator under argon atmosphere at room temperature"
+support:
+  - "gamma-Al2O3, Sasol Puralox, 200 m2/g"
+solvent:
+  - "deionized water"
+sample_pretreatment:
+  - "reduction in H2 at 400 deg C for 2 hours prior to catalytic testing"
+had_input_entity:
+  - id: "catcore:PREC_001_H2PtCl6"
+    title: "chloroplatinic acid hexahydrate"
+    precursor_quantity:
+      - 0.0485
 
-
-identifier: "SYNTH_001_Pt_Al2O3"
-nominal_composition: "5 wt% Pt/Al2O3"
-catalyst_measured_properties: "BET surface area: 185 m²/g, Pt particle size: 2.3 nm (TEM), Pt loading: 4.8 wt% (ICP-AES)"
-storage_conditions: ["stored in desiccator under argon atmosphere at room temperature"]
-support: ["γ-Al2O3, Sasol Puralox, 200 m²/g"]
-solvent: ["deionized water", "ethanol"]
-sample_pretreatment: ["reduction in H2 at 400°C for 2 hours prior to catalytic testing"]
-
-precursor:
-  - identifier: "PREC_001"
-    precursor_quantity: [0.0485]
-
-preparation_method:
-  - identifier: "PREP_001"
+realized_plan:
+  title: "incipient wetness impregnation"
+  description: "incipient_wetness, 25 deg C, 12 h"

tests/data/valid/Synthesis-001.yaml

@@ -1,11 +1,10 @@
+"""Data test."""
 import os
 import glob
 import pytest
-import yaml
 from pathlib import Path
-from typing import Dict, Any, Union, List
 
-from catcore.datamodel import catcore
+import src.catcore.datamodel.catcore
 from linkml_runtime.loaders import yaml_loader
 
 DATA_DIR_VALID = Path(__file__).parent / "data" / "valid"
@@ -14,190 +13,14 @@
 VALID_EXAMPLE_FILES = glob.glob(os.path.join(DATA_DIR_VALID, '*.yaml'))
 INVALID_EXAMPLE_FILES = glob.glob(os.path.join(DATA_DIR_INVALID, '*.yaml'))
 
-# Mapping from identifier patterns or context to concrete class names
-CHARACTERIZATION_TECHNIQUE_MAP = {
-    'xray_source': {
-        'Cu Kalpha': 'PowderXRD',
-        'Al Kalpha': 'XPS',
-    },
-    'adsorbate_gas': 'BET',
-    'reducing_gas_composition': 'TPR',
-    'oxidizing_gas_composition': 'TPO',
-    'excitation_laser_wavelength': 'RamanSpectroscopy',
-    'minimum_wavenumber': 'InfraredSpectroscopy',
-    'element_analyzed': 'XRayAbsorptionSpectroscopy',
-    'nucleus': 'NMRSpectroscopy',
-    'gun_type': 'TransmissionElectronMicroscopy',
-    'image_resolution': 'ScanningElectronMicroscopy',
-    'initial_temperature': 'Thermogravimetry',
-    'combustion_temperature': 'ElementalAnalysis',
-    'minimum_wavelength': 'UVVisSpectroscopy',
-    'adsorption_gas': 'DRIFTS',
-    'scan_rate': 'CyclicVoltammetry',
-    'light_wavelength': 'DynamicLightScattering',
-    'spray_voltage': 'ESI_MS',
-    'excitation_wavelength': 'PhotoluminescenceSpectroscopy',
-    'lifetime_fitting_model': 'PhotoluminescenceLifetime',
-    'eluent': 'SizeExclusionChromatography',
-    'gradient_program': 'HPLC_MS',
-    'primary_energy': 'EDX',
-    'electrode_configuration': 'ConductivityMeasurement',
-}
-
-PREPARATION_METHOD_MAP = {
-    'impregnation_type': 'Impregnation',
-    'precipitating_agent': 'CoPrecipitation',
-    'hydrolysis_ratio': 'SolGel',
-    'filling_volume': 'Solvothermal',
-    'plasma_type': 'PlasmaAssisted',
-    'fuel': 'CombustionSynthesis',
-    'substrate': 'AtomicLayerDeposition',
-    'microwave_frequency': 'MicrowaveAssisted',
-    'sonication_power': 'SonochemicalSynthesis',
-    'flame_type': 'FlameSprayPyrolysis',
-    'ball_material': 'MechanochemicalSynthesis',
-    'reaction_vessel': 'MolecularSynthesis',
-}
-
-SIMULATION_METHOD_MAP = {
-    'exchange_correlation_functional': 'DFT',
-    'force_field': 'MolecularDynamics',
-    'rate_constants': 'Microkinetics',
-    'interaction_potential': 'MonteCarlo',
-}
-
-CALCULATED_PROPERTY_MAP = {
-    'formation_energy': 'ThermodynamicStability',
-    'piezoelectric_tensor': 'Piezoelectricity',
-    'elastic_tensor': 'ElasticConstants',
-    'surface_energy': 'Surfaces',
-    'band_path': 'ElectronicStructure',
-    'polarization_direction': 'Ferroelectrics',
-    'direct_indirect': 'BandGap',
-    'material_composition': 'DielectricTensors',
-    'force_constant_method': 'PhononDispersion',
-    'fit_method': 'EquationsOfState',
-    'ph_range': 'AqueousStability',
-    'grain_boundary_plane': 'GrainBoundaries',
-}
-
-REACTOR_DESIGN_MAP = {
-    'gas_distributor_type': 'FluidizedBedReactor',
-}
-
-# Default classes for abstract types when no specific fields are found
-DEFAULT_CLASSES = {
-    'reactor_design_type': 'FixedBedReactor',
-    'product_identification_method': 'GCMS',
-}
-
-
-def infer_class_type(data: Dict[str, Any], type_map: Dict[str, Any], default_class: str = None) -> str:
-    """Infer the concrete class type based on present fields."""
-    for key, class_name in type_map.items():
-        if key in data:
-            if isinstance(class_name, dict):
-                # Need to check value
-                for value_pattern, cn in class_name.items():
-                    if value_pattern in str(data[key]):
-                        return cn
-            else:
-                return class_name
-
-    # Return default class if no specific fields found
-    return default_class
-
-
-def instantiate_polymorphic_objects(data: Union[Dict, List], parent_key: str = None) -> Union[Dict, List]:
-    """Recursively instantiate concrete classes for polymorphic fields."""
-    if isinstance(data, list):
-        return [instantiate_polymorphic_objects(item, parent_key) for item in data]
-
-    if not isinstance(data, dict):
-        return data
-
-    # Check for explicit type hint (both 'type' and '@type' for LinkML compatibility)
-    explicit_type = data.get('type') or data.get('@type')
-
-    # Recursively process nested structures first
-    result = {}
-    for key, value in data.items():
-        if key in ('type', '@type'):  # Skip the type hint fields
-            continue
-        result[key] = instantiate_polymorphic_objects(value, key)
-
-    # Now handle polymorphic instantiation for specific keys
-    if parent_key == 'characterization_technique':
-        class_name = explicit_type or infer_class_type(result, CHARACTERIZATION_TECHNIQUE_MAP)
-        if class_name:
-            cls = getattr(catcore, class_name)
-            return cls(**result)
-
-    elif parent_key == 'preparation_method':
-        class_name = explicit_type or infer_class_type(result, PREPARATION_METHOD_MAP)
-        if class_name:
-            cls = getattr(catcore, class_name)
-            return cls(**result)
-
-    elif parent_key == 'simulation_method':
-        class_name = explicit_type or infer_class_type(result, SIMULATION_METHOD_MAP)
-        if class_name:
-            cls = getattr(catcore, class_name)
-            return cls(**result)
-
-    elif parent_key == 'calculated_property':
-        class_name = explicit_type or infer_class_type(result, CALCULATED_PROPERTY_MAP)
-        if class_name:
-            cls = getattr(catcore, class_name)
-            return cls(**result)
-
-    elif parent_key == 'reactor_design_type':
-        class_name = explicit_type or infer_class_type(result, REACTOR_DESIGN_MAP,
-                                                       DEFAULT_CLASSES.get('reactor_design_type'))
-        if class_name:
-            cls = getattr(catcore, class_name)
-            return cls(**result)
-
-    elif parent_key == 'product_identification_method':
-        # For now, use GCMS as default if no specific fields found
-        class_name = explicit_type or DEFAULT_CLASSES.get('product_identification_method')
-        if class_name:
-            cls = getattr(catcore, class_name)
-            return cls(**result)
-
-    return result
-
 
 @pytest.mark.parametrize("filepath", VALID_EXAMPLE_FILES)
 def test_valid_data_files(filepath):
     """Test loading of all valid data files."""
     target_class_name = Path(filepath).stem.split("-")[0]
-    tgt_class = getattr(catcore, target_class_name)
-
-    # Load the YAML content
-    with open(filepath, 'r') as f:
-        data_dict = yaml.safe_load(f)
-
-    # Handle polymorphic fields by instantiating concrete classes
-    poly_fields = [
-        'characterization_technique',
-        'preparation_method',
-        'simulation_method',
-        'calculated_property',
-        'reactor_design_type',
-        'product_identification_method',
-        'operation_parameters',
-        'precursor'
-    ]
-
-    for poly_field in poly_fields:
-        if poly_field in data_dict and data_dict[poly_field]:
-            data_dict[poly_field] = instantiate_polymorphic_objects(
-                data_dict[poly_field],
-                poly_field
-            )
-
-    # Instantiate the target class
-    obj = tgt_class(**data_dict)
-
+    tgt_class = getattr(
+        src.catcore.datamodel.catcore,
+        target_class_name,
+    )
+    obj = yaml_loader.load(filepath, target_class=tgt_class)
     assert obj