2.6. pycsamt.emtf#

Format-neutral electromagnetic transfer-function scientific core: the EMTF document, matrix-oriented TransferFunction/StatisticalEstimate objects, the EMTF datatype registry, EDI/EDI-SPECTRA/EMTF-XML interoperability, and rotation/covariance transformation.

Format-neutral electromagnetic transfer-function scientific core.

class pycsamt.emtf.EMTF(product_id=None, description=None, subtype=None, tags=<factory>, periods=None, transfer_functions=<factory>, provenance=None, copyright=None, site=None, site_layout=None, orientation=None, processing=None, quality=None, field_notes=<factory>, station=None, station_id=None, lat=None, lon=None, elev=None, azimuth=None, metadata=<factory>, attrs=<factory>)#

Bases: MTBase

Format-neutral electromagnetic transfer-function document.

EMTF is the scientific object that EDI and EMTF XML adapters will eventually populate. Phase 2 adds reusable metadata objects while keeping the model independent of XML parsing and pycsamt.seg.

Parameters:
product_id: str | None = None#
description: str | None = None#
subtype: str | None = None#
tags: tuple[str, ...]#
periods: Any | None = None#
transfer_functions: dict[str, TransferFunction]#
provenance: ProvenanceMeta | None = None#
copyright: CopyrightInfo | None = None#
site: SiteMeta | None = None#
site_layout: SiteLayout | None = None#
orientation: OrientationMeta | None = None#
processing: ProcessingMeta | None = None#
quality: TransferFunctionQuality | None = None#
field_notes: dict[str, Any]#
station: str | None = None#
station_id: str | int | None = None#
lat: float | None = None#
lon: float | None = None#
elev: float | None = None#
azimuth: float | None = None#
metadata: dict[str, Any]#
attrs: dict[str, Any]#
validate()#

Normalize document state and validate attached TF period grids.

Return type:

None

property frequency: ndarray | None#

Return the document frequency vector in Hz when available.

property n_periods: int#

Return the common number of period samples when known.

add_transfer_function(tf, *, key=None, replace=False)#

Attach one scientific transfer function to the document.

Parameters:
Return type:

EMTF

get_transfer_function(key)#

Return a TF by semantic key or registered short code.

Parameters:

key (str)

Return type:

TransferFunction | None

property impedance: TransferFunction | None#

Return the matrix-oriented impedance TF.

property tipper_tf: TransferFunction | None#

Return the matrix-oriented tipper TF.

property z: ndarray | None#

Return the impedance array for legacy-style access.

property z_err: ndarray | None#

Return legacy standard errors when explicitly available.

property tipper: ndarray | None#

Return tipper data in the pyCSAMT (n, 1, 2) shape.

property tipper_err: ndarray | None#

Return legacy tipper standard errors when available.

property rho: ndarray | None#

Return stored apparent resistivity, or derive it from Z.

property phase: ndarray | None#

Return stored impedance phase, or derive it from Z.

property Z#

Build the existing pycsamt.z.Z compatibility object.

property Tip#

Build the existing pycsamt.z.tipper.Tipper object.

classmethod from_xml(source, *, strict=True)#

Read an EMTF XML document through the XML adapter.

The import is intentionally local so constructing the scientific core never requires XML serialization support unless this method is called.

Parameters:

strict (bool)

Return type:

EMTF

classmethod from_edi(source, **kwargs)#

Convert a historical SEG EDI object or path into EMTF.

EDI SPECTRA are preferred by default when present because they retain the full information needed to recover transfer-function covariance. Pass prefer_spectra=False to force the traditional impedance/tipper blocks instead. The adapter import remains local so the scientific core is independent of pycsamt.seg until requested.

Return type:

EMTF

classmethod from_edi_spectra(source, **kwargs)#

Recover EMTFs and full covariance directly from EDI SPECTRA.

This is the explicit Phase-8 entry point for single-station and remote-reference cross-power spectra. Any requested rotation is delegated to the format-neutral Phase-7 rotation engine.

Return type:

EMTF

to_edi(*, on_loss='warn')#

Return an in-memory pycsamt.seg.EDIFile representation.

Parameters:

on_loss ({"warn", "raise", "ignore"}) – Policy for EMTF content that standard EDI cannot preserve.

to_xml(*, strict=True, precision=17, pretty=True, xml_declaration=True)#

Serialize this scientific document to an EMTF XML string.

Parameters:
Return type:

str

