xtrack 0.90.1__tar.gz → 0.92.0__tar.gz

{xtrack-0.90.1/xtrack.egg-info → xtrack-0.92.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xtrack
-Version: 0.90.1
+Version: 0.92.0
 Summary: Tracking library for particle accelerators
 Home-page: https://xsuite.readthedocs.io/
 Download-URL: https://pypi.python.org/pypi/xtrack
@@ -25,6 +25,7 @@ Requires-Dist: pytest; extra == "tests"
 Requires-Dist: pytest-mock; extra == "tests"
 Requires-Dist: pymadng; extra == "tests"
 Requires-Dist: requests-mock; extra == "tests"
+Requires-Dist: tfs-pandas; extra == "tests"
 Provides-Extra: notebooks
 Requires-Dist: jupyter; extra == "notebooks"
 Requires-Dist: ipympl; extra == "notebooks"

{xtrack-0.90.1 → xtrack-0.92.0}/setup.py

@@ -50,7 +50,7 @@ setup(
     ],
     extras_require={
         'tests': ['cpymad', 'nafflib', 'PyHEADTAIL', 'pytest', 'pytest-mock',
-                  'pymadng', 'requests-mock'],
+                  'pymadng', 'requests-mock', 'tfs-pandas'],
         'notebooks': ['jupyter', 'ipympl', 'xplt'],
     },
 )

xtrack-0.92.0/tests/test_json.py

@@ -0,0 +1,94 @@
+import io
+
+import numpy as np
+
+from xtrack import json as xjson
+
+
+def test_complex_scalar_round_trip():
+    data = {"value": 1 + 2j}
+
+    buffer = io.StringIO()
+    xjson.dump(data, buffer)
+    raw = buffer.getvalue()
+
+    buffer.seek(0)
+    loaded_from_file = xjson.load(file=buffer)
+    assert loaded_from_file == data
+    assert isinstance(loaded_from_file["value"], complex)
+
+    loaded_from_string = xjson.load(string=raw)
+    assert loaded_from_string == data
+    assert isinstance(loaded_from_string["value"], complex)
+
+
+def test_complex_array_round_trip_preserves_dtype_and_shape(tmp_path):
+    array = np.array([[1 + 2j, 3 + 4j], [5 + 6j, 7 + 8j]], dtype=np.complex64)
+
+    path = tmp_path / "complex.json"
+    xjson.dump({"array": array}, path)
+
+    loaded = xjson.load(path)
+    round_trip = loaded["array"]
+
+    assert isinstance(round_trip, np.ndarray)
+    assert round_trip.dtype == array.dtype
+    np.testing.assert_allclose(round_trip, array)
+
+
+def test_complex_array_round_trip_with_gzip(tmp_path):
+    array = np.array([1 + 2j, 3 + 4j], dtype=np.complex128)
+
+    path = tmp_path / "complex.json.gz"
+    xjson.dump({"array": array}, path)
+
+    loaded = xjson.load(path)
+    round_trip = loaded["array"]
+
+    assert isinstance(round_trip, np.ndarray)
+    assert round_trip.dtype == array.dtype
+    np.testing.assert_allclose(round_trip, array)
+
+
+def test_python_primitive_types_round_trip():
+    data = {
+        "int": 42,
+        "float": 3.14,
+        "bool": True,
+        "str": "xtrack",
+        "list": [1, 2, 3],
+        "dict": {"nested": "value"},
+        "none": None,
+    }
+
+    buffer = io.StringIO()
+    xjson.dump(data, buffer)
+
+    buffer.seek(0)
+    loaded = xjson.load(file=buffer)
+    assert loaded == data
+
+
+def test_numpy_scalar_round_trip():
+    data = {"value": np.int64(5)}
+
+    buffer = io.StringIO()
+    xjson.dump(data, buffer)
+
+    buffer.seek(0)
+    loaded = xjson.load(file=buffer)
+
+    assert loaded["value"] == 5
+    assert isinstance(loaded["value"], int)
+
+
+def test_numpy_real_array_round_trip():
+    array = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
+
+    buffer = io.StringIO()
+    xjson.dump({"array": array}, buffer)
+
+    buffer.seek(0)
+    loaded = xjson.load(file=buffer)
+
+    assert loaded["array"] == array.tolist()

