crystal: Re-introduced phase fractions attribute

Author: Somerandomguy10111

exports.py

@@ -0,0 +1,56 @@
+@classmethod
+def make_empty(cls, is_simulated: bool = False, num_phases: int = 1) -> PowderExperiment:
+    phases = []
+    for j in range(num_phases):
+        lengths = (float('nan'), float('nan'), float('nan'))
+        angles = (float('nan'), float('nan'), float('nan'))
+        base = CrystalBasis.empty()
+
+        p = CrystalStructure(lengths=lengths, angles=angles, basis=base)
+        phases.append(p)
+
+    xray_info = XrayInfo.mk_empty()
+    return cls(phases=phases, crystallite_size=None, temp_in_celcius=None, xray_info=xray_info,
+               is_simulated=is_simulated)
+
+
+def get_list_repr(self) -> list:
+    list_repr = []
+    structure = self.phases[0]
+
+    a, b, c = structure.lengths
+    alpha, beta, gamma = structure.angles
+    lattice_params = [a, b, c, alpha, beta, gamma]
+    list_repr += lattice_params
+
+    base = structure.basis
+    padded_base = self.get_padded_base(base=base, nan_padding=base.is_empty())
+    for atomic_site in padded_base:
+        list_repr += atomic_site.as_list()
+
+    if structure.spacegroup is None:
+        spg_logits_list = [float('nan') for _ in range(NUM_SPACEGROUPS)]
+    else:
+        spg_logits_list = [1000 if j + 1 == structure.spacegroup else 0 for j in range(NUM_SPACEGROUPS)]
+    list_repr += spg_logits_list
+
+    list_repr += self.xray_info.as_list()
+    list_repr += [self.is_simulated]
+
+    return list_repr
+
+@staticmethod
+def get_padded_base(base: CrystalBasis, nan_padding : bool) -> CrystalBasis:
+    def make_padding_site():
+        if nan_padding:
+            site = AtomSite.make_placeholder()
+        else:
+            site = AtomSite.make_void()
+        return site
+
+    delta = MAX_ATOMIC_SITES - len(base)
+    if delta < 0:
+        raise ValueError(f'Base is too large! Size = {len(base)} exceeds MAX_ATOMIC_SITES = {MAX_ATOMIC_SITES}')
+
+    padded_base = base + [make_padding_site() for _ in range(delta)]
+    return padded_base

tests/t_crystal/t_properties.py

@@ -1,3 +1,5 @@
+from pymatgen.core import Lattice
+
 import tests.t_crystal.base_crystal as BaseTest
 from xrdpattern.crystal import CrystalStructure, CrystalBasis
 
@@ -8,15 +10,15 @@ class TestCifParsing(BaseTest.CrystalTest):
     def test_lattice_parameters(self):
         expected_lengths = [(5.801, 11.272, 5.57), (4.0809,4.0809,4.0809)]
         for crystal, (a_exp, b_exp, c_exp) in zip(self.custom_structures, expected_lengths):
-            a, b, c = crystal.lengths
+            a, b, c = crystal.lattice.lengths
             self.assertAlmostEqual(a, a_exp, places=3)
             self.assertAlmostEqual(b, b_exp, places=4)
             self.assertAlmostEqual(c, c_exp, places=3)
 
     def test_angles(self):
         expected_angles = [(90, 90, 90), (89.676, 89.676, 89.676)]
         for crystal, (alpha_exp, beta_exp, gamma_exp) in zip(self.custom_structures, expected_angles):
-            alpha, beta, gamma = crystal.angles
+            alpha, beta, gamma = crystal.lattice.angles
             self.assertEqual(alpha, alpha_exp)
             self.assertAlmostEqual(beta, beta_exp, places=3)
             self.assertEqual(gamma, gamma_exp)
@@ -34,7 +36,8 @@ def test_to_cif(self):
             print(f'CIF = \n{cif}')
 
     def test_standardize(self):
-        phase = CrystalStructure(lengths=(5.801, 11.272, 5.57), angles=(90, 90, 90), basis=CrystalBasis.empty())
+        lattice = Lattice.from_parameters(5.801, 11.272, 5.57, 90, 90, 90)
+        phase = CrystalStructure(lattice=lattice, basis=CrystalBasis.empty())
         new_phase = phase.get_standardized()
 
         self.assertTrue(len(new_phase.basis) == 0)

xrdpattern/crystal/components/base.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-import math
 import json
-from typing import Optional, Iterable
-from xrdpattern.serialization import Serializable
+import math
+from typing import Iterable
 
+from xrdpattern.serialization import Serializable
 from .atomic_site import AtomSite
 
 

xrdpattern/crystal/components/crystal.py

@@ -8,13 +8,11 @@
 from distlib.util import cached_property
 from pymatgen.core import Structure, Lattice, Species, Element
 from pymatgen.symmetry.analyzer import SpacegroupAnalyzer
