use LatticeJSON Schema version 2.0 (#78)

Author: felix-andreas

apace/classes.py

@@ -9,15 +9,15 @@ class Base:
     """Abstract base for all element and lattice classes.
 
     :param str name: The name of the object.
-    :param description: A brief description of the object.
-    :type description: str, optional
+    :param info: Additional information about the object.
+    :type info: str, optional
     """
 
-    def __init__(self, name, length, description=""):
+    def __init__(self, name, length, info=""):
         self.name: str = name
         """The name of the object."""
-        self.description: str = description
-        """A brief description of the object"""
+        self.info: str = info
+        """Additional information about the object"""
         self.parent_lattices: Set["Lattice"] = set()
         """All lattices which contain the object."""
         self._length = length
@@ -55,12 +55,12 @@ class Element(Base):
 
     :param str name: The name of the element.
     :param float length: The length of the element (m).
-    :param str description: A brief description of the element.
-    :type description: str, optional
+    :param str info: Additional information about the element.
+    :type info: str, optional
     """
 
-    def __init__(self, name, length, description=""):
-        super().__init__(name, length, description)
+    def __init__(self, name, length, info=""):
+        super().__init__(name, length, info)
         self._length = length
         self.length_changed: Signal = Signal()
         """Gets emitted when the length changes."""
@@ -94,8 +94,8 @@ class Drift(Element):
 
     :param str name: The name of the element.
     :param float length: The length of the element (m).
-    :param str description: A brief description of the element.
-    :type description: str, optional
+    :param str info: Additional information about the element.
+    :type info: str, optional
     """
 
     pass
@@ -111,12 +111,12 @@ class Dipole(Element):
     :type e1: float, optional
     :param e2: Exit angle in rad.
     :type e2: float, optional
-    :param description: A brief description of the element.
-    :type description: str, optional
+    :param info: Additional information about the element.
+    :type info: str, optional
     """
 
-    def __init__(self, name, length, angle, e1=0, e2=0, description=""):
-        super().__init__(name, length, description)
+    def __init__(self, name, length, angle, e1=0, e2=0, info=""):
+        super().__init__(name, length, info)
         self._angle = angle
         self._e1 = e1
         self._e2 = e2
@@ -176,12 +176,12 @@ class Quadrupole(Element):
     :param str name: Name of the element.
     :param float length: Length of the element (m).
     :param float k1: Geometric quadrupole strength (m^-2).
-    :param description: A brief description of the element.
-    :type description: str, optional
+    :param info: Additional information about the element.
+    :type info: str, optional
     """
 
-    def __init__(self, name, length, k1, description=""):
-        super().__init__(name, length, description)
+    def __init__(self, name, length, k1, info=""):
+        super().__init__(name, length, info)
         self._k1 = k1
 
     @property
@@ -201,12 +201,12 @@ class Sextupole(Element):
     :param str name: Name of the element.
     :param float length: Length of the element (m).
     :param float k1: Geometric quadrupole strength (m^-3).
-    :param description: A brief description of the element.
-    :type description: str, optional
+    :param info: Additional information about the element.
+    :type info: str, optional
     """
 
-    def __init__(self, name, length, k2, description=""):
-        super().__init__(name, length, description)
+    def __init__(self, name, length, k2, info=""):
+        super().__init__(name, length, info)
         self._k2 = k2
 
     @property
@@ -226,12 +226,12 @@ class Octupole(Element):
     :param str name: Name of the element.
     :param float length: Length of the element (m).
     :param float k3: Geometric quadrupole strength (m^-4).
-    :param description: A brief description of the element.
-    :type description: str, optional
+    :param info: Additional information about the element.
+    :type info: str, optional
     """
 
-    def __init__(self, name, length, k3, description=""):
-        super().__init__(name, length, description)
+    def __init__(self, name, length, k3, info=""):
+        super().__init__(name, length, info)
         self._k3 = k3
 
     @property
@@ -251,11 +251,11 @@ class Lattice(Base):
     :param str name: Name of the lattice.
     :param tree: Nested tree of elements and lattices.
     :type tree: Tuple[Union[Element, Lattice]]
-    :param str description: A brief description of the element.
+    :param str info: Additional information about the lattice.
     """
 
-    def __init__(self, name, tree, description=None):
-        super().__init__(name, description)
+    def __init__(self, name, tree, info=None):
+        super().__init__(name, info)
         self._tree = tree
         for obj in set(tree):
             obj.parent_lattices.add(self)
@@ -409,16 +409,13 @@ def from_dict(cls, data) -> "Lattice":
             objects[name] = class_(name=name, **attributes)
 
         # TODO: make sure sub_lattices are loaded in correct order
-        sub_lattices = data["sub_lattices"]
-        for name, tree_names in sub_lattices.items():
-            tree = [objects[name] for name in tree_names]
-            objects[name] = Lattice(name, tree)
-
-        return cls(
-            name=data["name"],
-            tree=[objects[name] for name in data["lattice"]],
-            description=data.get("description", ""),
-        )
+        for name, child_names in data["lattices"].items():
+            children = [objects[name] for name in child_names]
+            objects[name] = Lattice(name, children)
+
+        root_lattice = objects[data["root"]]
+        root_lattice.info = data.get("info", "")
+        return root_lattice
 
     def as_dict(self):
         """Serializes the `Lattice` object into a latticeJSON compliant dictionary."""
@@ -430,15 +427,17 @@ def as_dict(self):
             name = attributes.pop("name")
             elements_dict[name] = [type_.__name__, attributes]
 
-        sub_lattices_dict = {
+        lattices_dict = {
             lattice.name: [obj.name for obj in lattice.tree]
             for lattice in self.sub_lattices
         }
+        lattices_dict[self.name] = [obj.name for obj in self.tree]
 
         return dict(
-            name=self.name,
-            description=self.description,
+            version="2.0",
+            root=self.name,
+            info=self.info,
             lattice=[obj.name for obj in self.tree],
             elements=elements_dict,
-            sub_lattices=sub_lattices_dict,
+            lattices=lattices_dict,
         )

data/lattices/fodo_ring.json

@@ -1,14 +1,16 @@
 {
-  "name": "FODO_RING",
-  "description": "This is the simplest possible strong focusing lattice.",
+  "version": "2.0",
+  "title": "FODO Lattice",
+  "info": "This is the simplest possible strong focusing lattice.",
+  "root": "RING",
   "elements": {
     "D1": ["Drift", {"length": 0.55}],
     "Q1": ["Quadrupole", {"length": 0.2, "k1": 1.2}],
     "Q2": ["Quadrupole", {"length": 0.4, "k1": -1.2}],
     "B1": ["Dipole", {"length": 1.5, "angle": 0.392701, "e1": 0.1963505, "e2": 0.1963505}]
   },
-  "sub_lattices": {
-    "FODO": ["Q1", "D1", "B1", "D1", "Q2", "D1", "B1", "D1", "Q1"]
-  },
-  "lattice": ["FODO", "FODO", "FODO", "FODO", "FODO", "FODO", "FODO", "FODO"]
+  "lattices": {
+    "CELL": ["Q1", "D1", "B1", "D1", "Q2", "D1", "B1", "D1", "Q1"],
+    "RING": ["CELL", "CELL", "CELL", "CELL", "CELL", "CELL", "CELL", "CELL"]
+  }
 }

setup.py

@@ -19,7 +19,7 @@
     packages=find_packages(),
     package_data={"data": ["data"],},
     install_requires=[
-        "latticejson>=0.1.1",
+        "latticejson>=0.1.2",
         "numpy",
         "scipy",
         "matplotlib",

tests/test_io.py

@@ -24,7 +24,7 @@ def test_attributes(fodo_ring):
     assert 0.4 == fodo_ring["Q2"].length
     assert -1.2 == fodo_ring["Q2"].k1
 
-    fodo_cell = fodo_ring["FODO"]
+    fodo_cell = fodo_ring["CELL"]
     assert isinstance(fodo_cell, ap.Lattice)
     assert 6.0 == fodo_cell.length