{xtrack-0.90.1 → xtrack-0.92.0}/tests/test_mad_writer.py

@@ -29,7 +29,6 @@ def test_mad_writer(case):
     mad_seq = line.to_madx_sequence(sequence_name='myseq')
 
     mad = Madx(stdout=True)
-    mad.options.rbarc = False
     mad.input(mad_seq)
     mad.beam(particle='proton', energy=7000e9)
     mad.use('myseq')

{xtrack-0.90.1 → xtrack-0.92.0}/tests/test_rbend_straight_body.py

@@ -1,6 +1,7 @@
 import xtrack as xt
 import numpy as np
 import xobjects as xo
+from cpymad.madx import Madx
 from xobjects.test_helpers import for_all_test_contexts
 
 import pathlib
@@ -1786,4 +1787,61 @@ def test_rbend_straight_body_v_shift():
         xo.assert_allclose(sv_test.Z, sv_curved.Z, atol=5e-14)
         xo.assert_allclose(sv_test.phi, sv_curved.phi, atol=5e-14)
         xo.assert_allclose(sv_test.psi, sv_curved.psi, atol=5e-14)
-        xo.assert_allclose(sv_test.theta, sv_curved.theta, atol=5e-14)
+        xo.assert_allclose(sv_test.theta, sv_curved.theta, atol=5e-14)
+
+def test_rbend_loading_writing_in_interfaces():
+
+    madx = Madx()
+
+    l_straight = 1.0
+    angle = 0.5
+    l_arc = l_straight / np.sinc(angle / np.pi / 2) # np.sinc is sin(pi*x)/(pi*x)
+
+    madx.input('''
+    b: rbend, l=1.0, angle=0.5;
+
+    ss: sequence, l=5.0, refer=centre;
+        b, at=2.5;
+    endsequence;
+    beam;
+    use, sequence=ss;
+    twiss, betx=1, bety=1;
+    survey;
+    ''')
+    sv_madx = xt.Table(madx.table.survey, _copy_cols=True)
+    xo.assert_allclose(madx.elements['b'].l, l_straight, rtol=1e-12)
+    xo.assert_allclose(sv_madx['s', 'b:1'], 2.5 + l_arc / 2, rtol=1e-12) # b si at exit
+
+    # Check cpymad loader
+    line = xt.Line.from_madx_sequence(madx.sequence.ss)
+    line.remove('ss$start')
+    line.remove('ss$end')
+    line.particle_ref = xt.Particles(p0c=1e9)
+    sv_xs = line.survey()
+    xo.assert_allclose(line['b'].length_straight, l_straight, rtol=1e-12)
+    xo.assert_allclose(line['b'].length, l_arc, rtol=1e-12)
+    xo.assert_allclose(sv_xs['s', 'b'], 2.5 - l_arc / 2, rtol=1e-12) # b si at entrance
+
+    # Check to madx
+    mad_str = line.to_madx_sequence(sequence_name='ggg')
+    madx2 = Madx()
+    madx2.input(mad_str)
+    madx2.input('''
+    beam;
+    use, sequence=ggg;
+    twiss, betx=1, bety=1;
+    survey;
+    ''')
+    sv_madx2 = xt.Table(madx2.table.survey, _copy_cols=True)
+    xo.assert_allclose(madx2.elements['b'].l, l_straight, rtol=1e-12)
+
+    # Check native madx loader
+    env2 = xt.load(string=mad_str, format='madx')
+    sv_xs2 = env2.ggg.survey()
+    xo.assert_allclose(env2['b'].length_straight, l_straight, rtol=1e-12)
+    xo.assert_allclose(env2['b'].length, l_arc, rtol=1e-12)
+    xo.assert_allclose(sv_xs2['s', 'b'], 2.5 - l_arc / 2, rtol=1e-12) # b si at entrance
+
+    # Check madng
+    sv_ng = line.madng_survey()
+    xo.assert_allclose(sv_ng['s', 'b'], 2.5 - l_arc / 2, rtol=1e-12) # b si at entrance