write_xml(target, *, strict=True, precision=17, pretty=True, xml_declaration=True, encoding='utf-8')#

Write this document in EMTF XML format.

Parameters:
write(target, *, format='emtf_xml', **kwargs)#

Write this document using a supported serialization format.

Phase 6 supports EMTF XML and historical SEG EDI. EDI conversion is explicit and may emit DataLossWarning for content that the historical format cannot represent.

Parameters:

format (str)

rotate(angle=0.0, *, target='orthogonal', inplace=False, source_angles=None, use_legacy_edi_rotation=False, variance_policy='drop', unsupported_estimates='drop', derived_policy='drop')#

Rotate transfer functions with the format-neutral EMTF engine.

The original SiteLayout remains physical acquisition metadata and is never rotated. Full covariance factors are transformed consistently when present.

Parameters:

  • angle (float | None)

  • target (str)

  • inplace (bool)

  • use_legacy_edi_rotation (bool)

  • variance_policy (str)

  • unsupported_estimates (str)

  • derived_policy (str)

Return type:

EMTF

is_empty()#

Return True when no transfer-function content is attached.

Return type:

bool

to_bundle()#

Return a backward-compatible TFBundle view.

Return type:

TFBundle

classmethod from_bundle(bundle)#

Build an EMTF document from a legacy/generalized bundle.

Parameters:

bundle (TFBundle)

Return type:

EMTF

exception pycsamt.emtf.EMTFRotationError#

Bases: ValueError

Raised when an EMTF rotation cannot be defined unambiguously.

exception pycsamt.emtf.EMTFRotationWarning#

Bases: UserWarning

Base warning for scientifically incomplete EMTF rotations.

exception pycsamt.emtf.ApproximateVarianceRotationWarning#

Bases: EMTFRotationWarning

Warn that variance was handled without complete covariance.

exception pycsamt.emtf.UnsupportedEstimateRotationWarning#

Bases: EMTFRotationWarning

Warn that a statistical estimate cannot be rotated safely.

exception pycsamt.emtf.DerivedDataRotationWarning#

Bases: EMTFRotationWarning

Warn that derived products were dropped or retained stale.

exception pycsamt.emtf.LegacyRotationAssumptionWarning#

Bases: EMTFRotationWarning

Warn that historical EDI rotation metadata are being interpreted.

class pycsamt.emtf.RotationMatrices(input_matrix, output_matrix, source_mode, target_mode, source_angles, target_angle)#

Bases: object

Per-period input and output matrices used in an EMTF rotation.

Parameters:

  • input_matrix (ndarray) – Array of shape (n_period, n_input, n_input) containing U.

  • output_matrix (ndarray) – Array of shape (n_period, n_output, n_output) containing V.

  • source_mode (str) – Coordinate-frame modes used to construct the matrices.

  • target_mode (str) – Coordinate-frame modes used to construct the matrices.

  • source_angles (ndarray or None) – Orthogonal source azimuth(s), in degrees clockwise from geographic north. None when the source follows the physical site layout.

  • target_angle (float or None) – Orthogonal target azimuth. None for site-layout targets.

input_matrix: ndarray#
output_matrix: ndarray#
source_mode: str#
target_mode: str#
source_angles: ndarray | None#
target_angle: float | None#
property n_periods: int#
property is_identity: bool#

Return whether both matrix families are identities.

pycsamt.emtf.horizontal_rotation_matrix(theta1, theta2, target_angle)#

Return the FCU Q transform from two channels to an orthogonal frame.

Angles are degrees clockwise from geographic north. The source channels need not be orthogonal. The matrix maps source vector components into a right-handed orthogonal coordinate frame whose x-axis has azimuth target_angle.

Parameters:
Return type:

ndarray

pycsamt.emtf.horizontal_inverse_rotation_matrix(theta1, theta2, target_angle)#

Return the inverse of horizontal_rotation_matrix().

The explicit formula mirrors EMTF FCU rot2inv and permits a non-orthogonal original site layout. Parallel channels are singular and therefore rejected.

Parameters:
Return type:

ndarray

pycsamt.emtf.rotate_covariance(covariance, matrices, *, side)#

Rotate an inverse-signal or residual covariance matrix family.

Parameters:

  • covariance (array-like) – Shape (n_period, n, n).

  • matrices (array-like) – The corresponding U or V matrices for every period.

  • side ({"input", "output"}) – Descriptive validation label. Both covariance kinds use R @ C @ R.T; the side identifies which matrix family is supplied.