-from pymatgen.symmetry.groups import SpaceGroup
 
 from xrdpattern.serialization import JsonDataclass
 from .atomic_site import AtomSite
 from .base import CrystalBasis
 
-
 logger = logging.getLogger(__name__)
 CrystalSystem = Literal["cubic", "hexagonal", "monoclinic", "orthorhombic", "tetragonal", "triclinic", "trigonal"]
 # ---------------------------------------------------------
@@ -26,6 +24,11 @@ class CrystalStructure(JsonDataclass):
     spacegroup : Optional[int] = None
     chemical_composition : Optional[str] = None
     wyckoff_symbols : Optional[list[str]] = None
+    phase_fraction: Optional[float] = None
+
+    def __post_init__(self):
+        if not 0 <= self.phase_fraction <= 1:
+            raise ValueError(f'Phase fraction must be between 0 and 1. Got {self.phase_fraction}')
 
     @classmethod
     def from_cif(cls, cif_content : str) -> CrystalStructure:
@@ -137,4 +140,12 @@ def _spg_to_crystal_system(spg: int) -> CrystalSystem:
             return "trigonal"
         if spg <= 194:
             return "hexagonal"
-        return "cubic"
+        return "cubic"
+
+    @property
+    def angles(self) -> tuple[float, float, float]:
+        return self.lattice.angles
+
+    @property
+    def lengths(self) -> tuple[float, float, float]:
+        return self.lattice.lengths

xrdpattern/pattern/pattern.py

@@ -103,8 +103,7 @@ def __eq__(self, other : XrdPattern):
             if isinstance(v1, np.ndarray):
                 is_ok = np.array_equal(v1, v2)
             elif isinstance(v1, PowderExperiment):
-                objs_equal = [str(x)==str(y) for x,y in zip(v1.get_list_repr(), v2.get_list_repr())]
-                is_ok = all(objs_equal)
+                is_ok = v1
             else:
                 is_ok = v1 == v2
 

xrdpattern/xrd/data.py

@@ -86,7 +86,7 @@ def has_label(self, label_type: LabelType) -> bool:
         if label_type == LabelType.composition:
             return self.primary_phase.chemical_composition is not None
         if label_type == LabelType.lattice:
-            return all(not math.isnan(x) for x in self.primary_phase.lengths) and all(not math.isnan(x) for x in self.primary_phase.angles)
+            return
         if label_type == LabelType.atom_coords:
             return len(self.primary_phase.basis) > 0
         if label_type == LabelType.spg:

xrdpattern/xrd/experiment.py

@@ -2,15 +2,12 @@
 
 import math
 from dataclasses import dataclass, field
-from enum import Enum
 from importlib.metadata import version
 from typing import Optional
 
-import torch
-
-from xrdpattern.crystal import CrystalStructure, CrystalBasis, AtomSite
+from xrdpattern.crystal import CrystalStructure
 from xrdpattern.serialization import JsonDataclass
-from xrdpattern.xrd.tensorization import LabelTensor
+from xrdpattern.xrd.xray import XrayInfo
 
 NUM_SPACEGROUPS = 230
 MAX_ATOMIC_SITES = 100
@@ -26,25 +23,13 @@ class PowderExperiment(JsonDataclass):
     temp_in_celcius: Optional[float] = None
 
     def __post_init__(self):
-        if len(self.phases) == 0:
-            raise ValueError(f'Material must have at least one phase! Got {len(self.phases)}')
-
         if len(self.phases) == 1:
             self.phases[0].phase_fraction = 1
 
     @classmethod
-    def make_empty(cls, is_simulated : bool = False, num_phases : int = 1) -> PowderExperiment:
-        phases = []
-        for j in range(num_phases):
-            lengths = (float('nan'),float('nan'), float('nan'))
-            angles = (float('nan'),float('nan'), float('nan'))
-            base = CrystalBasis.empty()
-
-            p = CrystalStructure(lengths=lengths, angles=angles, basis=base)
-            phases.append(p)
-
+    def make_empty(cls, is_simulated: bool = False) -> PowderExperiment:
         xray_info = XrayInfo.mk_empty()
-        return cls(phases=phases, crystallite_size=None, temp_in_celcius=None, xray_info=xray_info, is_simulated=is_simulated)
+        return cls(phases=[], xray_info=xray_info, is_simulated=is_simulated)
 
     @classmethod
     def from_multi_phase(cls, phases : list[CrystalStructure]):
@@ -93,101 +78,11 @@ def is_nonempty(self) -> bool:
         crystal_basis_nonempty = len(primary_phase.basis) > 0
         return xray_info_nonemtpy or composition_nonempty or lattice_params_nonempty or crystal_basis_nonempty
 