{xtrack-0.90.1 → xtrack-0.92.0}/tests/test_twiss.py

@@ -2058,4 +2058,4 @@ def test_twiss_disable_apertures():
     tw = line.twiss(betx=1, bety=1, x=0.2, y=0)
     xo.assert_allclose(tw.x[-1], 0.2)
     with pytest.raises(AssertionError):
-        line.twiss(betx=1, bety=1, x=0.2, y=0, disable_apertures=False)
+        line.twiss(betx=1, bety=1, x=0.2, y=0, disable_apertures=False)

xtrack-0.92.0/tests/test_twiss_to_file.py

@@ -0,0 +1,88 @@
+import xtrack as xt
+import xobjects as xo
+import numpy as np
+import pytest
+import pathlib
+
+test_data_folder = pathlib.Path(
+    __file__).parent.joinpath('../test_data').absolute()
+
+@pytest.mark.parametrize("check_type", ['csv', 'hdf5', 'tfs', 'json'])
+def test_twiss_table_file(check_type, tmp_path):
+
+    env = xt.load(test_data_folder / 'sps_thick/sps.seq')
+    env.vars.load(test_data_folder / 'sps_thick/lhc_q20.str')
+    line = env.sps
+    line.set_particle_ref('p', energy0=26e9)
+    tw = line.twiss4d()
+
+    if check_type == 'csv':
+        tw.to_csv(tmp_path / 'twiss_test.csv')
+        tw_test = xt.load(tmp_path / 'twiss_test.csv')
+    elif check_type == 'hdf5':
+        tw.to_hdf5(tmp_path / 'twiss_test.h5')
+        tw_test = xt.load(tmp_path / 'twiss_test.h5')
+    elif check_type == 'tfs':
+        tw.to_tfs(tmp_path / 'twiss_test.tfs')
+        tw_test = xt.load(tmp_path / 'twiss_test.tfs')
+    elif check_type == 'json':
+        tw.to_json(tmp_path / 'twiss_test.json')
+        tw_test = xt.load(tmp_path / 'twiss_test.json')
+    else:
+        raise ValueError(f'check_type {check_type} not supported')
+
+    assert isinstance(tw_test, xt.TwissTable)
+
+    assert np.all(np.array(tw_test._col_names) == np.array(tw._col_names))
+    if check_type == 'tfs':
+        assert set(tw_test.keys()) - set(tw.keys()) == {
+            '__class__', 'attrs_serialization', 'column_serialization', 'xtrack_version'
+        }
+    elif check_type == 'json':
+        assert set(tw_test.keys()) - set(tw.keys()) == {'xtrack_version'}
+    else:
+        assert set(tw_test.keys()) - set(tw.keys()) == {'__class__', 'xtrack_version'}
+    assert set(tw.keys()) - set(tw_test.keys()) == {'_action'}
+
+    for kk in tw._data:
+        if kk == '_action':
+            continue
+        if kk in ['particle_on_co', 'steps_r_matrix', 'line_config']:
+            continue # To be checked separately
+        if tw[kk] is None:
+            assert tw_test[kk] is None
+            continue
+        if isinstance(tw[kk], np.ndarray) and isinstance(tw[kk][0], str):
+            assert np.all(tw[kk] == tw_test[kk])
+            continue
+        elif isinstance(tw[kk], str):
+            assert tw[kk] == tw_test[kk]
+            continue
+        xo.assert_allclose(tw[kk], tw_test[kk], rtol=1e-7, atol=1e-15)
+
+    # Check particle_on_co
+    assert isinstance(tw.particle_on_co, xt.Particles)
+    assert isinstance(tw_test.particle_on_co, xt.Particles)
+    dct_ref = line.particle_ref.to_dict()
+    dct_test = tw_test.particle_on_co.to_dict()
+    for kk in dct_ref:
+        if isinstance(dct_ref[kk], np.ndarray):
+            xo.assert_allclose(dct_ref[kk], dct_test[kk], rtol=1e-10, atol=1e-15)
+        else:
+            assert dct_ref[kk] == dct_test[kk]
+
+    # Check steps_r_matrix
+    assert isinstance(tw.steps_r_matrix, dict)
+    assert isinstance(tw_test.steps_r_matrix, dict)
+    assert set(tw.steps_r_matrix.keys()) == set(tw_test.steps_r_matrix.keys())
+    for kk in tw.steps_r_matrix:
+        rmat_ref = tw.steps_r_matrix[kk]
+        rmat_test = tw_test.steps_r_matrix[kk]
+        xo.assert_allclose(rmat_ref, rmat_test, rtol=1e-10, atol=1e-15)
+
+    # Check line_config
+    assert isinstance(tw.line_config, dict)
+    assert isinstance(tw_test.line_config, dict)
+    assert set(tw.line_config.keys()) == set(tw_test.line_config.keys())
+    for kk in tw.line_config:
+        assert tw.line_config[kk] == tw_test.line_config[kk]