Return type:

ndarray

pycsamt.emtf.rotate_transfer_function(tf, *, source_mode, target_mode='orthogonal', target_angle=0.0, source_angles=None, site_layout=None, variance_policy='drop', unsupported_estimates='drop')#

Rotate one matrix-valued transfer function and supported estimates.

Full INVSIGCOV + RESIDCOV factors are rotated exactly and VAR is recomputed from their diagonal products. If full covariance is absent, variance_policy controls whether VAR is dropped, rejected, or transformed under an explicit approximation.

Parameters:
Return type:

TransferFunction

pycsamt.emtf.rotate_emtf(document, angle=0.0, *, target='orthogonal', inplace=False, source_angles=None, use_legacy_edi_rotation=False, variance_policy='drop', unsupported_estimates='drop', derived_policy='drop')#

Rotate all primary transfer functions in an EMTF document.

Parameters:

  • document (EMTF) – Source scientific document.

  • angle (float, optional) – Target azimuth in degrees clockwise from geographic north. Ignored for target='sitelayout'.

  • target ({"orthogonal", "sitelayout"}) – Coordinate frame to produce.

  • inplace (bool, default=False) – If True, mutate and return document. The original physical SiteLayout object is never modified.

  • source_angles (scalar, array-like, mapping, optional) – Explicit orthogonal source angle(s). A mapping may provide different vectors by TF tag/code, useful for historical principal-axis EDI.

  • use_legacy_edi_rotation (bool, default=False) – Opt in to interpreting retained edi_zrot / edi_trot vectors as orthogonal source frames when document-level orientation is ambiguous.

  • variance_policy ({"drop", "raise", "independent", "fcu"}) – Behavior for VAR when full covariance factors are unavailable.

  • unsupported_estimates ({"drop", "keep", "raise"}) – Policy for estimates without a defined rotation law.

  • derived_policy ({"drop", "keep", "raise"}) – Derived products are not rotated directly; normally they should be recomputed after rotating their primary transfer function.

Return type:

EMTF

exception pycsamt.emtf.DataLossWarning#

Bases: UserWarning

Warning emitted when an EDI conversion cannot preserve information.

exception pycsamt.emtf.EMTFEDIConversionError#

Bases: ValueError

Raised when an EDI conversion would be scientifically invalid.

exception pycsamt.emtf.SpectraCovarianceWarning#

Bases: UserWarning

Warning emitted for recoverable SPECTRA covariance issues.

exception pycsamt.emtf.SpectraRecoveryError#

Bases: EdIDataError

Raised when an exact EDI SPECTRA recovery cannot be performed.

class pycsamt.emtf.SpectraChannelMap(hx, hy, ex, ey, hz=None, rx=None, ry=None, channel_types=())#

Bases: object

Resolved local, remote, and output channel indices.

Parameters:
hx: int#
hy: int#
ex: int#
ey: int#
hz: int | None = None#
rx: int | None = None#
ry: int | None = None#
channel_types: tuple[str, ...] = ()#
property local_h: tuple[int, int]#
property remote_h: tuple[int, int]#
property outputs: tuple[int, ...]#
property reference_type: str#
class pycsamt.emtf.SpectraRecoveryResult(frequency, periods, transfer_functions, channel_map, used_indices, skipped_indices, avgt, rotspec, combined_residual_covariance=None, combined_output_channels=())#

Bases: object

Numerical result of one FCU-compatible SPECTRA recovery.

Parameters:
frequency: ndarray#
periods: ndarray#
transfer_functions: dict[str, TransferFunction]#
channel_map: SpectraChannelMap#
used_indices: ndarray#
skipped_indices: ndarray#
avgt: ndarray#
rotspec: ndarray#
combined_residual_covariance: ndarray | None = None#
combined_output_channels: tuple[str, ...] = ()#
property impedance: TransferFunction#
property tipper: TransferFunction | None#
pycsamt.emtf.resolve_spectra_channels(spectra)#

Resolve FCU local/remote channel roles from SPECTRA channel order.

Historical files commonly encode remote H channels as a second HX/HY pair. Explicit RX/RY or RHX/RHY labels are also accepted. When no remote pair is present, the local HX/HY pair is reused exactly as FCU does for a single-station analysis.

Parameters:

spectra (Any)

Return type:

SpectraChannelMap

