API

NMRBase

NMRTools.NMRBase.AbstractNMRData — Type

AbstractNMRData <: DimensionalData.AbstractDimArray

Abstract supertype for objects that wrap an array of NMR data, and metadata about its contents.

AbstractNMRDatas inherit from AbstractDimArray from DimensionalData.jl. They can be indexed as regular Julia arrays or with DimensionalData.jl Dimensions.

source

NMRTools.NMRBase.Coherence — Type

Coherence

Abstract supertype for representing coherences.

NMRIO

NMRTools.NMRIO.FQList — Type

FQList(values, unit::Symbol, relative::Bool)

Represents a frequency list. unit can be :Hz or :ppm, and relative indicates whether the frequency is given relative to SFO (true) or BF (false).

Raw values can be extracted using the data function, or (better) as absolute chemical shifts (in ppm) or relative offsets (in Hz) using ppm and hz functions.

See also: hz

source

NMRTools.NMRIO._find_dimension_path — Function

_find_dimension_path(key, annotations, prefix="")

Find the dotted path to a key in the annotations dictionary. Returns the path that should match entries in the dimensions array.

source

NMRTools.NMRIO._is_programmatic_pattern — Method

_is_programmatic_pattern(value) -> Bool

Check if a value is a programmatic list pattern. Must be a Dict with either:

"type" key and either "step" or "end" key (linear/log patterns)
"counter" and "scale" keys (counter-based pattern)

source

NMRTools.NMRIO._resolve_parameter — Method

_resolve_parameter(param_str::String, spec::NMRData) -> Union{Nothing, Any}

Attempt to resolve a parameter string using the acqus data. Returns the resolved value or nothing if not a recognized parameter.

Handles parameter patterns (case-insensitive):

Indexed parameters: p1, pl1, d20, cnst8, gpz6, etc.
Nucleus assignments: f1, f2, f3, f4
Any other parameter names that exist in acqus (including lists)

source

NMRTools.NMRIO._resolve_programmatic_pattern — Method

_resolve_programmatic_pattern(key, pattern, root_annotations, spec, dimensions)

Resolve a single programmatic list pattern to a vector.

source

NMRTools.NMRIO._resolve_programmatic_recursive! — Method

_resolve_programmatic_recursive!(obj, root_annotations, spec, dimensions)

Recursively traverse annotations to find and resolve programmatic list patterns.

source

NMRTools.NMRIO.exampledata — Method

exampledata(name::String)

Load example NMR data provided with NMRTools.jl

Arguments

name::String : Name of example data set to load. Call exampledata() to list available data.

Returns

NMR data object(s) corresponding to the requested example data set.

Example

data = exampledata("1D_19F_titration")

source

NMRTools.NMRIO.getformat — Method

getformat(filename)

Take an input filename and return either :ucsf, :nmrpipe, :pdata (bruker processed), or :unknown after checking whether the filename matches any known format.

source

NMRTools.NMRIO.loadnmr — Method

loadnmr(filename, experimentfolder=nothing)

Main function for loading NMR data. experimentfolder contains the path to an experiment directory, for identification of metadata, if the filename is not directly within an experiment.

Returns an NMRData structure, or throws an NMRToolsError is there is a problem.

Examples

nmrPipe import:

loadnmr("exampledata/1D_1H/1/test.ft1");
loadnmr("exampledata/1D_19F/1/test.ft1");
loadnmr("exampledata/2D_HN/1/test.ft2");
loadnmr("exampledata/pseudo2D_XSTE/1/test.ft1");
loadnmr("exampledata/pseudo3D_HN_R2/1/ft/test%03d.ft2");

Bruker pdata import:

loadnmr("exampledata/1D_19F/1");
loadnmr("exampledata/1D_19F/1/");
loadnmr("exampledata/1D_19F/1/pdata/1");
loadnmr("exampledata/1D_19F/1/pdata/1/");

ucsf (Sparky) import:

loadnmr("exampledata/2D_HN/1/hmqc.ucsf");
loadnmr("exampledata/1D_19F/1/");
loadnmr("exampledata/1D_19F/1/pdata/1");
loadnmr("exampledata/1D_19F/1/pdata/1/");

source

NMRTools.NMRIO.loadnmrpipe1d — Method

loadnmrpipe1d(filename, md, mdax)

Return an NMRData array containing spectrum and associated metadata.

source

NMRTools.NMRIO.loadnmrpipe2d — Method

loadnmrpipe2d(filename, md, mdax)

Return NMRData containing spectrum and associated metadata.

source

NMRTools.NMRIO.loadnmrpipe3d — Method

loadnmrpipe3d(filename, md, mdax)

Return NMRData containing spectrum and associated metadata.

source

NMRTools.NMRIO.loadpdata — Function

loadpdata(filename, allcomponents=false)

Filename will be a reference to a pdata folder.

source

NMRTools.NMRIO.parse_annotations — Method

parse_annotations(content::String) -> Dict{String, Any}

Parse pulse programme annotations from content string. Annotations are embedded within pulse programme comments marked with ;@ at the start of lines.

The function:

Filters out lines starting with ;@
Strips the ;@ prefix from each line
Parses the resulting YAML document into a dictionary

source

NMRTools.NMRIO.parsefqlist — Method

parsefqlist(lines)

Return contents of the specified fqlist.

