Skip to content
BranchesTags

Repository files navigation

RvSpectML

GitHub tagStableBuild Status

Coverage

RvSpectML.jl is a package to facilitate the analysis of stellar spectroscopic times series. The primary goal is to measure extremely precise radial velocities (EPRVs).
To support that goal, it will also include tools to deal with intrinsic stellar variability and telluric variability. RvSpectML works with several other related packages.

Scope

RvSpectML.jl is currently able to:

  • Call EchelleInstruments.jl to:
    • create a manifest of files (as a DataFrame) to be ingested from a directory (custom filtering via Query.jl)
    • read datafiles from NEID and EXPRES into a common set of data structures,
    • perform basic pre-processing (filtering out some orders, pixels within an order, chunks of spectra with NaNs, normalize spectra,...)
    • read a line list or cross-correlation function (CCF) mask file based on ESPRESSO or VALD,
  • Call EchelleCCFs.jl:
    • compute cross-correlation function (CCF) of spectra relative to multiple CCF mask shapes efficiently,
    • measure RVs based on either the CCF
  • interpolate spectra to a new set of wavelengths using linear, sinc, or Gaussian process regression algorithms,
  • combine many files into a template spectra, interpolating them to a common wavelength grid and applying Doppler shift by estimated RV,
  • measure RVs based on a Taylor expansion of the flux,
  • perform Doppler-constrained PCA analysis.
  • Call RvSpectMLPlots.jl to:
    • make some common plots

RvSpectML.jl and/or its companion packages will eventually include tools to:

  • read datafiles from additional spectrographs into a common set of data structures,
  • perform additional pre-processing steps as needed,
  • measure RVs using additional methods,
  • calculated additional stellar activity indicators, and
  • predict contamination due to stellar variability.

Contributing

For now, please start by contributing code that you anticipate is likely useful for collaborators or other researchers. Please keep code where you are actively experimenting with new approaches in separate github repositories. Once you have a basic working example of how to apply your methods, then please create an example demonstrating that.
Once it is reasonably mature, then please contact Eric to discuss whether to merge your code into this repo, one of the other associated repo or to keep it as an example showing how to use your method in its separate repository.

Related Packages & Repos

  • RvSpectMLBase: Types, common small utilities. Minimal dependancies.
  • EchelleInstruments.jl: Code specific to each instrument
  • EchelleCCFs.jl: Computes CCFs with an anlytic mask
  • RVSpectML (this package) holds larger algorithms and code that interconnects the component packages. (Any plotting should be outside of src and not in the Project.toml.)
  • Scalpels.jl: Provides Scalpels algorithm for analyzing an ensemble of CCFs and estimating RVs and contamination from stellar variability.
  • NeidArchive.jl: Julia wrapper for API to query/download data from Neid archives.
  • GPLinearODEMaker: Implements a multi-variate GP time-series likelihood and optimization functions.
  • RvSpectMLPlots.jl: Plotting functions/scripts/notebooks, so other packages don't get bogged down by Plots.jl

About

Better Radial velocities from Stellar Spectroscopy via Machine Learning

Topics

astroinformaticsastrostatisticsexoplanetsradial-velocitiesspectrastellar-variabilitytime-series-analysis

Resources

Readme
MIT license
Activity
Custom properties

Stars

12 stars

Watchers

2 watching

Forks

3 forks
Report repository

Releases

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - RvSpectML/RvSpectML.jl: Better Radial velocities from Stellar Spectroscopy via Machine Learning · GitHub
Skip to content
BranchesTags
Repository files navigation
RvSpectML
GitHub tagStableBuild Status
Coverage
RvSpectML.jl is a package to facilitate the analysis of stellar spectroscopic times series.
The primary goal is to measure extremely precise radial velocities (EPRVs).