pycsamt.emtf.recover_spectra_transfer_functions(spectra, *, nfreq_policy='raise', missing_policy='raise', avgt_policy='raise')#

Recover Z/T and full covariance from an EDI SPECTRA container.

The implementation mirrors EMTF FCU’s read_edi_spectra equations. It intentionally does not rotate the spectra or the recovered TFs; Phase 7’s EMTF rotation engine performs any requested coordinate transformation.

Parameters:

  • spectra (Any)

  • nfreq_policy (str)

  • missing_policy (str)

  • avgt_policy (str)

Return type:

SpectraRecoveryResult

pycsamt.emtf.spectra_to_emtf(source, *, spectra=None, nfreq_policy='raise', missing_policy='raise', avgt_policy='raise', target_angle=None)#

Convert EDI SPECTRA to the format-neutral EMTF scientific model.

If target_angle is supplied, the recovered full-covariance TFs are passed to the Phase-7 rotation engine; no spectra-specific rotation code is used here.

Parameters:

  • source (Any)

  • spectra (Any | None)

  • nfreq_policy (str)

  • missing_policy (str)

  • avgt_policy (str)

  • target_angle (float | None)

Return type:

EMTF

pycsamt.emtf.edi_to_emtf(source, *, prefer_spectra=True, spectra_nfreq_policy='raise', spectra_missing_policy='raise', spectra_avgt_policy='raise')#

Convert a historical SEG EDI object/path into EMTF.

EDI SPECTRA are preferred when present because they retain enough cross-power information to recover the full inverse-signal and residual covariance matrices. Set prefer_spectra=False to force the historical impedance/tipper blocks.

Notes

pyCSAMT historically stores Z.z_err = sqrt(EDI complex variance). The non-SPECTRA path therefore reconstructs EMTF VAR as z_err**2 exactly, preserving the EDI file’s complex-variance convention without redefining the public Z.z_err API. The standard error of a real or imaginary component, when needed statistically, is sqrt(VAR / 2).

Parameters:

  • source (Any)

  • prefer_spectra (bool)

  • spectra_nfreq_policy (str)

  • spectra_missing_policy (str)

  • spectra_avgt_policy (str)

Return type:

EMTF

pycsamt.emtf.emtf_to_edi(document, *, on_loss='warn')#

Convert EMTF into an in-memory historical EDIFile.

The standard EDI representation used here stores impedance/tipper and component variances. Rich covariance matrices, arbitrary TF types, and several EMTF metadata blocks have no lossless destination; on_loss controls whether those reductions warn, raise, or are explicitly ignored.

Parameters:
Return type:

Any

pycsamt.emtf.write_edi(obj, target, *, on_loss='warn', preserve_zero=True, stamp_headers=False, force_tipper=None, **kwargs)#

Write an EMTF or EDIFile to an exact filesystem target.

Existing EDIFile.write() behavior remains unchanged by default. This neutral adapter opts into preserve_zero=True so finite physical zeros are not turned into the EDI missing-value sentinel during format conversion; NaN/Inf values are still serialized as the sentinel.

Parameters:
Return type:

Path

pycsamt.emtf.bundle_to_emtf(bundle)#

Return EMTF from the established TFBundle bridge.

Parameters:

bundle (TFBundle)

Return type:

EMTF

pycsamt.emtf.emtf_to_bundle(document)#

Return a backward-compatible TFBundle view of an EMTF document.

Parameters:

document (EMTF)

Return type:

TFBundle

class pycsamt.emtf.TransferFunction(name, data, input_channels=<factory>, output_channels=<factory>, units=None, periods=None, estimates=<factory>, attrs=<factory>)#

Bases: MTBase

Represent one matrix-valued electromagnetic transfer function.

The canonical array layout is (n_period, n_output_channels, n_input_channels). The matrix axes retain physical channel meaning, unlike EDI’s disconnected component blocks. No EDI or XML syntax is stored in this object.

Parameters:
name: str#
data: Any#
input_channels: tuple[str, ...]#
output_channels: tuple[str, ...]#
units: str | None = None#
periods: Any | None = None#
estimates: dict[str, StatisticalEstimate]#
attrs: dict[str, Any]#
validate()#

Normalize and validate matrix, channels, periods, and estimates.

Return type:

None

property definition: DataTypeDefinition | None#

Return the registry definition associated with this TF.

property n_periods: int#

Number of frequency/period samples.

property n_output: int#

Number of output matrix rows.

property n_input: int#

Number of input matrix columns.