{xtrack-0.90.1 → xtrack-0.92.0}/xtrack/__init__.py

@@ -50,8 +50,8 @@ from .load import load
 
 from .multiline import Multiline
 
-from xdeps import Table, FunctionPieceWiseLinear
+from xdeps import FunctionPieceWiseLinear
+from .table import Table
 
 from ._version import __version__
 
-

xtrack-0.92.0/xtrack/_version.py

@@ -0,0 +1 @@
+__version__ = '0.92.0'

{xtrack-0.90.1 → xtrack-0.92.0}/xtrack/beam_elements/elements.py

@@ -1447,11 +1447,9 @@ class Bend(_BendCommon, BeamElement):
     length : float, optional
         Length of the element in meters along the reference trajectory.
     knl : array, optional
-        Integrated strength of the high-order normal multipolar components
-        (knl[0] and knl[1] should not be used).
+        Integrated strength of the high-order normal multipolar components.
     ksl : array, optional
-        Integrated strength of the high-order skew multipolar components
-        (ksl[0] and ksl[1] should not be used).
+        Integrated strength of the high-order skew multipolar components.
     order : int, optional
         Maximum order of multipole expansion for this magnet. Defaults to 5.
     model : str, optional
@@ -1697,11 +1695,9 @@ class RBend(_BendCommon, BeamElement):
         Length of the element in units of m along a straight line. Changes to
         `length_straight` will update `length` and `h`.
     knl : array, optional
-        Integrated strength of the high-order normal multipolar components
-        (`knl[0]` and `knl[1]` should not be used).
+        Integrated strength of the high-order normal multipolar components.
     ksl : array, optional
-        Integrated strength of the high-order skew multipolar components
-        (`ksl[0]` and `ksl[1]` should not be used).
+        Integrated strength of the high-order skew multipolar components.
     model : str, optional
         Drift model to be used in kick-splitting. See `Bend` for details.
     integrator : str, optional

{xtrack-0.90.1 → xtrack-0.92.0}/xtrack/environment.py

@@ -658,11 +658,10 @@ class Environment:
 
     def _get_a_drift_name(self):
         self._drift_counter += 1
-        nn = f'drift_{self._drift_counter}'
-        if nn not in self.element_dict:
-            return nn
-        else:
-            return self._get_a_drift_name()
+        while nn := f'drift_{self._drift_counter}':
+            if nn not in self.element_dict:
+                return nn
+            self._drift_counter += 1
 
     def __setitem__(self, key, value):
 
@@ -679,6 +678,7 @@ class Environment:
     def to_dict(self, include_var_management=True, include_version=True):
 
         out = {}