To support that goal, it will also include tools to deal with intrinsic stellar variability and telluric variability. RvSpectML works with several other related packages.
Scope
RvSpectML.jl is currently able to:
  • Call EchelleInstruments.jl to:

    • create a manifest of files (as a DataFrame) to be ingested from a directory (custom filtering via Query.jl)
    • read datafiles from NEID and EXPRES into a common set of data structures,
    • perform basic pre-processing (filtering out some orders, pixels within an order, chunks of spectra with NaNs, normalize spectra,...)
    • read a line list or cross-correlation function (CCF) mask file based on ESPRESSO or VALD,
  • Call EchelleCCFs.jl:

    • compute cross-correlation function (CCF) of spectra relative to multiple CCF mask shapes efficiently,
    • measure RVs based on either the CCF
  • interpolate spectra to a new set of wavelengths using linear, sinc, or Gaussian process regression algorithms,
  • combine many files into a template spectra, interpolating them to a common wavelength grid and applying Doppler shift by estimated RV,
  • measure RVs based on a Taylor expansion of the flux,
  • perform Doppler-constrained PCA analysis.
  • Call RvSpectMLPlots.jl to:

    • make some common plots
RvSpectML.jl and/or its companion packages will eventually include tools to:
  • read datafiles from additional spectrographs into a common set of data structures,
  • perform additional pre-processing steps as needed,
  • measure RVs using additional methods,
  • calculated additional stellar activity indicators, and
  • predict contamination due to stellar variability.
Contributing
For now, please start by contributing code that you anticipate is likely useful for collaborators or other researchers.
Please keep code where you are actively experimenting with new approaches in separate github repositories. Once you have a basic working example of how to apply your methods, then please create an example demonstrating that.

Once it is reasonably mature, then please contact Eric to discuss whether to merge your code into this repo, one of the other associated repo or to keep it as an example showing how to use your method in its separate repository.
Related Packages & Repos
  • RvSpectMLBase: Types, common small utilities. Minimal dependancies.
  • EchelleInstruments.jl: Code specific to each instrument
  • EchelleCCFs.jl: Computes CCFs with an anlytic mask
  • RVSpectML (this package) holds larger algorithms and code that interconnects the component packages. (Any plotting should be outside of src and not in the Project.toml.)
  • Scalpels.jl: Provides Scalpels algorithm for analyzing an ensemble of CCFs and estimating RVs and contamination from stellar variability.
  • NeidArchive.jl: Julia wrapper for API to query/download data from Neid archives.
  • GPLinearODEMaker: Implements a multi-variate GP time-series likelihood and optimization functions.
  • RvSpectMLPlots.jl: Plotting functions/scripts/notebooks, so other packages don't get bogged down by Plots.jl
About
Better Radial velocities from Stellar Spectroscopy via Machine Learning
Topics
astroinformaticsastrostatisticsexoplanetsradial-velocitiesspectrastellar-variabilitytime-series-analysis
Resources
Readme
MIT license
Activity
Custom properties
Stars
12 stars
Watchers
2 watching
Forks
3 forks
Report repository
Releases
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - RvSpectML/RvSpectML.jl: Better Radial velocities from Stellar Spectroscopy via Machine Learning · GitHub
Skip to content
BranchesTags
Repository files navigation
RvSpectML
GitHub tagStableBuild Status
Coverage
RvSpectML.jl is a package to facilitate the analysis of stellar spectroscopic times series.
The primary goal is to measure extremely precise radial velocities (EPRVs).

To support that goal, it will also include tools to deal with intrinsic stellar variability and telluric variability. RvSpectML works with several other related packages.
Scope
RvSpectML.jl is currently able to:
  • Call EchelleInstruments.jl to:

    • create a manifest of files (as a DataFrame) to be ingested from a directory (custom filtering via Query.jl)
    • read datafiles from NEID and EXPRES into a common set of data structures,
    • perform basic pre-processing (filtering out some orders, pixels within an order, chunks of spectra with NaNs, normalize spectra,...)
    • read a line list or cross-correlation function (CCF) mask file based on ESPRESSO or VALD,
  • Call EchelleCCFs.jl:

    • compute cross-correlation function (CCF) of spectra relative to multiple CCF mask shapes efficiently,
    • measure RVs based on either the CCF
  • interpolate spectra to a new set of wavelengths using linear, sinc, or Gaussian process regression algorithms,
  • combine many files into a template spectra, interpolating them to a common wavelength grid and applying Doppler shift by estimated RV,
  • measure RVs based on a Taylor expansion of the flux,
  • perform Doppler-constrained PCA analysis.
  • Call RvSpectMLPlots.jl to:

    • make some common plots