property shape: tuple[int, ...]#

Return the normalized TF data shape.

property frequency: ndarray | None#

Frequency vector in Hz derived from periods.

add_estimate(estimate, *, key=None, replace=False)#

Attach a statistical estimate to this transfer function.

Parameters:
Return type:

TransferFunction

get_estimate(key)#

Return an attached estimate by key, code, or semantic kind.

Parameters:

key (str)

Return type:

StatisticalEstimate | None

copy()#

Return a detached copy of data, periods, estimates, and attrs.

Return type:

TransferFunction

class pycsamt.emtf.StatisticalEstimate(name, data, kind, units=None, attrs=<factory>)#

Bases: PyCSAMTObject

Represent a frequency-indexed statistical estimate.

The object deliberately stores the estimate as supplied instead of coercing all uncertainty information into the legacy z_err model. This is essential for later support of full covariance matrices.

Parameters:

  • name (str) – Short code, e.g. "VAR" or "RESIDCOV".

  • data (array-like) – Numerical estimate. Real and complex arrays are supported.

  • kind (str) – Semantic name such as "variance" or "inverse_signal_covariance".

  • units (str or None) – Units when defined.

  • attrs (dict) – Additional non-serialization-specific metadata.

name: str#
data: Any#
kind: str#
units: str | None = None#
attrs: dict[str, Any]#
validate()#

Normalize and validate the estimate in place.

Return type:

None

property shape: tuple[int, ...]#

Return the stored array shape.

property is_complex: bool#

Return whether the stored estimate has a complex dtype.

copy()#

Return a detached copy of the estimate.

Return type:

StatisticalEstimate

class pycsamt.emtf.DataTypeDefinition(name, tag, data_kind, input_kind=None, output_kind=None, units=None, intention='primary', description='', derived_from=None, aliases=<factory>, see_also=<factory>)#

Bases: PyCSAMTObject

Describe one electromagnetic transfer-function data type.

Parameters:

  • name (str) – Short EMTF/FCU code, for example "Z" or "T".

  • tag (str) – Stable semantic key, for example "impedance".

  • data_kind ({"real", "complex"}) – Numerical representation of the data.

  • input_kind (str or None) – Broad channel families used by EMTF (typically "H" or "E"). Scalar derived products may omit these values.

  • output_kind (str or None) – Broad channel families used by EMTF (typically "H" or "E"). Scalar derived products may omit these values.

  • units (str or None) – Native units recorded by the format definition.

  • intention ({"primary", "derived"}) – Whether the quantity is measured/estimated as a primary TF or derived from another response.

  • description (str) – Human-readable description.

  • derived_from (str or None) – Semantic tag of the parent quantity for derived products.

  • aliases (tuple of str) – Alternate historical codes accepted for lookup. These are useful because the 2020 EMTF paper and FCU v4.1 differ for a few names (for example Q/P versus ZI/TI).

  • see_also (tuple of str) – Related semantic tags.

name: str#
tag: str#
data_kind: str#
input_kind: str | None = None#
output_kind: str | None = None#
units: str | None = None#
intention: str = 'primary'#
description: str = ''#
derived_from: str | None = None#
aliases: tuple[str, ...]#
see_also: tuple[str, ...]#
property is_primary: bool#

Return True for a primary transfer-function type.

property is_derived: bool#

Return True for a derived data type.

pycsamt.emtf.register_emtf_datatype(definition, *, overwrite=False)#

Register and return an EMTF data-type definition.

The semantic tag is the unique registry identity. Short names can be shared by compatible variants (notably full and off-diagonal impedance), therefore the first short-name registration remains the default lookup unless overwrite=True is explicitly requested.

Parameters:
Return type:

DataTypeDefinition

pycsamt.emtf.get_emtf_datatype(key)#

Return a registered definition by semantic tag, code, or alias.

Parameters:

key (str)

Return type:

DataTypeDefinition | None

pycsamt.emtf.list_emtf_datatypes(*, intention=None)#

Return a copy of registered data types keyed by semantic tag.

Parameters:

intention (str | None)

Return type:

dict[str, DataTypeDefinition]

class pycsamt.emtf.EMTFXMLReader(*, strict=True)#

Bases: PyCSAMTObject

Read EMTF XML without routing the document through EDI.

Parameters:

strict (bool, default=True) – In strict mode malformed scientific content raises EMTFXMLParseError. In permissive mode recoverable problems are warned about and the reader preserves as much content as possible.