+        out['__class__'] = self.__class__.__name__
 
         if include_version:
             out["xtrack_version"] = xt.__version__

{xtrack-0.90.1 → xtrack-0.92.0}/xtrack/general.py

@@ -23,7 +23,7 @@ class _LOC:
 START = _LOC('START')
 END = _LOC('END')
 
-def read_url(url, timeout=0.1):
+def read_url(url, timeout=0.1, binary=False):
     """
     Read content from a URL.
     """
@@ -31,9 +31,16 @@ def read_url(url, timeout=0.1):
         response = requests.get(url, timeout=timeout)
         response.raise_for_status()  # Raise an error for bad responses
         if url.endswith('.gz'):
-            return gzip.decompress(response.content).decode("utf-8")
+            out = gzip.decompress(response.content)
+            if binary:
+                return out
+            else:
+                return out.decode("utf-8")
         else:
-            return response.text
+            if binary:
+                return response.content
+            else:
+                return response.text
     except requests.exceptions.RequestException as e:
         raise RuntimeError(f"Failed to read from URL {url}: {e}")
 

xtrack-0.92.0/xtrack/json.py

@@ -0,0 +1,96 @@
+import json
+import io
+from pathlib import Path
+import gzip
+
+import numpy as np
+
+from xobjects import JEncoder
+
+
+_COMPLEX_SCALAR_TAG = "__complex__"
+_COMPLEX_ARRAY_TAG = "__complex_ndarray__"
+
+
+class _XtrackJSONEncoder(JEncoder):
+    def default(self, obj):
+        if isinstance(obj, complex):
+            return {_COMPLEX_SCALAR_TAG: [obj.real, obj.imag]}
+
+        if isinstance(obj, np.ndarray) and np.issubdtype(
+            obj.dtype, np.complexfloating
+        ):
+            return {
+                _COMPLEX_ARRAY_TAG: {
+                    "dtype": str(obj.dtype),
+                    "shape": obj.shape,
+                    "real": obj.real.tolist(),
+                    "imag": obj.imag.tolist(),
+                }
+            }
+
+        return super().default(obj)
+
+
+def _complex_object_hook(obj):
+    if _COMPLEX_SCALAR_TAG in obj:
+        real, imag = obj[_COMPLEX_SCALAR_TAG]
+        return complex(real, imag)
+
+    if _COMPLEX_ARRAY_TAG in obj:
+        metadata = obj[_COMPLEX_ARRAY_TAG]
+        real = np.array(metadata["real"], dtype=float)
+        imag = np.array(metadata["imag"], dtype=float)
+        data = real + 1j * imag
+        dtype = metadata.get("dtype")
+        if dtype is not None:
+            data = data.astype(np.dtype(dtype))
+        shape = metadata.get("shape")
+        if shape is not None:
+            data = np.array(data).reshape(tuple(shape))
+        return data
+
+    return obj
+
+
+def dump(data, file, indent=1):
+    if isinstance(file, io.IOBase):
+        fh, close = file, False
+    elif (isinstance(file, str) and file.endswith(".gz")) or (
+        isinstance(file, Path) and file.suffix == ".gz"
+    ):
+        fh, close = gzip.open(file, "wt"), True
+    else:
+        fh, close = open(file, "w"), True
+
+    json.dump(data, fh, indent=indent, cls=_XtrackJSONEncoder)
+
+    if close:
+        fh.close()
+
+
+def load(file=None, string=None):
+
+    if string is not None:
+        assert file is None, "Cannot specify both file and string"
+        data = json.loads(string, object_hook=_complex_object_hook)
+        return data
+
+    if file is None:
+        raise ValueError("Must specify either file or string")
+
+    if isinstance(file, io.IOBase):
+        fh, close = file, False
+    elif (isinstance(file, str) and file.endswith(".gz")) or (
+        isinstance(file, Path) and file.suffix == ".gz"
+    ):
+        fh, close = gzip.open(file, "rt"), True
+    else:
+        fh, close = open(file, "r"), True
+
+    data = json.load(fh, object_hook=_complex_object_hook)
+
+    if close:
+        fh.close()
+
+    return data