RvSpectML.jl and/or its companion packages will eventually include tools to:
  • read datafiles from additional spectrographs into a common set of data structures,
  • perform additional pre-processing steps as needed,
  • measure RVs using additional methods,
  • calculated additional stellar activity indicators, and
  • predict contamination due to stellar variability.
Contributing
For now, please start by contributing code that you anticipate is likely useful for collaborators or other researchers.
Please keep code where you are actively experimenting with new approaches in separate github repositories. Once you have a basic working example of how to apply your methods, then please create an example demonstrating that.

Once it is reasonably mature, then please contact Eric to discuss whether to merge your code into this repo, one of the other associated repo or to keep it as an example showing how to use your method in its separate repository.
Related Packages & Repos
  • RvSpectMLBase: Types, common small utilities. Minimal dependancies.
  • EchelleInstruments.jl: Code specific to each instrument
  • EchelleCCFs.jl: Computes CCFs with an anlytic mask
  • RVSpectML (this package) holds larger algorithms and code that interconnects the component packages. (Any plotting should be outside of src and not in the Project.toml.)
  • Scalpels.jl: Provides Scalpels algorithm for analyzing an ensemble of CCFs and estimating RVs and contamination from stellar variability.
  • NeidArchive.jl: Julia wrapper for API to query/download data from Neid archives.
  • GPLinearODEMaker: Implements a multi-variate GP time-series likelihood and optimization functions.
  • RvSpectMLPlots.jl: Plotting functions/scripts/notebooks, so other packages don't get bogged down by Plots.jl
About
Better Radial velocities from Stellar Spectroscopy via Machine Learning
Topics
astroinformaticsastrostatisticsexoplanetsradial-velocitiesspectrastellar-variabilitytime-series-analysis
Resources
Readme
MIT license
Activity
Custom properties
Stars
12 stars
Watchers
2 watching
Forks
3 forks
Report repository
Releases
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - RvSpectML/RvSpectML.jl: Better Radial velocities from Stellar Spectroscopy via Machine Learning · GitHub
Skip to content
BranchesTags
Repository files navigation
RvSpectML
GitHub tagStableBuild Status
Coverage
RvSpectML.jl is a package to facilitate the analysis of stellar spectroscopic times series.
The primary goal is to measure extremely precise radial velocities (EPRVs).

To support that goal, it will also include tools to deal with intrinsic stellar variability and telluric variability. RvSpectML works with several other related packages.
Scope
RvSpectML.jl is currently able to:
  • Call EchelleInstruments.jl to:

    • create a manifest of files (as a DataFrame) to be ingested from a directory (custom filtering via Query.jl)
    • read datafiles from NEID and EXPRES into a common set of data structures,
    • perform basic pre-processing (filtering out some orders, pixels within an order, chunks of spectra with NaNs, normalize spectra,...)
    • read a line list or cross-correlation function (CCF) mask file based on ESPRESSO or VALD,
  • Call EchelleCCFs.jl:

    • compute cross-correlation function (CCF) of spectra relative to multiple CCF mask shapes efficiently,
    • measure RVs based on either the CCF
  • interpolate spectra to a new set of wavelengths using linear, sinc, or Gaussian process regression algorithms,
  • combine many files into a template spectra, interpolating them to a common wavelength grid and applying Doppler shift by estimated RV,
  • measure RVs based on a Taylor expansion of the flux,
  • perform Doppler-constrained PCA analysis.
  • Call RvSpectMLPlots.jl to:

    • make some common plots
