Element

Abstract element

class model.library.element.Element(name: str, length: float = 0.0, dp: float = 0.0, *, ns: int = 1, ds: float | None = None, order: int = 0, exact: bool = False, insertion: bool = False, output: bool = False, matrix: bool = False)[source]

Abstract element

property dp: torch.Tensor

Get momentum deviation

Parameters:: None
Return type:: Tensor

property exact: bool

Get exact flag

Parameters:: None
Return type:: bool

property insertion: bool

Get insertion flag

Parameters:: None
Return type:: bool

property length: torch.Tensor

Get length

Parameters:: None
Return type:: Tensor

abstract make_matrix() → tuple[torch.Tensor, torch.Tensor][source]

Generate transformation matrices (error element)

Parameters:: None
Return type:: tuple[Tensor, Tensor]

abstract make_step() → tuple[Mapping, ParametricMapping][source]

Generate integration step

Parameters:: None
Return type:: tuple[Mapping, ParametricMapping]

property matrix: bool

Get matrix flag

Parameters:: None
Return type:: bool

property name: str

Get name

Parameters:: None
Return type:: str

property ns: int

Get number of integration steps

Parameters:: None
Return type:: int

property order: int

Get integration order

Parameters:: None
Return type:: int

property output: bool

Get output flag

Parameters:: None
Return type:: bool

table(*, name: bool = False, alignment: bool = True) → dict[str, dict[str, torch.Tensor]] | dict[str, torch.Tensor][source]

Generate default deviation table

Parameters:: None
Return type:: dict[str, dict[str,Tensor]] | dict[str,Tensor]

model.library.element.transform(element: Element, state: State, data: dict[str, torch.Tensor]) → State[source]

Apply alignment errors

element: Element: element to apply error to
state: State: initial input state
data: dict[str, Tensor]: deviation and alignment table