read(source)#

Read one EMTF XML source into the scientific EMTF model.

Parameters:

source (str | bytes | PathLike[str] | IO[str] | IO[bytes])

Return type:

EMTF

exception pycsamt.emtf.EMTFXMLParseError#

Bases: ValueError

Raised when an EMTF XML document cannot be interpreted safely.

exception pycsamt.emtf.EMTFXMLWarning#

Bases: UserWarning

Warning emitted for recoverable EMTF XML inconsistencies.

pycsamt.emtf.read_emtf_xml(source, *, strict=True)#

Convenience wrapper around EMTFXMLReader.

Parameters:
Return type:

EMTF

class pycsamt.emtf.EMTFXMLSerializer(*, strict=True, precision=17)#

Bases: PyCSAMTObject

Build a deterministic EMTF XML element tree from an EMTF.

Parameters:

  • strict (bool, default=True) – Reject unsupported or scientifically ambiguous content. Permissive mode warns and omits only the problematic component.

  • precision (int, default=17) – Significant decimal digits used for floating-point response data. Seventeen digits are sufficient to round-trip IEEE float64 values.

to_element(document)#

Return the root <EM_TF> element for document.

Parameters:

document (EMTF)

Return type:

Element

exception pycsamt.emtf.EMTFXMLSerializationError#

Bases: ValueError

Raised when an EMTF object cannot be serialized safely.

exception pycsamt.emtf.EMTFXMLWriteWarning#

Bases: UserWarning

Warning emitted when permissive XML writing omits unsafe content.

class pycsamt.emtf.EMTFXMLWriter(*, strict=True, precision=17, pretty=True)#

Bases: PyCSAMTObject

Serialize EMTF documents as EMTF XML.

Parameters:

  • strict (bool, default=True) – Reject unsupported/ambiguous scientific content rather than silently dropping it.

  • precision (int, default=17) – Significant digits used for floating-point response data.

  • pretty (bool, default=True) – Indent the generated XML for human readability.

to_element(document)#

Return a serialized root element.

Parameters:

document (EMTF)

Return type:

Element

dumps(document, *, xml_declaration=True, encoding='utf-8')#

Return a Unicode EMTF XML document.

Parameters:

  • document (EMTF)

  • xml_declaration (bool)

  • encoding (str)

Return type:

str

write(document, target, *, xml_declaration=True, encoding='utf-8')#

Write document to a filesystem path or writable stream.

Parameters:
Return type:

Path | IO[str] | IO[bytes]

pycsamt.emtf.write_emtf_xml(document, target, *, strict=True, precision=17, pretty=True, xml_declaration=True, encoding='utf-8')#

Convenience wrapper around EMTFXMLWriter.

Parameters:
Return type:

Path | IO[str] | IO[bytes]

2.6.1. Core Scientific Model#

pycsamt.emtf.document

Document-level electromagnetic transfer-function scientific container.

pycsamt.emtf.transfer

Matrix-oriented electromagnetic transfer-function scientific objects.

pycsamt.emtf.estimates

Statistical estimate objects used by the format-neutral EMTF core.

pycsamt.emtf.datatypes

Registry of EMTF primary and derived electromagnetic data types.

pycsamt.emtf.validation

Validation helpers for the format-neutral EMTF scientific model.

pycsamt.emtf.base

Shared constants for the format-neutral EMTF scientific core.

2.6.2. Rotation and Covariance#

pycsamt.emtf.orientation

Format-neutral EMTF rotation and covariance transformations.

2.6.3. EDI and TFBundle Interoperability#

pycsamt.emtf.converters.edi

Explicit conversion between SEG EDI and the format-neutral EMTF model.

pycsamt.emtf.converters.spectra

FCU-compatible recovery of EMTFs from historical EDI SPECTRA.

pycsamt.emtf.converters.bundle

Small explicit wrappers for EMTF <-> TFBundle interoperability.

2.6.4. EMTF XML#

pycsamt.emtf.xml.reader

EMTF XML -> format-neutral pycsamt.emtf.EMTF reader.

pycsamt.emtf.xml.writer

Filesystem/stream writer for the EMTF XML serializer.

pycsamt.emtf.xml.serializer

EMTF scientific objects -> deterministic XML element trees.

pycsamt.emtf.xml.parser

Low-level, namespace-safe helpers for EMTF XML parsing.

pycsamt.emtf.xml.constants

Constants used by the EMTF XML reader.
On this page