RvSpectML.jl and/or its companion packages will eventually include tools to:
  • read datafiles from additional spectrographs into a common set of data structures,
  • perform additional pre-processing steps as needed,
  • measure RVs using additional methods,
  • calculated additional stellar activity indicators, and
  • predict contamination due to stellar variability.
Contributing
For now, please start by contributing code that you anticipate is likely useful for collaborators or other researchers.
Please keep code where you are actively experimenting with new approaches in separate github repositories. Once you have a basic working example of how to apply your methods, then please create an example demonstrating that.

Once it is reasonably mature, then please contact Eric to discuss whether to merge your code into this repo, one of the other associated repo or to keep it as an example showing how to use your method in its separate repository.
Related Packages & Repos
  • RvSpectMLBase: Types, common small utilities. Minimal dependancies.
  • EchelleInstruments.jl: Code specific to each instrument
  • EchelleCCFs.jl: Computes CCFs with an anlytic mask
  • RVSpectML (this package) holds larger algorithms and code that interconnects the component packages. (Any plotting should be outside of src and not in the Project.toml.)
  • Scalpels.jl: Provides Scalpels algorithm for analyzing an ensemble of CCFs and estimating RVs and contamination from stellar variability.
  • NeidArchive.jl: Julia wrapper for API to query/download data from Neid archives.
  • GPLinearODEMaker: Implements a multi-variate GP time-series likelihood and optimization functions.
  • RvSpectMLPlots.jl: Plotting functions/scripts/notebooks, so other packages don't get bogged down by Plots.jl
About
Better Radial velocities from Stellar Spectroscopy via Machine Learning
Topics
astroinformaticsastrostatisticsexoplanetsradial-velocitiesspectrastellar-variabilitytime-series-analysis
Resources
Readme
MIT license
Activity
Custom properties
Stars
12 stars
Watchers
2 watching
Forks
3 forks
Report repository
Releases
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - RvSpectML/RvSpectML.jl: Better Radial velocities from Stellar Spectroscopy via Machine Learning · GitHub
Skip to content
BranchesTags
Repository files navigation
RvSpectML
GitHub tagStableBuild Status
Coverage
RvSpectML.jl is a package to facilitate the analysis of stellar spectroscopic times series.
The primary goal is to measure extremely precise radial velocities (EPRVs).

To support that goal, it will also include tools to deal with intrinsic stellar variability and telluric variability. RvSpectML works with several other related packages.
Scope
RvSpectML.jl is currently able to:
  • Call EchelleInstruments.jl to:

    • create a manifest of files (as a DataFrame) to be ingested from a directory (custom filtering via Query.jl)
    • read datafiles from NEID and EXPRES into a common set of data structures,
    • perform basic pre-processing (filtering out some orders, pixels within an order, chunks of spectra with NaNs, normalize spectra,...)
    • read a line list or cross-correlation function (CCF) mask file based on ESPRESSO or VALD,
  • Call EchelleCCFs.jl:

    • compute cross-correlation function (CCF) of spectra relative to multiple CCF mask shapes efficiently,
    • measure RVs based on either the CCF
  • interpolate spectra to a new set of wavelengths using linear, sinc, or Gaussian process regression algorithms,
  • combine many files into a template spectra, interpolating them to a common wavelength grid and applying Doppler shift by estimated RV,
  • measure RVs based on a Taylor expansion of the flux,
  • perform Doppler-constrained PCA analysis.
  • Call RvSpectMLPlots.jl to:

    • make some common plots
RvSpectML.jl and/or its companion packages will eventually include tools to:
  • read datafiles from additional spectrographs into a common set of data structures,
  • perform additional pre-processing steps as needed,
  • measure RVs using additional methods,
  • calculated additional stellar activity indicators, and
  • predict contamination due to stellar variability.
Contributing
For now, please start by contributing code that you anticipate is likely useful for collaborators or other researchers.
Please keep code where you are actively experimenting with new approaches in separate github repositories. Once you have a basic working example of how to apply your methods, then please create an example demonstrating that.