fqlists can have several different formats:

first line | reference | unit

         | sfo         | Hz

sfo hz | sfo | Hz sfo ppm | sfo | ppm bf hz | bf | Hz bf ppm | bf | ppm p | sfo | ppm P | bf | ppm

source

NMRTools.NMRIO.parsenmrpipeheader — Method

parsenmrpipeheader(header)

Pass a 512 x 4 byte array containing an nmrPipe header file, and returns dictionaries of metadata. The nmrPipe header format is defined in fdatap.h.

Return values

md: dictionary of spectrum metadata
mdax: array of dictionaries containing axis metadata

Examples

md, mdax = parsenmrpipeheader(header)

source

NMRTools.NMRIO.parsepulseprogramlists! — Method

Example lines to parse: define list<gradient> EA=<EA> define list<gradient> EA3 = { 1.0000 0.8750 } define list<pulse> taulist = <$VPLIST> define list<power> powerlist = <$VALIST> define list<gradient> diff=<Difframp> define list<frequency> F19sat = <$FQ1LIST>

NB gradient files have weird syntax!!

source

NMRTools.NMRIO.parseucsfaxisheader — Method

parse ucsf axis header into a dictionary

source

NMRTools.NMRIO.parseucsfheader — Method

parse ucsf file header into a dictionary

source

NMRTools.NMRIO.parsevalist — Method

return valist contents as Powers

source

NMRTools.NMRIO.parsevdlist — Method

return vdlist contents in seconds

source

NMRTools.NMRIO.parsevplist — Method

return vplist contents in seconds

source

NMRTools.NMRIO.replacedurations! — Method

replacedurations!(dic)

Ensure all durations in the acqus dictionary are in seconds.

source

NMRTools.NMRIO.replacepowers! — Method

replacepowers!(dic)

Ensure all powers in the acqus dictionary are stored as Power types.

source

NMRTools.NMRIO.resolve_parameter_references! — Method

resolve_parameter_references!(annotations::Dict{String, Any}, spec::NMRData)

Recursively traverse the annotations dictionary and resolve parameter references. References are bare parameter names like p1, pl1, d20, VALIST, etc.

Parameters are resolved using the acqus() function to get values from the acqus file.

Arguments

annotations::Dict{String, Any}: Annotations dictionary to modify in-place
spec::NMRData: NMRData object containing acqus metadata

Examples

# Before resolution: {"pulse": "p1", "power": "pl1", "duration": "VDLIST"}
# After resolution: {"pulse": 9.2, "power": Power(...), "duration": [0.01, 0.02, ...]}

source

NMRTools.NMRIO.resolve_programmatic_lists! — Method

resolve_programmatic_lists!(annotations::Dict{String, Any}, spec::NMRData)

Resolve programmatic list patterns in annotations to actual vectors.

Programmatic lists are specified as dictionaries with one of two patterns:

Pattern 1: Type-based (linear/log)

type: "linear" or "log" (logarithmic)
start: starting value
step: step size (for linear with start/step)
end: ending value (for linear or log with start/end)

Pattern 2: Counter-based

counter: array of values (typically integers from a loop counter)
scale: scale factor to multiply each counter element by

For type-based patterns, the function:

Identifies fields containing programmatic list patterns ({type, start, step/end})
Finds the dimension number for that field from the dimensions annotation
Gets the number of points in that dimension
Replaces the pattern with a correctly sized vector

For counter-based patterns, the function:

Multiplies each element of the counter array by the scale value
Returns the resulting vector

Examples

# Linear spacing with start/step
# {type: linear, start: p9, step: p9} with 10 points → [p9, 2*p9, 3*p9, ...]

# Linear spacing with start/end
# {type: linear, start: 0.001, end: 0.1} with 10 points → [0.001, 0.012, ..., 0.1]

# Logarithmic spacing with start/end
# {type: log, start: 0.001, end: 0.1} with 10 points → [0.001, 0.0016, ..., 0.1]

# Counter-based pattern
# {counter: [0, 1, 2, 3], scale: 0.01} → [0.0, 0.01, 0.02, 0.03]

source

NMRTools.NMRIO.sumexpts — Method

sumexpts(inputexpts...; out, weights=[])

Sum a collection of Bruker NMR experiments, with optional weighting factors. Data will be truncated to fit the shortest data file.

Arguments

inputexpts...: Input experiment names (strings or integers)
out: Output experiment name (string or integer)
weights: Optional vector of weights for each input experiment

Details

Experiment names should be either strings with filenames or integers converted to strings
If weights are supplied, the length must match the number of input experiments
First input experiment is used as a template for the output experiment
For 1D experiments, 'fid' files are added; for nD experiments, 'ser' files are added
Processed data files in pdata/1 are removed, other pdata subdirectories are deleted
Updates the title file with information about the summed experiments
Updates the number of scans in the acqus file to be the sum of individual experiments
Prompts before overwriting any existing experiment

source

NMRTools.NMRIO.topspinversion — Method

parsetopspinversion(acqusfilename)

Return the TopSpin version as a VersionNumber (e.g. v"4.2.0").

This is obtained from the end of the first line of the acqus file, e.g.

##TITLE= Parameter file, TopSpin 4.2.0
##TITLE= Parameter file, TOPSPIN		Version 2.1
##TITLE= Parameter file, TOPSPIN		Version 3.2

source