Updates Tests

Author: HendrikBorgelt

src/catcore/datamodel/catcore.py

@@ -1,5 +1,5 @@
 # Auto generated from catcore.yaml by pythongen.py version: 0.0.1
-# Generation date: 2025-12-11T14:30:24
+# Generation date: 2026-01-21T11:56:35
 # Schema: catcore-metadata
 #
 # id: https://w3id.org/nfdi4cat/catcore

tests/data/valid/Characterization-001.yaml

@@ -13,6 +13,7 @@ sample_pretreatment: ["calcined at 450C for 4 hours", "none", "degassed at 300C
 characterization_technique:
   # Powder XRD
   - identifier: "CHAR_TECH_001"
+    "@type": "PowderXRD"
     xray_source: ["Cu Kalpha (lambda = 1.5406 A)"]
     atmosphere: ["ambient air"]
     operation_mode: ["continuous scan"]
@@ -26,6 +27,7 @@ characterization_technique:
 
   # XPS
   - identifier: "CHAR_TECH_002"
+    "@type": "XPS"
     xray_source: ["Al Kalpha (1486.6 eV)"]
     total_acquisition_time: [1800.0]  # seconds
     number_of_scans: [10]
@@ -40,6 +42,7 @@ characterization_technique:
 
   # BET Surface Area
   - identifier: "CHAR_TECH_003"
+    "@type": "BET"
     adsorbate_gas: ["N2"]
     degassing_temperature: [300.0]  # Celsius
     measurement_temperature: [77.0]  # Kelvin
@@ -48,6 +51,7 @@ characterization_technique:
 
   # Temperature Programmed Reduction
   - identifier: "CHAR_TECH_004"
+    "@type": "TPR"
     reducing_gas_composition: ["5% H2/Ar"]
     heating_rate: [10.0]  # Celsius/min
     minimum_temperature: [50.0]  # Celsius

tests/data/valid/Reaction-001.yaml

@@ -7,6 +7,7 @@ software_package: ["VASP 6.3.0", "ASE 3.22.1"]
 
 simulation_method:
   - identifier: "SIM_METHOD_001"
+    "@type": "DFT"
     exchange_correlation_functional: ["PBE (Perdew-Burke-Ernzerhof)"]
     energy_cutoff: [450.0]  # eV
     convergence_criteria: ["energy: 1x10-5 eV, forces: 0.02 eV/A"]
@@ -17,6 +18,7 @@ simulation_method:
 calculated_property:
   # Surface properties
   - identifier: "CALC_PROP_001"
+    "@type": "Surfaces"
     surface_energy: [0.089]  # J/m²
     miller_indices: ["(111)"]
     slab_thickness: [12.75]  # Angstrom (5 layers)
@@ -25,17 +27,19 @@ calculated_property:
 
   # Electronic structure
   - identifier: "CALC_PROP_002"
+    "@type": "ElectronicStructure"
     material_composition: ["Pt(111) surface with adsorbed CO"]
     crystal_structure: ["fcc Pt substrate"]
     k_point_mesh: ["5x5x1 for surface calculations"]
     energy_cutoff: [450.0]  # eV
     smearing_method: ["Methfessel-Paxton, sigma=0.2 eV"]
     spin_polarized: [true]
-    band_path: ["|-M-K-|"]
+    band_path: ["Γ-M-K-Γ"]
     fermi_energy: [5.42]  # eV
 
   # Adsorption energies (as additional property)
   - identifier: "CALC_PROP_003"
+    "@type": "ThermodynamicStability"
     formation_energy: [-1.68]  # eV (CO adsorption energy)
     reference_energies: ["E(Pt_slab) = -261.70 eV, E(CO_gas) = -14.84 eV, E(Pt_slab+CO) = -278.22 eV"]
     energy_above_hull: [0.0]  # eV (most stable configuration)

tests/data/valid/Simulation-001.yaml

@@ -12,6 +12,8 @@ precursor:
 
 preparation_method:
   - identifier: "PREP_001"
+    # Add the @type field to specify the concrete class
+    "@type": "Impregnation"
     impregnation_type: ["wet_impregnation"]
     impregnation_duration: [4.0]  # hours
     impregnation_temperature: [25.0]  # Celsius

tests/data/valid/Synthesis-001.yaml

@@ -14,7 +14,6 @@
 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': {
@@ -24,11 +23,30 @@
     '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',  # or DepositionPrecipitation
+    'precipitating_agent': 'CoPrecipitation',
     'hydrolysis_ratio': 'SolGel',
     'filling_volume': 'Solvothermal',
     'plasma_type': 'PlasmaAssisted',
@@ -38,7 +56,6 @@
     'sonication_power': 'SonochemicalSynthesis',
     'flame_type': 'FlameSprayPyrolysis',
     'ball_material': 'MechanochemicalSynthesis',
-    'synthesis_pressure': 'Sublimation',
     'reaction_vessel': 'MolecularSynthesis',
 }
 
@@ -57,10 +74,25 @@
     '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]) -> str:
+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:
@@ -71,7 +103,9 @@ def infer_class_type(data: Dict[str, Any], type_map: Dict[str, Any]) -> str:
                         return cn
             else:
                 return class_name
-    return None
+
+    # 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]:
@@ -82,32 +116,51 @@ def instantiate_polymorphic_objects(data: Union[Dict, List], parent_key: str = N
     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 = infer_class_type(result, CHARACTERIZATION_TECHNIQUE_MAP)
+        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 = infer_class_type(result, PREPARATION_METHOD_MAP)
+        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 = infer_class_type(result, SIMULATION_METHOD_MAP)
+        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 = infer_class_type(result, CALCULATED_PROPERTY_MAP)
+        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)
@@ -126,7 +179,18 @@ def test_valid_data_files(filepath):
         data_dict = yaml.safe_load(f)
 
     # Handle polymorphic fields by instantiating concrete classes
-    for poly_field in ['characterization_technique', 'preparation_method', 'simulation_method', 'calculated_property']:
+    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],