Once it is reasonably mature, then please contact Eric to discuss whether to merge your code into this repo, one of the other associated repo or to keep it as an example showing how to use your method in its separate repository.
Related Packages & Repos
  • RvSpectMLBase: Types, common small utilities. Minimal dependancies.
  • EchelleInstruments.jl: Code specific to each instrument
  • EchelleCCFs.jl: Computes CCFs with an anlytic mask
  • RVSpectML (this package) holds larger algorithms and code that interconnects the component packages. (Any plotting should be outside of src and not in the Project.toml.)
  • Scalpels.jl: Provides Scalpels algorithm for analyzing an ensemble of CCFs and estimating RVs and contamination from stellar variability.
  • NeidArchive.jl: Julia wrapper for API to query/download data from Neid archives.
  • GPLinearODEMaker: Implements a multi-variate GP time-series likelihood and optimization functions.
  • RvSpectMLPlots.jl: Plotting functions/scripts/notebooks, so other packages don't get bogged down by Plots.jl
About
Better Radial velocities from Stellar Spectroscopy via Machine Learning
Topics
astroinformaticsastrostatisticsexoplanetsradial-velocitiesspectrastellar-variabilitytime-series-analysis
Resources
Readme
MIT license
Activity
Custom properties
Stars
12 stars
Watchers
2 watching
Forks
3 forks
Report repository
Releases
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - RvSpectML/RvSpectML.jl: Better Radial velocities from Stellar Spectroscopy via Machine Learning · GitHub
Skip to content
BranchesTags
Repository files navigation
RvSpectML
GitHub tagStableBuild Status
Coverage
RvSpectML.jl is a package to facilitate the analysis of stellar spectroscopic times series.
The primary goal is to measure extremely precise radial velocities (EPRVs).

To support that goal, it will also include tools to deal with intrinsic stellar variability and telluric variability. RvSpectML works with several other related packages.
Scope
RvSpectML.jl is currently able to:
  • Call EchelleInstruments.jl to:

    • create a manifest of files (as a DataFrame) to be ingested from a directory (custom filtering via Query.jl)
    • read datafiles from NEID and EXPRES into a common set of data structures,
    • perform basic pre-processing (filtering out some orders, pixels within an order, chunks of spectra with NaNs, normalize spectra,...)
    • read a line list or cross-correlation function (CCF) mask file based on ESPRESSO or VALD,
  • Call EchelleCCFs.jl:

    • compute cross-correlation function (CCF) of spectra relative to multiple CCF mask shapes efficiently,
    • measure RVs based on either the CCF
  • interpolate spectra to a new set of wavelengths using linear, sinc, or Gaussian process regression algorithms,
  • combine many files into a template spectra, interpolating them to a common wavelength grid and applying Doppler shift by estimated RV,
  • measure RVs based on a Taylor expansion of the flux,
  • perform Doppler-constrained PCA analysis.
  • Call RvSpectMLPlots.jl to:

    • make some common plots
RvSpectML.jl and/or its companion packages will eventually include tools to:
  • read datafiles from additional spectrographs into a common set of data structures,
  • perform additional pre-processing steps as needed,
  • measure RVs using additional methods,
  • calculated additional stellar activity indicators, and
  • predict contamination due to stellar variability.
Contributing
For now, please start by contributing code that you anticipate is likely useful for collaborators or other researchers.
Please keep code where you are actively experimenting with new approaches in separate github repositories. Once you have a basic working example of how to apply your methods, then please create an example demonstrating that.