-    @property
-    def primary_wavelength(self) -> float:
-        return self.xray_info.primary_wavelength
-
-    @property
-    def secondary_wavelength(self) -> float:
-        return self.xray_info.secondary_wavelength
-
-    def get_list_repr(self) -> list:
-        list_repr = []
-        structure = self.phases[0]
-
-        a, b, c = structure.lengths
-        alpha, beta, gamma = structure.angles
-        lattice_params = [a, b, c, alpha, beta, gamma]
-        list_repr += lattice_params
-
-        base = structure.basis
-        padded_base = self.get_padded_base(base=base, nan_padding=base.is_empty())
-        for atomic_site in padded_base:
-            list_repr += atomic_site.as_list()
-
-        if structure.spacegroup is None:
-            spg_logits_list = [float('nan') for _ in range(NUM_SPACEGROUPS)]
-        else:
-            spg_logits_list = [1000 if j + 1 == structure.spacegroup else 0 for j in range(NUM_SPACEGROUPS)]
-        list_repr += spg_logits_list
-
-        list_repr += self.xray_info.as_list()
-        list_repr += [self.is_simulated]
-
-        return list_repr
-
-    @staticmethod
-    def get_padded_base(base: CrystalBasis, nan_padding : bool) -> CrystalBasis:
-        def make_padding_site():
-            if nan_padding:
-                site = AtomSite.make_placeholder()
-            else:
-                site = AtomSite.make_void()
-            return site
-
-        delta = MAX_ATOMIC_SITES - len(base)
-        if delta < 0:
-            raise ValueError(f'Base is too large! Size = {len(base)} exceeds MAX_ATOMIC_SITES = {MAX_ATOMIC_SITES}')
-
-        padded_base = base + [make_padding_site() for _ in range(delta)]
-        return padded_base
-
-
-    def to_tensor(self, dtype : torch.dtype = torch.get_default_dtype(), device : torch.device = torch.get_default_device()) -> LabelTensor:
-        tensor = torch.tensor(self.get_list_repr(), dtype=dtype, device=device)
-        return LabelTensor(tensor)
-
-
-@dataclass
-class XrayInfo(JsonDataclass):
-    primary_wavelength: Optional[float]
-    secondary_wavelength: Optional[float]
-
-    @classmethod
-    def mk_empty(cls):
-        return cls(primary_wavelength=None, secondary_wavelength=None)
-
-    def as_list(self) -> list[float]:
-        return [self.primary_wavelength, self.secondary_wavelength]
-
-    @staticmethod
-    def default_ratio() -> float:
-        return 0.5
-
-
-class XrdAnode(Enum):
-    Cu = "Cu"
-    Mo = "Mo"
-    Cr = "Cr"
-    Fe = "Fe"
-    Co = "Co"
-    Ag = "Ag"
-
-    def get_wavelengths(self) -> (float, float):
-        MATERiAL_TO_WAVELENGTHS = {
-            "Cu": (1.54439, 1.54056),
-            "Mo": (0.71359, 0.70930),
-            "Cr": (2.29361, 2.28970),
-            "Fe": (1.93998, 1.93604),
-            "Co": (1.79285, 1.78896),
-            "Ag": (0.563813, 0.559421),
-        }
-        return MATERiAL_TO_WAVELENGTHS[self.value]
-
-    def get_xray_info(self) -> XrayInfo:
-        primary, secondary = self.get_wavelengths()
-        return XrayInfo(primary_wavelength=primary, secondary_wavelength=secondary)
+    def __eq__(self, other : PowderExperiment):
+        return self.to_str() == other.to_str()
 
+    # def to_tensor(self, dtype : torch.dtype = torch.get_default_dtype(), device : torch.device = torch.get_default_device()) -> LabelTensor:
+    #     return LabelTensor(tensor)
 
 @dataclass
 class Metadata(JsonDataclass):
@@ -206,5 +101,6 @@ def __eq__(self, other : Metadata):
     def remove_filename(self):
         self.filename = None
 
+
 def get_library_version(library_name : str):
     return version(library_name)

xrdpattern/xrd/xray.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from xrdpattern.serialization import JsonDataclass
+
+
+@dataclass
+class XrayInfo(JsonDataclass):
+    primary_wavelength: Optional[float]
+    secondary_wavelength: Optional[float]
+
+    @classmethod
+    def from_anode(cls, element : str):
+        MATERIAL_TO_WAVELNGTHS = {
+            "Cu": (1.54439, 1.54056),
+            "Mo": (0.71359, 0.70930),
+            "Cr": (2.29361, 2.28970),
+            "Fe": (1.93998, 1.93604),
+            "Co": (1.79285, 1.78896),
+            "Ag": (0.563813, 0.559421),
+        }
+        return cls(*MATERIAL_TO_WAVELNGTHS[element])
+
+    @classmethod
+    def mk_empty(cls):
+        return cls(primary_wavelength=None, secondary_wavelength=None)
+
+    def as_list(self) -> list[float]:
+        return [self.primary_wavelength, self.secondary_wavelength]
+
+    @staticmethod
+    def default_ratio() -> float:
+        return 0.5
+
+
+class XrdAnode:
+    Cu = "Cu"
+    Mo = "Mo"
+    Cr = "Cr"
+    Fe = "Fe"
+    Co = "Co"
+    Ag = "Ag"