{xtrack-0.90.1 → xtrack-0.92.0}/xtrack/line.py

@@ -612,6 +612,7 @@ class Line:
         '''
 
         out = {}
+        out['__class__'] = self.__class__.__name__
 
         if include_version:
             out["xtrack_version"] = xt.__version__

xtrack-0.92.0/xtrack/load.py

@@ -0,0 +1,140 @@
+# copyright ############################### #
+# This file is part of the Xtrack Package.  #
+# Copyright (c) CERN, 2025.                 #
+# ######################################### #
+
+from __future__ import annotations
+
+import io
+from pathlib import Path
+from typing import Literal, Optional
+
+import xtrack as xt
+
+
+_SUPPORTED_FORMATS = {'json', 'madx', 'python', 'csv', 'hdf5', 'tfs'}
+
+
+def _resolve_table_instance(table: xt.Table):
+    table_class = getattr(table, '_data', {}).get('__class__')
+    if not isinstance(table_class, str):
+        return table
+
+    cls = getattr(xt, table_class, None)
+    if cls is None or cls is xt.Table:
+        return table
+
+    out = cls(data=table._data, col_names=table._col_names)
+
+    return out
+
+def _guess_format_from_path(path: str) -> Optional[str]:
+    lower = path.lower()
+    if lower.endswith(('.json', '.json.gz')):
+        return 'json'
+    if lower.endswith(('.seq', '.madx')):
+        return 'madx'
+    if lower.endswith('.py'):
+        return 'python'
+    if lower.endswith(('.h5', '.hdf5')):
+        return 'hdf5'
+    if lower.endswith('.csv'):
+        return 'csv'
+    if lower.endswith('.tfs'):
+        return 'tfs'
+    return None
+
+
+def load(
+        file=None,
+        string=None,
+        format: Literal['json', 'madx', 'python', 'csv', 'hdf5', 'tfs'] = None,
+        timeout=5.0,
+        reverse_lines=None,
+):
+    if isinstance(file, Path):
+        file = str(file)
+
+    if (file is None) == (string is None):
+        raise ValueError('Must specify either file or string, but not both')
+
+    if string is not None and format not in _SUPPORTED_FORMATS:
+        raise ValueError(
+            f'Format must be specified to be one of {_SUPPORTED_FORMATS} when using string input'
+        )
+
+    if format is None and file is not None and isinstance(file, str):
+        format = _guess_format_from_path(file)
+
+    if format is None:
+        raise ValueError('format could not be determined, please specify it explicitly')
+
+    if reverse_lines and format != 'madx':
+        raise ValueError('`reverse_lines` is only supported for madx input.')
+
+    if file and isinstance(file, str) and (file.startswith('http://') or file.startswith('https://')):
+        binary = format == 'hdf5'
+        string = xt.general.read_url(file, timeout=timeout, binary=binary)
+        file = None
+
+    if format == 'json':
+        payload = xt.json.load(file=file, string=string)
+        cls_name = payload.pop('__class__', None)
+        if cls_name is not None:
+            cls = getattr(xt, cls_name, None)
+            if cls is None:
+                raise ValueError(f'Unknown class {cls_name!r} in json data')
+            return cls.from_dict(payload)
+        if 'lines' in payload:
+            return xt.Environment.from_dict(payload)
+        if 'element_names' in payload or 'line' in payload:
+            if 'line' in payload:
+                payload = payload['line']
+            return xt.Line.from_dict(payload)
+        raise ValueError('Cannot determine class from json data')
+
+    if format == 'madx':
+        return xt.load_madx_lattice(file=file, string=string, reverse_lines=reverse_lines)
+
+    if format == 'python':
+        if string is not None:
+            raise NotImplementedError('Loading from string not implemented for python format')
+        env = xt.Environment()
+        env.call(file)
+        return env
+
+    if format == 'csv':
+        if string is not None:
+            text = string.decode() if isinstance(string, bytes) else string
+            buffer = io.StringIO(text)
+            base_table = xt.Table.from_csv(buffer)
+        else:
+            if hasattr(file, 'seek'):
+                file.seek(0)
+            base_table = xt.Table.from_csv(file)
+        return _resolve_table_instance(base_table)
+
+    if format == 'hdf5':
+        if string is not None:
+            if not isinstance(string, (bytes, bytearray)):
+                raise TypeError('HDF5 string input must be bytes-like')
+            buffer = io.BytesIO(string)
+            base_table = xt.Table.from_hdf5(buffer)
+        else:
+            if hasattr(file, 'seek'):
+                file.seek(0)
+            base_table = xt.Table.from_hdf5(file)
+        return _resolve_table_instance(base_table)
+
+    if format == 'tfs':
+        if string is not None:
+            text = string.decode() if isinstance(string, bytes) else string
+            buffer = io.StringIO(text)
+            base_table = xt.Table.from_tfs(buffer)
+        else:
+            if hasattr(file, 'seek'):
+                file.seek(0)
+            base_table = xt.Table.from_tfs(file)
+        return _resolve_table_instance(base_table)
+
+    raise ValueError(f'Unsupported format {format!r}')

{xtrack-0.90.1 → xtrack-0.92.0}/xtrack/mad_parser/loader.py

@@ -203,6 +203,8 @@ class MadxLoader:
             if build:
                 builder.build()
 
+            self.env._last_loaded_builders = builders
+
         return builders
 
     def _parse_parameters(self, parameters: Dict[str, Dict[str, str]]):
@@ -624,7 +626,7 @@ class MadxLoader:
         return self._mad_base_type(element_name) in _APERTURE_TYPES
 
 
-def load_madx_lattice(file=None, string=None, reverse_lines=None):
+def load_madx_lattice(file=None, string=None, reverse_lines=None, build=True):
 
     if file is not None and string is not None:
         raise ValueError('Only one of `file` or `string` can be provided!')
@@ -635,9 +637,9 @@ def load_madx_lattice(file=None, string=None, reverse_lines=None):
     loader = MadxLoader()
 
     if file is not None:
-        loader.load_file(file)
+        loader.load_file(file, build=build)
     elif string is not None:
-        loader.load_string(string)
+        loader.load_string(string, build=build)
     else:
         raise ValueError('Something went wrong!')
 

{xtrack-0.90.1 → xtrack-0.92.0}/xtrack/mad_writer.py

@@ -415,7 +415,12 @@ def bend_to_mad_str(name, line, bend_type='sbend', mad_type=MadType.MADX, substi
     tokens.append(bend_type)
     if mad_type == MadType.MADNG:
         tokens.append(f"'{name.replace(':', '__')}'")  # replace ':' with '__' for MADNG
-    tokens.append(mad_assignment('l', _ge(bend.length), mad_type, substituted_vars=substituted_vars))
+    if bend_type == 'sbend' or mad_type == MadType.MADNG: # in MAD-NG all bends use the arc length
+        tokens.append(mad_assignment('l', _ge(bend.length), mad_type, substituted_vars=substituted_vars))
+    elif bend_type == 'rbend':
+        tokens.append(mad_assignment('l', _ge(bend.length_straight), mad_type, substituted_vars=substituted_vars))
+    else:
+        raise ValueError(f"bend_type {bend_type} not recognized")
     tokens.append(mad_assignment('angle', _ge(bend.h) * _ge(bend.length), mad_type, substituted_vars=substituted_vars))
     tokens.append(mad_assignment('k0', _ge(bend.k0), mad_type, substituted_vars=substituted_vars))
     tokens.append(mad_assignment('e1', _ge(bend.edge_entry_angle), mad_type, substituted_vars=substituted_vars))