Once it is reasonably mature, then please contact Eric to discuss whether to merge your code into this repo, one of the other associated repo or to keep it as an example showing how to use your method in its separate repository.
Related Packages & Repos
  • RvSpectMLBase: Types, common small utilities. Minimal dependancies.
  • EchelleInstruments.jl: Code specific to each instrument
  • EchelleCCFs.jl: Computes CCFs with an anlytic mask
  • RVSpectML (this package) holds larger algorithms and code that interconnects the component packages. (Any plotting should be outside of src and not in the Project.toml.)
  • Scalpels.jl: Provides Scalpels algorithm for analyzing an ensemble of CCFs and estimating RVs and contamination from stellar variability.
  • NeidArchive.jl: Julia wrapper for API to query/download data from Neid archives.
  • GPLinearODEMaker: Implements a multi-variate GP time-series likelihood and optimization functions.
  • RvSpectMLPlots.jl: Plotting functions/scripts/notebooks, so other packages don't get bogged down by Plots.jl
About
Better Radial velocities from Stellar Spectroscopy via Machine Learning
Topics
astroinformaticsastrostatisticsexoplanetsradial-velocitiesspectrastellar-variabilitytime-series-analysis
Resources
Readme
MIT license
Activity
Custom properties
Stars
12 stars
Watchers
2 watching
Forks
3 forks
Report repository
Releases
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - RvSpectML/RvSpectML.jl: Better Radial velocities from Stellar Spectroscopy via Machine Learning · GitHub
Skip to content
BranchesTags
Repository files navigation
RvSpectML
GitHub tagStableBuild Status
Coverage
RvSpectML.jl is a package to facilitate the analysis of stellar spectroscopic times series.
The primary goal is to measure extremely precise radial velocities (EPRVs).

To support that goal, it will also include tools to deal with intrinsic stellar variability and telluric variability. RvSpectML works with several other related packages.
Scope
RvSpectML.jl is currently able to:
  • Call EchelleInstruments.jl to:

    • create a manifest of files (as a DataFrame) to be ingested from a directory (custom filtering via Query.jl)
    • read datafiles from NEID and EXPRES into a common set of data structures,
    • perform basic pre-processing (filtering out some orders, pixels within an order, chunks of spectra with NaNs, normalize spectra,...)
    • read a line list or cross-correlation function (CCF) mask file based on ESPRESSO or VALD,
  • Call EchelleCCFs.jl:

    • compute cross-correlation function (CCF) of spectra relative to multiple CCF mask shapes efficiently,
    • measure RVs based on either the CCF
  • interpolate spectra to a new set of wavelengths using linear, sinc, or Gaussian process regression algorithms,
  • combine many files into a template spectra, interpolating them to a common wavelength grid and applying Doppler shift by estimated RV,
  • measure RVs based on a Taylor expansion of the flux,
  • perform Doppler-constrained PCA analysis.
  • Call RvSpectMLPlots.jl to:

    • make some common plots
RvSpectML.jl and/or its companion packages will eventually include tools to:
  • read datafiles from additional spectrographs into a common set of data structures,
  • perform additional pre-processing steps as needed,
  • measure RVs using additional methods,
  • calculated additional stellar activity indicators, and
  • predict contamination due to stellar variability.
Contributing
For now, please start by contributing code that you anticipate is likely useful for collaborators or other researchers.
Please keep code where you are actively experimenting with new approaches in separate github repositories. Once you have a basic working example of how to apply your methods, then please create an example demonstrating that.

Once it is reasonably mature, then please contact Eric to discuss whether to merge your code into this repo, one of the other associated repo or to keep it as an example showing how to use your method in its separate repository.
Related Packages & Repos
  • RvSpectMLBase: Types, common small utilities. Minimal dependancies.
  • EchelleInstruments.jl: Code specific to each instrument
  • EchelleCCFs.jl: Computes CCFs with an anlytic mask
  • RVSpectML (this package) holds larger algorithms and code that interconnects the component packages. (Any plotting should be outside of src and not in the Project.toml.)
  • Scalpels.jl: Provides Scalpels algorithm for analyzing an ensemble of CCFs and estimating RVs and contamination from stellar variability.
  • NeidArchive.jl: Julia wrapper for API to query/download data from Neid archives.
  • GPLinearODEMaker: Implements a multi-variate GP time-series likelihood and optimization functions.
  • RvSpectMLPlots.jl: Plotting functions/scripts/notebooks, so other packages don't get bogged down by Plots.jl
About
Better Radial velocities from Stellar Spectroscopy via Machine Learning
Topics
astroinformaticsastrostatisticsexoplanetsradial-velocitiesspectrastellar-variabilitytime-series-analysis
Resources
Readme
MIT license
Activity
Custom properties
Stars
12 stars
Watchers
2 watching
Forks
3 forks
Report repository
Releases
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - RvSpectML/RvSpectML.jl: Better Radial velocities from Stellar Spectroscopy via Machine Learning · GitHub
Skip to content
BranchesTags
Repository files navigation
RvSpectML
GitHub tagStableBuild Status
Coverage
RvSpectML.jl is a package to facilitate the analysis of stellar spectroscopic times series.
The primary goal is to measure extremely precise radial velocities (EPRVs).

To support that goal, it will also include tools to deal with intrinsic stellar variability and telluric variability. RvSpectML works with several other related packages.
Scope
RvSpectML.jl is currently able to:
  • Call EchelleInstruments.jl to:

    • create a manifest of files (as a DataFrame) to be ingested from a directory (custom filtering via Query.jl)
    • read datafiles from NEID and EXPRES into a common set of data structures,
    • perform basic pre-processing (filtering out some orders, pixels within an order, chunks of spectra with NaNs, normalize spectra,...)
    • read a line list or cross-correlation function (CCF) mask file based on ESPRESSO or VALD,
  • Call EchelleCCFs.jl:

    • compute cross-correlation function (CCF) of spectra relative to multiple CCF mask shapes efficiently,
    • measure RVs based on either the CCF
  • interpolate spectra to a new set of wavelengths using linear, sinc, or Gaussian process regression algorithms,
  • combine many files into a template spectra, interpolating them to a common wavelength grid and applying Doppler shift by estimated RV,
  • measure RVs based on a Taylor expansion of the flux,
  • perform Doppler-constrained PCA analysis.
  • Call RvSpectMLPlots.jl to:

    • make some common plots
RvSpectML.jl and/or its companion packages will eventually include tools to:
  • read datafiles from additional spectrographs into a common set of data structures,
  • perform additional pre-processing steps as needed,
  • measure RVs using additional methods,
  • calculated additional stellar activity indicators, and
  • predict contamination due to stellar variability.
Contributing
For now, please start by contributing code that you anticipate is likely useful for collaborators or other researchers.
Please keep code where you are actively experimenting with new approaches in separate github repositories. Once you have a basic working example of how to apply your methods, then please create an example demonstrating that.

Once it is reasonably mature, then please contact Eric to discuss whether to merge your code into this repo, one of the other associated repo or to keep it as an example showing how to use your method in its separate repository.
Related Packages & Repos
  • RvSpectMLBase: Types, common small utilities. Minimal dependancies.
  • EchelleInstruments.jl: Code specific to each instrument
  • EchelleCCFs.jl: Computes CCFs with an anlytic mask
  • RVSpectML (this package) holds larger algorithms and code that interconnects the component packages. (Any plotting should be outside of src and not in the Project.toml.)
  • Scalpels.jl: Provides Scalpels algorithm for analyzing an ensemble of CCFs and estimating RVs and contamination from stellar variability.
  • NeidArchive.jl: Julia wrapper for API to query/download data from Neid archives.
  • GPLinearODEMaker: Implements a multi-variate GP time-series likelihood and optimization functions.
  • RvSpectMLPlots.jl: Plotting functions/scripts/notebooks, so other packages don't get bogged down by Plots.jl
About
Better Radial velocities from Stellar Spectroscopy via Machine Learning
Topics
astroinformaticsastrostatisticsexoplanetsradial-velocitiesspectrastellar-variabilitytime-series-analysis
Resources
Readme
MIT license
Activity
Custom properties
Stars
12 stars
Watchers
2 watching
Forks
3 forks
Report repository
Releases
Contributors
Languages