From 00a3f150a737173385e928be09cad3ab6174f34d Mon Sep 17 00:00:00 2001 From: Jeremy Prevost Date: Wed, 6 Jul 2022 11:50:19 -0400 Subject: [PATCH] OpenSearch and GraphQL for multiple source filters Why are these changes being introduced: * Being able to search multiple source at once is desired Relevant ticket(s): * https://mitlibraries.atlassian.net/browse/RDI-170 How does this address that need: * Creates a method to add "OR" filtering in OpenSearch * Updates GraphQL to expect source as an array of keywords instead of a single string Document any side effects to this change: * GraphQL previously expected Source as a single string and now expects an array of strings. As V2 is not yet launched, this isn't a concern for V2, but may require changes for V1 consumers including Bento which filters to just ArchivesSpace. --- app/graphql/types/query_type.rb | 2 +- app/models/opensearch.rb | 25 +++- .../controllers/graphql_controller_v2_test.rb | 98 ++++++++++++++++ test/models/opensearch_test.rb | 21 +++- .../graphql_v2_filter_multiple_sources.yml | 108 ++++++++++++++++++ .../graphql_v2_filter_single_source.yml | 108 ++++++++++++++++++ 6 files changed, 356 insertions(+), 6 deletions(-) create mode 100644 test/vcr_cassettes/graphql_v2_filter_multiple_sources.yml create mode 100644 test/vcr_cassettes/graphql_v2_filter_single_source.yml diff --git a/app/graphql/types/query_type.rb b/app/graphql/types/query_type.rb index 33ad9b7..c0576f2 100644 --- a/app/graphql/types/query_type.rb +++ b/app/graphql/types/query_type.rb @@ -52,7 +52,7 @@ def record_id(id:) argument :format_facet, [String], required: false, default_value: nil argument :languages_facet, [String], required: false, default_value: nil argument :literary_form_facet, String, required: false, default_value: nil - argument :source_facet, String, required: false, default_value: 'All' + argument :source_facet, [String], required: false, default_value: nil argument :subjects_facet, [String], required: false, default_value: nil end else diff --git a/app/models/opensearch.rb b/app/models/opensearch.rb index 39ac149..e9c74c3 100644 --- a/app/models/opensearch.rb +++ b/app/models/opensearch.rb @@ -4,7 +4,7 @@ class Opensearch def search(from, params, client) @params = params - client.search(index: ENV['ELASTICSEARCH_INDEX'], + client.search(index: ENV.fetch('ELASTICSEARCH_INDEX', nil), body: build_query(from)) end @@ -114,7 +114,8 @@ def filters f.push filter_single(@params[:literary_form_facet], 'literary_form') if @params[:literary_form_facet] - f.push filter_single(@params[:source_facet], 'source') if @params[:source_facet] + f.push filter_sources(@params[:source_facet]) if @params[:source_facet] + f.push filter(@params[:subjects_facet], 'subjects') if @params[:subjects_facet] f end @@ -155,6 +156,26 @@ def filter_single(param, field) } end + def filter_sources(param) + { + bool: { + should: source_array(param) + } + } + end + + def source_array(param) + sources = [] + param.each do |source| + sources << { + term: { + source: source + } + } + end + sources + end + # https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations-bucket-terms-aggregation.html def aggregations { diff --git a/test/controllers/graphql_controller_v2_test.rb b/test/controllers/graphql_controller_v2_test.rb index 254cc90..d47fecb 100644 --- a/test/controllers/graphql_controller_v2_test.rb +++ b/test/controllers/graphql_controller_v2_test.rb @@ -314,4 +314,102 @@ def setup json = JSON.parse(response.body) assert(json['errors'].first['message'].present?) end + + test 'graphqlv2 filter multiple sources' do + VCR.use_cassette('graphql v2 filter multiple sources') do + + # no filters to return all sources. used later to test filters return less than the total. + post '/graphql', params: { query: + '{ + search(searchterm: "data") { + hits + aggregations { + source { + key + docCount + } + } + } + }' + } + + json = JSON.parse(response.body) + initial_source_array = json['data']['search']['aggregations']['source'] + + # filtering to 2 sources returns 2 sources + post '/graphql', params: { query: + '{ + search(searchterm: "data", sourceFacet: ["Zenodo", "DSpace@MIT"]) { + hits + aggregations { + source { + key + docCount + } + } + } + }' + } + assert_equal(200, response.status) + + json = JSON.parse(response.body) + filtered_source_array = json['data']['search']['aggregations']['source'] + + assert(initial_source_array.count > filtered_source_array.count) + assert_equal(2, filtered_source_array.count) + + expected_sources = ['zenodo', 'dspace@mit'] + actual_sources = filtered_source_array.map{|source| source["key"]} + assert_equal(expected_sources, actual_sources) + end + end + + test 'graphqlv2 filter single source' do + VCR.use_cassette('graphql v2 filter single source') do + + # no filters to return all sources. used later to test filters return less than the total. + post '/graphql', params: { query: + '{ + search(searchterm: "data") { + hits + aggregations { + source { + key + docCount + } + } + } + }' + } + + json = JSON.parse(response.body) + initial_source_array = json['data']['search']['aggregations']['source'] + + # filtering to 1 sources returns 1 source + post '/graphql', params: { query: + '{ + search(searchterm: "data", sourceFacet: ["DSpace@MIT"]) { + hits + aggregations { + source { + key + docCount + } + } + } + }' + } + assert_equal(200, response.status) + + json = JSON.parse(response.body) + filtered_source_array = json['data']['search']['aggregations']['source'] + + assert(initial_source_array.count > filtered_source_array.count) + assert_equal(1, filtered_source_array.count) + + expected_sources = ['dspace@mit'] + actual_sources = filtered_source_array.map{|source| source["key"]} + assert_equal(expected_sources, actual_sources) + end + end end diff --git a/test/models/opensearch_test.rb b/test/models/opensearch_test.rb index 32d3cb7..55f5311 100644 --- a/test/models/opensearch_test.rb +++ b/test/models/opensearch_test.rb @@ -72,17 +72,32 @@ class OpensearchTest < ActiveSupport::TestCase VCR.use_cassette('opensearch single field nested') do params = { contributors: 'mcternan' } results = Opensearch.new.search(0, params, Timdex::OSClient) - assert_equal "A common table : 80 recipes and stories from my shared cultures /", + assert_equal 'A common table : 80 recipes and stories from my shared cultures /', results['hits']['hits'].first['_source']['title'] end end test 'searches multiple fields' do VCR.use_cassette('opensearch multiple fields') do - params = { q: 'chinese', title: 'common', contributors: 'mcternan'} + params = { q: 'chinese', title: 'common', contributors: 'mcternan' } results = Opensearch.new.search(0, params, Timdex::OSClient) - assert_equal "A common table : 80 recipes and stories from my shared cultures /", + assert_equal 'A common table : 80 recipes and stories from my shared cultures /', results['hits']['hits'].first['_source']['title'] end end + + test 'source_array creates correct query structure' do + sources = ['Zenodo', 'DSpace@MIT'] + expected = [{ term: { source: 'Zenodo' } }, { term: { source: 'DSpace@MIT' } }] + + assert_equal(expected, Opensearch.new.source_array(sources)) + end + + test 'filter_sources creates correct query structure' do + sources = ['Zenodo', 'DSpace@MIT'] + expected = { bool: { should: [{ term: { source: 'Zenodo' } }, + { term: { source: 'DSpace@MIT' } }] } } + + assert_equal(expected, Opensearch.new.filter_sources(sources)) + end end diff --git a/test/vcr_cassettes/graphql_v2_filter_multiple_sources.yml b/test/vcr_cassettes/graphql_v2_filter_multiple_sources.yml new file mode 100644 index 0000000..9a11daf --- /dev/null +++ b/test/vcr_cassettes/graphql_v2_filter_multiple_sources.yml @@ -0,0 +1,108 @@ +--- +http_interactions: +- request: + method: get + uri: http://localhost:9200/ + body: + encoding: US-ASCII + string: '' + headers: + User-Agent: + - 'opensearch-ruby/2.0.0 (RUBY_VERSION: 2.7.6; darwin x86_64; Faraday v1.10.0)' + Content-Type: + - application/json + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=UTF-8 + Content-Length: + - '350' + body: + encoding: ASCII-8BIT + string: | + { + "name" : "aa481ae9e939", + "cluster_name" : "docker-cluster", + "cluster_uuid" : "ktiriADZSI2Vohg8EZdVfA", + "version" : { + "distribution" : "opensearch", + "number" : "1.3.0", + "build_type" : "tar", + "build_hash" : "e45991597c86ba1bbcc36ee1dfdc165197a913af", + "build_date" : "2022-03-15T19:07:30.455415Z", + "build_snapshot" : false, + "lucene_version" : "8.10.1", + "minimum_wire_compatibility_version" : "6.8.0", + "minimum_index_compatibility_version" : "6.0.0-beta1" + }, + "tagline" : "The OpenSearch Project: https://opensearch.org/" + } + recorded_at: Wed, 06 Jul 2022 15:35:56 GMT +- request: + method: post + uri: http://localhost:9200/timdex-prod/_search + body: + encoding: UTF-8 + string: '{"from":"0","size":20,"query":{"bool":{"should":[{"prefix":{"title.exact_value":{"value":"data","boost":15.0}}},{"term":{"title":{"value":"data","boost":1.0}}},{"nested":{"path":"contributors","query":{"term":{"contributors.value":{"value":"data","boost":0.1}}}}}],"must":[{"multi_match":{"query":"data"}}],"filter":[]}},"highlight":{"pre_tags":["\u003cspan + class=\"highlight\"\u003e"],"post_tags":["\u003c/span\u003e"],"fields":{"*":{}}},"aggregations":{"collections":{"terms":{"field":"collections.keyword"}},"contributors":{"nested":{"path":"contributors"},"aggs":{"contributor_names":{"terms":{"field":"contributors.value.keyword"}}}},"content_type":{"terms":{"field":"content_type"}},"content_format":{"terms":{"field":"format"}},"languages":{"terms":{"field":"languages.keyword"}},"literary_form":{"terms":{"field":"literary_form"}},"source":{"terms":{"field":"source"}},"subjects":{"nested":{"path":"subjects"},"aggs":{"subject_names":{"terms":{"field":"subjects.value.keyword"}}}}}}' + headers: + User-Agent: + - 'opensearch-ruby/2.0.0 (RUBY_VERSION: 2.7.6; darwin x86_64; Faraday v1.10.0)' + Content-Type: + - application/json + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=UTF-8 + Content-Length: + - '17634' + body: + encoding: ASCII-8BIT + string: !binary |- + {"took":351,"timed_out":false,"_shards":{"total":4,"successful":4,"skipped":0,"failed":0},"hits":{"total":{"value":557,"relation":"eq"},"max_score":20.448364,"hits":[{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5728409","_score":20.448364,"_source":{"citation":"Stevens, Abigail (2021): Data for time series tutorial. Zenodo. Dataset. https://zenodo.org/record/5728409","content_type":["Dataset"],"contributors":[{"affiliation":["Michigan State Univ. and Univ. of Michigan"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-5041-3079"],"value":"Stevens, Abigail"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-11-25"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5728409"},{"kind":"url","value":"https://zenodo.org/record/5728409"}],"languages":["en"],"notes":[{"kind":"Other","value":["{\"references\": [\"Wilson-Hodge, C. et al. (2018). \\\"NICER and Fermi GBM Observations of the First Galactic Ultraluminous X-Ray Pulsar Swift J0243.6+6124,\\\" ApJ, 863, 9.\", \"Stevens, A.L. et al. (2018). \\\" A NICER Discovery of a Low-frequency Quasi-periodic Oscillation in the Soft-intermediate State of MAXI J1535-571,\\\" ApJ, 865, L15.\"]}"]}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5728408"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5728409","subjects":[{"kind":"Subject scheme not provided","value":["astronomy"]}],"summary":["\u003cp\u003eThese are sample data files to be used in the time series tutorial found here: \u003ca href=\"https://github.com/abigailStev/timeseries-tutorial\"\u003ehttps://github.com/abigailStev/timeseries-tutorial \u003c/a\u003e\u003c/p\u003e\n\n\u003cp\u003eThey are public datasets from the NICER X-ray Timing Instrument of a black hole, MAXI J1535-571, and a neutron star, Swift J0243.6+6124. There are also Good Time Intervals I created for each of the photon event lists.\u003c/p\u003e"],"timdex_record_id":"zenodo:5728409","title":"Data for time series tutorial"},"highlight":{"summary":["<p>These are sample <span class=\"highlight\">data</span> files to be used in the time series tutorial found here: <a href=\"https://github.com"],"citation":["Stevens, Abigail (2021): <span class=\"highlight\">Data</span> for time series tutorial. Zenodo."],"title.exact_value":["<span class=\"highlight\">Data for time series tutorial</span>"],"title":["<span class=\"highlight\">Data</span> for time series tutorial"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:3242151","_score":19.489151,"_source":{"citation":"Deacon, Niall R, Henning, Thomas, Kossakowski, Diana E. (2019): Data-driven stellar parameters for southern TESS FGK targets. Zenodo. JournalArticle. https://zenodo.org/record/3242151","content_type":["JournalArticle"],"contributors":[{"affiliation":["MPIA"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-2440-7350"],"value":"Deacon, Niall R"},{"affiliation":["MPIA"],"kind":"Creator","value":"Henning, Thomas"},{"affiliation":["MPIA"],"kind":"Creator","value":"Kossakowski, Diana E."}],"dates":[{"kind":"Publication date","value":"2019"},{"kind":"Issued","value":"2019-06-09"}],"edition":"1.0","format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.3242151"},{"kind":"url","value":"https://zenodo.org/record/3242151"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.3242150"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/3242151","subjects":[{"kind":"Subject scheme not provided","value":["astronomy, exoplanet, tess, stellar parameters"]}],"summary":["\u003cp\u003ePresented here are the extended tables for Deacon et al. (2019)\u003c/p\u003e\n\n\u003cp\u003eTable3: This table presents stellar parameters for southern FGK stars that are likely high priority targets for the TESS mission. The parameters are presented in the same way as in the tables in the paper with the exception of several additional flags.\u003cbr\u003e\n\u003cbr\u003e\nfeh_flag - set if an object has an estimated Fe/H value of \u0026gt;0.55. This normally indicates the code is hitting the edge of the metallicity grid and likely means the object cannot be well described by our model rather than it being extremely high metallicity\u003cbr\u003e\n\u003cbr\u003e\nTable A1: A compilation of Gaia astrometry for TESS targets is presented as described in the paper\u003cbr\u003e\n\u003cbr\u003e\nfeh_not_measured_flag - set when we do not have Skymapper u or v data and thus cannot reliably estimate an objects metallicity. In these cases Fe/H is set to -1, the typical value in the solar neighbourhood\u003cbr\u003e\n\u003cbr\u003e\nav_lim_flag - set if we do not find a statistically significant constrain on the star\u0026#39;s extinction. In this case we quote an upper limit based on other studies (this is detailed further in the paper)\u003cbr\u003e\n\u003cbr\u003e\nteff_flag - indicates that the best-fitting effective temperature value fell outside our grid. Thus we quote either the lower limit (7000K) or the upper limit (4600K for dwarfs, 4000K for giants). For such objects all other parameters are set to null values (-99.9 for all parameters except extinction which is set to 99.9)\u003cbr\u003e\n\u003cbr\u003e\nteff_lower_lim_flag - set if the lower limit of our T_eff confidence bound falls outside the range of our training sample.\u003cbr\u003e\n\u003cbr\u003e\nteff_upper_lim_flag - set if the upper limit of our T_eff confidence bound falls outside the range of our training sample.\u003cbr\u003e\n\u003cbr\u003e\n\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:3242151","title":"Data-driven stellar parameters for southern TESS FGK targets"},"highlight":{"summary":["as described in the paper<br>\n<br>\nfeh_not_measured_flag - set when we do not have Skymapper u or v <span class=\"highlight\">data</span>"],"citation":["Deacon, Niall R, Henning, Thomas, Kossakowski, Diana E. (2019): <span class=\"highlight\">Data</span>-driven stellar parameters for southern"],"title.exact_value":["<span class=\"highlight\">Data-driven stellar parameters for southern TESS FGK targets</span>"],"title":["<span class=\"highlight\">Data</span>-driven stellar parameters for southern TESS FGK targets"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5727583","_score":19.343845,"_source":{"citation":"Taubenberger Stefan (2021): Data for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae\". Zenodo. Dataset. https://zenodo.org/record/5727583","content_type":["Dataset"],"contributors":[{"affiliation":["Max-Planck-Institut für Astrophysik"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-4265-1958"],"value":"Taubenberger Stefan"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-11-25"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5727583"},{"kind":"url","value":"https://zenodo.org/record/5727583"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsSupplementTo","uri":"https://doi.org/10.1007/978-3-319-21846-5_37"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5727582"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5727583","subjects":[{"kind":"Subject scheme not provided","value":["supernovae"]},{"kind":"Subject scheme not provided","value":["thermonuclear"]}],"summary":["\u003cp\u003eData needed to recreate Figure 1 of Taubenberger\u0026nbsp; S., \u003ca href=\"https://ui.adsabs.harvard.edu/abs/2017hsn..book..317T/abstract\"\u003e\u0026quot;The Extremes of Thermonuclear Supernovae\u0026quot;\u003c/a\u003e, in\u0026nbsp;A. W. Alsabti, P. Murdin, eds., \u0026ldquo;Handbook of Supernovae\u0026rdquo;, Springer, ISBN: 978-3-319-20794-0 (2017). A detailed README is included.\u003c/p\u003e"],"timdex_record_id":"zenodo:5727583","title":"Data for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae\""},"highlight":{"summary":["<p><span class=\"highlight\">Data</span> needed to recreate Figure 1 of Taubenberger&nbsp; S., <a href=\"https://ui.adsabs.harvard.edu/"],"citation":["Taubenberger Stefan (2021): <span class=\"highlight\">Data</span> for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae"],"title.exact_value":["<span class=\"highlight\">Data for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae\"</span>"],"title":["<span class=\"highlight\">Data</span> for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:3820679","_score":19.08733,"_source":{"citation":"Martínez-Palomera, Jorge, Bloom, Joshua S., Abrahams, Ellianna S. (2020): Data from: \"Deep Generative Modeling of Periodic Variable Stars Using Physical Parameters\". Zenodo. Dataset. https://zenodo.org/record/3820679","content_type":["Dataset"],"contributors":[{"affiliation":["University of California Berkeley"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-7395-4935"],"value":"Martínez-Palomera, Jorge"},{"affiliation":["University of California Berkeley"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-7777-216X"],"value":"Bloom, Joshua S."},{"affiliation":["University of California Berkeley"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-9879-1183"],"value":"Abrahams, Ellianna S."}],"dates":[{"kind":"Publication date","value":"2020"},{"kind":"Issued","value":"2020-05-20"}],"edition":"0.1","format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.3820679"},{"kind":"url","value":"https://zenodo.org/record/3820679"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsSupplementTo","uri":"arXiv:2005.07773"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.3820678"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/3820679","subjects":[{"kind":"Subject scheme not provided","value":["periodic variables"]},{"kind":"Subject scheme not provided","value":["light curves"]},{"kind":"Subject scheme not provided","value":["cross-matching validation"]},{"kind":"Subject scheme not provided","value":["ogle3"]},{"kind":"Subject scheme not provided","value":["gaia-dr2"]},{"kind":"Subject scheme not provided","value":["variational autoencoder"]},{"kind":"Subject scheme not provided","value":["generative models"]}],"summary":["\u003cp\u003eThis dataset was used for the training of a conditioned Variational Autoencoder that generates physically informed light curves of periodic variable stars. The light curves correspond to data obtained from The Optical Gravitational Lensing Experiment (\u003ca href=\"https://ui.adsabs.harvard.edu/abs/1992AcA....42..253U/abstract\"\u003eOGLE\u003c/a\u003e), while ancillary information was obtained from the Gaia Data Release 2 (\u003ca href=\"https://ui.adsabs.harvard.edu/link_gateway/2016A\u0026amp;A...595A...1G/doi:10.1051/0004-6361/201629272\"\u003eGAIA DR2\u003c/a\u003e). This repository contains the preprocessed OGLE light curves and the GAIA measurements corresponding to each cross-matched source. We also provided a subsample of cross-matched sources that were carefully validated following several steps described in the companion article (paper reference).\u003c/p\u003e\n\n\u003cp\u003eThis dataset is realized in tandem with the corresponding\u0026nbsp;\u003ca href=\"https://github.com/jorgemarpa/PELS-VAE\"\u003eGitHub\u003c/a\u003e\u0026nbsp;and\u0026nbsp;\u003ca href=\"https://arxiv.org/abs/2005.07773\"\u003earticle\u003c/a\u003e.\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:3820679","title":"Data from: \"Deep Generative Modeling of Periodic Variable Stars Using Physical Parameters\""},"highlight":{"summary":["The light curves correspond to <span class=\"highlight\">data</span> obtained from The Optical Gravitational Lensing Experiment (<a href","abs/1992AcA....42..253U/abstract\">OGLE</a>), while ancillary information was obtained from the Gaia <span class=\"highlight\">Data</span>"],"citation":["., Abrahams, Ellianna S. (2020): <span class=\"highlight\">Data</span> from: \"Deep Generative Modeling of Periodic Variable Stars Using"],"title.exact_value":["<span class=\"highlight\">Data from: \"Deep Generative Modeling of Periodic Variable Stars Using Physical Parameters\"</span>"],"title":["<span class=\"highlight\">Data</span> from: \"Deep Generative Modeling of Periodic Variable Stars Using Physical Parameters\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:3628656","_score":19.01915,"_source":{"citation":"Huang, Jane (2020): Data from  \"A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk\". Zenodo. Dataset. https://zenodo.org/record/3628656","content_type":["Dataset"],"contributors":[{"affiliation":["Center for Astrophysics | Harvard \u0026 Smithsonian"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-6947-6072"],"value":"Huang, Jane"}],"dates":[{"kind":"Publication date","value":"2020"},{"kind":"Issued","value":"2020-01-29"}],"edition":"1","format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.3628656"},{"kind":"url","value":"https://zenodo.org/record/3628656"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.3628655"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/3628656","subjects":[{"kind":"Subject scheme not provided","value":["GM Aur"]},{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["Protoplanetary disks"]}],"summary":["\u003cp\u003eImage cubes, self-calibrated visibilities, and self-calibration and imaging scripts for data associated with Huang et al., 2020, \u0026quot;A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk,\u0026quot; The Astrophysical Journal, 891, 48,\u0026nbsp;arXiv:2001.11040\u003c/p\u003e\n\n\u003cp\u003eThe raw data are available on the ALMA archive under program IDs\u0026nbsp;2017.1.01151.S and\u0026nbsp;2018.1.01230.S (PI: Jane Huang).\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eScripts:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003ereduction_utils.py: Set of helper functions for self-calibration scripts\u003c/p\u003e\n\n\u003cp\u003eB4continuumreduction.py: Self-calibration and imaging script for Band 4\u0026nbsp;(2.1 mm) continuum (GMAurB4continuumfinal.image.fits) from GMAurB4continuum.final.ms.tgz\u003c/p\u003e\n\n\u003cp\u003eB6continuumreduction.py: Self-calibration and imaging script for Band 6 (1.1 mm) continuum (GMAurB6continuumfinal.image.fits) from GMAurB6continuum.final.ms.tgz\u003c/p\u003e\n\n\u003cp\u003eHCOp_imaging.py: Script producing GMAur_HCOp_continuumsubtracted.image.fits and GMAur_HCOp_withcontinuum.image.fits from GMAurB6_HCOp.ms.contsub.cvel and GMAurB6_HCOp.ms.cvel, respectively\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eMeasurement sets:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eGMAurB4continuumfinal.ms.tgz: Self-calibrated 2.1 mm continuum visibilities for GM Aur\u003c/p\u003e\n\n\u003cp\u003eGMAurB6continuumfinal.ms.tgz: Self-calibrated 1.1 mm continuum visibilities for GM Aur\u003c/p\u003e\n\n\u003cp\u003eGMAurB6_HCOp.ms.cvel.tgz: Self-calibrated HCO\u003csup\u003e+\u0026nbsp;\u003c/sup\u003e3-2 visibilities\u0026nbsp;without continuum subtraction\u003c/p\u003e\n\n\u003cp\u003eGMAurB6_HCOp.ms.contsub.cvel.tgz: Self-calibrated HCO\u003csup\u003e+\u0026nbsp;\u003c/sup\u003e3-2 visibilities\u0026nbsp;with\u0026nbsp;continuum subtraction\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eImages:\u0026nbsp;\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eGMAurB6continuumfinal.image.fits: 1.1 mm continuum image of GM Aur\u003c/p\u003e\n\n\u003cp\u003eGMAurB4continuumfinal.image.fits: 2.1 mm continuum image of GM Aur\u003c/p\u003e\n\n\u003cp\u003eGMAur_HCOp_withcontinuum.image.fits: HCO\u003csup\u003e+\u0026nbsp;\u003c/sup\u003e3-2 image cube toward GM Aur without continuum subtraction\u003c/p\u003e\n\n\u003cp\u003eGMAur_HCOp_continuumsubtracted.image.fits:\u0026nbsp;HCO\u003csup\u003e+\u0026nbsp;\u003c/sup\u003e3-2 image cube toward GM Aur with\u0026nbsp;continuum subtraction\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:3628656","title":"Data from  \"A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk\""},"highlight":{"summary":["<p>Image cubes, self-calibrated visibilities, and self-calibration and imaging scripts for <span class=\"highlight\">data</span> associated","protoplanetary disk,&quot; The Astrophysical Journal, 891, 48,&nbsp;arXiv:2001.11040</p>\n\n<p>The raw <span class=\"highlight\">data</span>"],"citation":["Huang, Jane (2020): <span class=\"highlight\">Data</span> from  \"A multi-frequency ALMA characterization of substructures in the GM Aur"],"title.exact_value":["<span class=\"highlight\">Data from  \"A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk</span>"],"title":["<span class=\"highlight\">Data</span> from  \"A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:4454165","_score":18.887436,"_source":{"citation":"Law, Charles John (2021): Data from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6-0.4\". Zenodo. Dataset. https://zenodo.org/record/4454165","content_type":["Dataset"],"contributors":[{"affiliation":["Center for Astrophysics | Harvard \u0026 Smithsonian"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-1413-1776"],"value":"Law, Charles John"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-01-21"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.4454165"},{"kind":"url","value":"https://zenodo.org/record/4454165"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.4454164"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/aas"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/4454165","subjects":[{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["Complex organic molecules"]},{"kind":"Subject scheme not provided","value":["Massive star formation"]}],"summary":["\u003cp\u003eNon-continuum-subtracted\u0026nbsp;spectral line image cubes associated with Law et al., 2021, \u0026quot;Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6-0.4,\u0026quot;\u0026nbsp;The Astrophysical Journal [arXiv:2101.07801].\u003c/p\u003e\n\n\u003cp\u003eThe raw data are available on the ALMA archive under program ID\u0026nbsp;2015.1.00106.S (PI: Qizhou\u0026nbsp;Zhang).\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eDatasets:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eG10_6_spw25.fits: Image cube from ~233-235 GHz\u003c/p\u003e\n\n\u003cp\u003eG10_6_spw27.fits: Image cube from ~231-233\u0026nbsp;GHz\u003c/p\u003e\n\n\u003cp\u003eG10_6_spw29.fits: Image cube from ~219-221\u0026nbsp;GHz\u003c/p\u003e\n\n\u003cp\u003eG10_6_spw31.fits: Image cube from ~217-219\u0026nbsp;GHz\u003c/p\u003e"],"timdex_record_id":"zenodo:4454165","title":"Data from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6-0.4\""},"highlight":{"summary":["</p>\n\n<p>The raw <span class=\"highlight\">data</span> are available on the ALMA archive under program ID&nbsp;2015.1.00106.S (PI: Qizhou"],"citation":["Law, Charles John (2021): <span class=\"highlight\">Data</span> from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive"],"title.exact_value":["<span class=\"highlight\">Data from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6</span>"],"title":["<span class=\"highlight\">Data</span> from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:6542596","_score":18.850346,"_source":{"citation":"Heimersheim, Stefan, Sartorio, Nina S., Fialkov, Anastasia, Lorimer, Duncan R. (2022): Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\". Zenodo. Software. https://zenodo.org/record/6542596","content_type":["Software"],"contributors":[{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-9631-4212"],"value":"Heimersheim, Stefan"},{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-2138-5192"],"value":"Sartorio, Nina S."},{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK; Kavli Institute for Cosmology, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-1369-633X"],"value":"Fialkov, Anastasia"},{"affiliation":["West Virginia University, Department of Physics and Astronomy, P. O. Box 6315, Morgantown, WV, USA; Center for Gravitational Waves and Cosmology, West Virginia University, Chestnut Ridge Research Building, Morgantown, WV, USA"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-1301-966X"],"value":"Lorimer, Duncan R."}],"dates":[{"kind":"Publication date","value":"2022"},{"kind":"Issued","value":"2022-05-14"}],"format":"electronic resource","funding_information":[{"award_number":"1430284","award_uri":"info:eu-repo/grantAgreement/NSF/Directorate+for+Mathematical+%26+Physical+Sciences/1430284/","funder_identifier":"10.13039/100000001","funder_identifier_type":"Crossref Funder ID","funder_name":"National Science Foundation"},{"award_number":"1458952","award_uri":"info:eu-repo/grantAgreement/NSF//1458952/","funder_identifier":"10.13039/100000001","funder_identifier_type":"Crossref Funder ID","funder_name":"National Science Foundation"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.6542596"},{"kind":"url","value":"https://zenodo.org/record/6542596"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsSupplementTo","uri":"https://arxiv.org/abs/2107.14242"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5504050"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/6542596","summary":["\u003cp\u003eThis upload contains the data and code used for our Fast Radio Burst forecast, constraining reionization and cosmological parameters (\u003ca href=\"https://arxiv.org/abs/2107.14242\"\u003earXiv:2107.14242\u003c/a\u003e). The data includes both, the generated synthetic observations, as well as the Nested Sampling chains used to produce the results and figures.\u003c/p\u003e\n\n\u003cp\u003eThe minimal set to run the analysis (FlexKnotFRB-small) takes up 6.5 GB (uncompressed) of disk space and can be used to reproduce everything except the high-resolution version of Figure 3. (That version can also be reproduce but would take ~24h.) The full set (FlexKnotFRB-full) takes 31 GB and contains pre-computed cache files allowing to regenerate all paper plots quickly (\u0026lt;\u0026lt;1h). Finally the extra chains which contain additional runs with different seeds and a run with different priors take 68 GB of disk space uncompressed.\u003c/p\u003e\n\n\u003cp\u003eThe most recent code (but not the Nested Sampling chains) is also available on \u003ca href=\"https://github.com/Stefan-Heimersheim/FlexKnotFRB\"\u003eGitHub\u003c/a\u003e.\u003c/p\u003e"],"timdex_record_id":"zenodo:6542596","title":"Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\""},"highlight":{"summary":["<p>This upload contains the <span class=\"highlight\">data</span> and code used for our Fast Radio Burst forecast, constraining reionization","The <span class=\"highlight\">data</span> includes both, the generated synthetic observations, as well as the Nested Sampling chains used"],"citation":["., Fialkov, Anastasia, Lorimer, Duncan R. (2022): <span class=\"highlight\">Data</span> and Code for \"What it Takes to Measure Reionization"],"title.exact_value":["<span class=\"highlight\">Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\"</span>"],"title":["<span class=\"highlight\">Data</span> and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5504051","_score":18.850346,"_source":{"citation":"Heimersheim, Stefan, Sartorio, Nina S., Fialkov, Anastasia, Lorimer, Duncan R. (2021): Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\". Zenodo. Software. https://zenodo.org/record/5504051","content_type":["Software"],"contributors":[{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-9631-4212"],"value":"Heimersheim, Stefan"},{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-2138-5192"],"value":"Sartorio, Nina S."},{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK; Kavli Institute for Cosmology, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-1369-633X"],"value":"Fialkov, Anastasia"},{"affiliation":["West Virginia University, Department of Physics and Astronomy, P. O. Box 6315, Morgantown, WV, USA; Center for Gravitational Waves and Cosmology, West Virginia University, Chestnut Ridge Research Building, Morgantown, WV, USA"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-1301-966X"],"value":"Lorimer, Duncan R."}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-09-14"}],"format":"electronic resource","funding_information":[{"award_number":"1430284","award_uri":"info:eu-repo/grantAgreement/NSF/Directorate+for+Mathematical+%26+Physical+Sciences/1430284/","funder_identifier":"10.13039/100000001","funder_identifier_type":"Crossref Funder ID","funder_name":"National Science Foundation"},{"award_number":"1458952","award_uri":"info:eu-repo/grantAgreement/NSF//1458952/","funder_identifier":"10.13039/100000001","funder_identifier_type":"Crossref Funder ID","funder_name":"National Science Foundation"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5504051"},{"kind":"url","value":"https://zenodo.org/record/5504051"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsSupplementTo","uri":"https://arxiv.org/abs/2107.14242"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5504050"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5504051","summary":["\u003cp\u003eThis upload contains the data and code used for our Fast Radio Burst forecast, constraining reionization and cosmological parameters (\u003ca href=\"https://arxiv.org/abs/2107.14242\"\u003earxiv/2107.14242\u003c/a\u003e). The data includes both, the generated synthetic observations, as well as the Nested Sampling chains used to produce the results and figures.\u003cbr\u003e\nThe most recent code (though not the Nested Sampling chains) is also available on \u003ca href=\"https://github.com/Stefan-Heimersheim/FlexKnotFRB\"\u003eGitHub\u003c/a\u003e.\u003c/p\u003e"],"timdex_record_id":"zenodo:5504051","title":"Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\""},"highlight":{"summary":["<p>This upload contains the <span class=\"highlight\">data</span> and code used for our Fast Radio Burst forecast, constraining reionization","The <span class=\"highlight\">data</span> includes both, the generated synthetic observations, as well as the Nested Sampling chains used"],"citation":["., Fialkov, Anastasia, Lorimer, Duncan R. (2021): <span class=\"highlight\">Data</span> and Code for \"What it Takes to Measure Reionization"],"title.exact_value":["<span class=\"highlight\">Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\"</span>"],"title":["<span class=\"highlight\">Data</span> and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:3928862","_score":18.831516,"_source":{"citation":"Jane Huang (2020): Data from \"Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup\". Zenodo. Dataset. https://zenodo.org/record/3928862","content_type":["Dataset"],"contributors":[{"affiliation":["Center for Astrophysics | Harvard \u0026 Smithsonian"],"kind":"Creator","value":"Jane Huang"}],"dates":[{"kind":"Publication date","value":"2020"},{"kind":"Issued","value":"2020-07-07"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.3928862"},{"kind":"url","value":"https://zenodo.org/record/3928862"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.3928861"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/3928862","subjects":[{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["protoplanetary disks"]},{"kind":"Subject scheme not provided","value":["RU Lup"]}],"summary":["\u003cp\u003eImage cubes, self-calibrated visibilities, and self-calibration and imaging scripts for data from Huang et al., 2020, \u0026quot;Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup,\u0026quot; accepted for publication by The Astrophysical Journal, arXiv:2007.02974\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003eThe raw ALMA data can be found at the ALMA archive under program ID 2018.1.01201.S (PI: Jane Huang).\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eScripts:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eselfcal_C43-5.py, selfcal_C43-2.py, selfcal_ACA.py: self-calibration scripts for observation of RU Lup in various ALMA configurations\u003c/p\u003e\n\n\u003cp\u003eimaging.py: imaging script used for all lines\u003c/p\u003e\n\n\u003cp\u003ereductionutils.py can be downloaded from\u0026nbsp;\u003ca href=\"https://zenodo.org/record/3628656\"\u003ehttps://zenodo.org/record/3628656\u003c/a\u003e\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eMeasurement sets:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eRULupcontinuum.ms.tgz: Continuum visibilities for \u0026quot;RULupallcontinuum.image.pbcor.fits\u0026quot; (the high-resolution ALMA continuum data can be found on the \u003ca href=\"https://bulk.cv.nrao.edu/almadata/lp/DSHARP/\"\u003eDSHARP\u003c/a\u003e page)\u003c/p\u003e\n\n\u003cp\u003eRULup_12CO.ms.contsub.tgz: Continuum-subtracted visibilities for the \u003csup\u003e12\u003c/sup\u003eCO J=2-1 line toward RU Lup\u003c/p\u003e\n\n\u003cp\u003eRULup_12CO_nocontsub.ms.tgz: Visibilities for the \u003csup\u003e12\u003c/sup\u003eCO J=2-1 line (no continuum subtraction) toward RU Lup, used to make the \u0026#39;RULup_12COpeakintensity.fits\u0026#39; file.\u003c/p\u003e\n\n\u003cp\u003eRULup_13CO.ms.contsub.tgz: Continuum-subtracted visibilities for the \u003csup\u003e13\u003c/sup\u003eCO J=2-1 line toward RU Lup\u003c/p\u003e\n\n\u003cp\u003eRULup_C18O.ms.contsub.tgz: Continuum-subtracted visibilities for the C\u003csup\u003e18\u003c/sup\u003eO J=2-1 line toward RU Lup\u003c/p\u003e\n\n\u003cp\u003eRULup_DCOp.ms.contsub.tgz: Continuum-subtracted visibilities for the\u0026nbsp; DCO\u003csup\u003e+\u003c/sup\u003e J=3-2 line toward RU Lup\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eImages: \u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eRULup12CO.1sigcut.pbcor.mom0.fits: Integrated intensity map of \u003csup\u003e12\u003c/sup\u003eCO J=2-1 appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULup12CO.pbcor.mom1.fits: \u003csup\u003e12\u003c/sup\u003eCO J=2-1 intensity-weighted velocity map appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULup13CO.pbcor.mom0.fits: Integrated intensity map of \u003csup\u003e13\u003c/sup\u003eCO J=2-1 appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULup13CO.pbcor.mom1.fits: \u003csup\u003e13\u003c/sup\u003eCO J=2-1 intensity-weighted velocity map appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULupC18O.pbcor.mom0.fits: Integrated intensity map of C\u003csup\u003e18\u003c/sup\u003eO J=2-1 appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULupC18O.pbcor.mom1.fits: C\u003csup\u003e18\u003c/sup\u003eO J=2-1 intensity-weighted velocity map appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULup12CO.image.pbcor.fits: \u003csup\u003e12\u003c/sup\u003eCO J=2-1 image cube appearing in Fig. 2\u003c/p\u003e\n\n\u003cp\u003eRULupC18O.image.pbcor.fits: C\u003csup\u003e18\u003c/sup\u003eO J=2-1 image cube appearing in Fig. 2\u003c/p\u003e\n\n\u003cp\u003eRULup13CO.image.pbcor.fits: \u003csup\u003e12\u003c/sup\u003eCO J=2-1 image cube appearing in Fig. 3\u003c/p\u003e\n\n\u003cp\u003eRULup_12COpeakintensity.fits: Peak intensity image of \u003csup\u003e12\u003c/sup\u003eCO used to make Figure 4\u003c/p\u003e\n\n\u003cp\u003eRULupDCOp.pbcor.mom0.fits: Integrated intensity map of DCO\u003csup\u003e+\u003c/sup\u003e J=3-2 appearing in Fig. 10\u003c/p\u003e\n\n\u003cp\u003eRULupDCOp.image.pbcor.fits: DCO\u003csup\u003e+\u003c/sup\u003e J=3-2 image cube appearing in Fig. 11\u003c/p\u003e\n\n\u003cp\u003eRULupallcontinuum.image.pbcor.fits: Continuum image appearing in Fig. 12\u003c/p\u003e\n\n\u003cp\u003eRULup12COinitial.mask.image.fits: \u003csup\u003e12\u003c/sup\u003eCO CLEAN mask shown in Fig. 13\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:3928862","title":"Data from \"Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup\""},"highlight":{"summary":["<p>Image cubes, self-calibrated visibilities, and self-calibration and imaging scripts for <span class=\"highlight\">data</span> from","accepted for publication by The Astrophysical Journal, arXiv:2007.02974&nbsp;</p>\n\n<p>The raw ALMA <span class=\"highlight\">data</span>","visibilities for &quot;RULupallcontinuum.image.pbcor.fits&quot; (the high-resolution ALMA continuum <span class=\"highlight\">data</span>"],"citation":["Jane Huang (2020): <span class=\"highlight\">Data</span> from \"Large-scale CO spirals and complex kinematics associated with the T Tauri"],"title.exact_value":["<span class=\"highlight\">Data from \"Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup\"</span>"],"title":["<span class=\"highlight\">Data</span> from \"Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:2556767","_score":18.76409,"_source":{"citation":"Moldon, Javier, Ghirlanda, Giancarlo (2019): Data processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science. Zenodo. Dataset. https://zenodo.org/record/2556767","content_type":["Dataset"],"contributors":[{"affiliation":["The University of Manchester"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-8079-7608"],"value":"Moldon, Javier"},{"affiliation":["Instituto Nazionale di Astrofisica"],"kind":"Creator","value":"Ghirlanda, Giancarlo"},{"affiliation":["The University of Manchester"],"kind":"ContactPerson","identifier":["https://orcid.org/0000-0002-8079-7608"],"value":"Moldon, Javier"},{"affiliation":["Instituto Nazionale di Astrofisica"],"kind":"Researcher","value":"Ghirlanda, Giancarlo"}],"dates":[{"kind":"Publication date","value":"2019"},{"kind":"Issued","value":"2019-02-04"}],"edition":"1","format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.2556767"},{"kind":"url","value":"https://zenodo.org/record/2556767"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.2556766"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/2556767","subjects":[{"kind":"Subject scheme not provided","value":["interferometry"]},{"kind":"Subject scheme not provided","value":["radio"]},{"kind":"Subject scheme not provided","value":["e-MERLIN"]},{"kind":"Subject scheme not provided","value":["astronomy"]},{"kind":"Subject scheme not provided","value":["gravitational wave"]}],"summary":["\u003cp\u003eData processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e\n\n\u003cul\u003e\n\t\u003cli\u003einfo.txt contains a general description of how the data was processed and the main results.\u003c/li\u003e\n\t\u003cli\u003epipeline.tar contains the data pipeline used to process the e-MERLIN observations\u003c/li\u003e\n\t\u003cli\u003eimaging.py is the script used to produce the final images\u003c/li\u003e\n\t\u003cli\u003eCY6213_images.tar contain the final images of the target source (not corrected by calibration factor, described in the imaging script).\u003c/li\u003e\n\u003c/ul\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:2556767","title":"Data processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science"},"highlight":{"summary":["<p><span class=\"highlight\">Data</span> processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science","</p>\n\n<p>&nbsp;</p>\n\n<ul>\n\t<li>info.txt contains a general description of how the <span class=\"highlight\">data</span> was processed","</li>\n\t<li>pipeline.tar contains the <span class=\"highlight\">data</span> pipeline used to process the e-MERLIN observations</li>\n\t<li"],"citation":["Moldon, Javier, Ghirlanda, Giancarlo (2019): <span class=\"highlight\">Data</span> processing scripts and images from e-MERLIN project"],"title.exact_value":["<span class=\"highlight\">Data processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science</span>"],"title":["<span class=\"highlight\">Data</span> processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:6410045","_score":18.673622,"_source":{"citation":"Law, Charles John, Crystian, Sage, Teague, Richard, Öberg, Karin I., Rich, Evan A., Andrews, Sean M., Bae, Jaehan, Flaherty, Kevin, Guzmán, Viviana V., Huang, Jane, Ilee, John D., Kastner, Joel H., Loomis, Ryan A., Long, Feng, Pérez, Laura M., Pérez, Sebastián, Qi, Chunhua, Rosotti, Giovanni P., Ruíz-Rodríguez, Dary, Tsukagoshi, Takashi, Wilner, David J. (2022): Data from \"CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks\". Zenodo. Dataset. https://zenodo.org/record/6410045","content_type":["Dataset"],"contributors":[{"kind":"Creator","identifier":["https://orcid.org/0000-0003-1413-1776"],"value":"Law, Charles John"},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-1050-278X"],"value":"Crystian, Sage"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-1534-5186"],"value":"Teague, Richard"},{"kind":"Creator","identifier":["https://orcid.org/0000-0001-8798-1347"],"value":"Öberg, Karin I."},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-1779-8181"],"value":"Rich, Evan A."},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-2253-2270"],"value":"Andrews, Sean M."},{"kind":"Creator","identifier":["https://orcid.org/0000-0001-7258-770X"],"value":"Bae, Jaehan"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-2657-1314"],"value":"Flaherty, Kevin"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-4784-3040"],"value":"Guzmán, Viviana V."},{"kind":"Creator","identifier":["https://orcid.org/0000-0001-6947-6072"],"value":"Huang, Jane"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-1008-1142"],"value":"Ilee, John D."},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-3138-8250"],"value":"Kastner, Joel H."},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-8932-1219"],"value":"Loomis, Ryan A."},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-7607-719X"],"value":"Long, Feng"},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-1199-9564"],"value":"Pérez, Laura M."},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-2953-755X"],"value":"Pérez, Sebastián"},{"kind":"Creator","identifier":["https://orcid.org/0000-0001-8642-1786"],"value":"Qi, Chunhua"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-4853-5736"],"value":"Rosotti, Giovanni P."},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-3573-8163"],"value":"Ruíz-Rodríguez, Dary"},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-6034-2892"],"value":"Tsukagoshi, Takashi"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-1526-7587"],"value":"Wilner, David J."}],"dates":[{"kind":"Publication date","value":"2022"},{"kind":"Issued","value":"2022-04-03"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.6410045"},{"kind":"url","value":"https://zenodo.org/record/6410045"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.6410044"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/aas"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/6410045","subjects":[{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["Protoplanetary Disks"]},{"kind":"Subject scheme not provided","value":["CO Line Emission"]}],"summary":["\u003cp\u003eCO line emission image cubes (\u0026quot;[DISK]_CO_cube.fits\u0026quot;), line+continuum\u0026nbsp;image cubes (\u0026quot;[DISK]_CO_cube_wcont.fits\u0026quot;), and zeroth moment maps (\u0026quot;[DISK]_CO_M0.fits\u0026quot;) associated with Law et al., 2022, \u0026quot;CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks,\u0026quot;\u0026nbsp;The Astrophysical Journal\u003c/p\u003e\n\n\u003cp\u003eCO line emission image cubes from the DSHARP ALMA Large Program (for HD 142666, MY Lup, GW Lup, WaOph 6, DoAr 25) can be found at:\u0026nbsp;https://bulk.cv.nrao.edu/almadata/lp/DSHARP/ and are not included here.\u003c/p\u003e\n\n\u003cp\u003eThe raw data are available on the ALMA archive (see Table 1 in the paper for a\u0026nbsp;listing of the relevant\u0026nbsp;ALMA project codes).\u003c/p\u003e"],"timdex_record_id":"zenodo:6410045","title":"Data from \"CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks\""},"highlight":{"summary":["</p>\n\n<p>The raw <span class=\"highlight\">data</span> are available on the ALMA archive (see Table 1 in the paper for a&nbsp;listing"],"citation":["., Ruíz-Rodríguez, Dary, Tsukagoshi, Takashi, Wilner, David J. (2022): <span class=\"highlight\">Data</span> from \"CO Line Emission Surfaces"],"title.exact_value":["<span class=\"highlight\">Data from \"CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks\"</span>"],"title":["<span class=\"highlight\">Data</span> from \"CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:4756381","_score":18.66253,"_source":{"citation":"Tazzari, Marco (2021): Data from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications for grain growth and radial drift\". Zenodo. Dataset. https://zenodo.org/record/4756381","content_type":["Dataset"],"contributors":[{"affiliation":["University of Cambridge"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-3590-5814"],"value":"Tazzari, Marco"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-06-21"}],"format":"electronic resource","funding_information":[{"award_number":"291227","award_uri":"info:eu-repo/grantAgreement/EC/FP7/291227/","funder_identifier":"10.13039/100011102","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"},{"award_number":"823823","award_uri":"info:eu-repo/grantAgreement/EC/H2020/823823/","funder_identifier":"10.13039/100010661","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"},{"award_number":"ST/S000623/1","award_uri":"info:eu-repo/grantAgreement/RCUK/STFC/ST%2FS000623%2F1/","funder_identifier":"10.13039/501100000690","funder_identifier_type":"Crossref Funder ID","funder_name":"Research Councils UK"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.4756381"},{"kind":"url","value":"https://zenodo.org/record/4756381"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsCompiledBy","uri":"arXiv:2010.02249"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.4756380"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/4756381","summary":["\u003cp\u003eTable 1, Table 2, and Table 3 from Tazzari et al., 2021,\u0026nbsp;\u0026quot;Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications for grain growth and radial drift\u0026quot;, Monthly Notices of the Royal Astronomical Society, arXiv:2010.02249\u003c/p\u003e\n\n\u003cp\u003eBoth tables are available in IPAC format, which is in human- and machine-readable:\u003c/p\u003e\n\n\u003cpre\u003e\u003ccode class=\"language-python\"\u003efrom astropy.io import ascii\ntb = ascii.read('Table1.txt', format='ipac')\u003c/code\u003e\u003c/pre\u003e\n\n\u003cp\u003eTable comments (stored at the beginning of the ASCII file as lines starting with \u0026quot;/\u0026quot;) can be read as:\u003c/p\u003e\n\n\u003cpre\u003e\u003ccode class=\"language-python\"\u003etb.meta['comments']\n\u003c/code\u003e\u003c/pre\u003e"],"timdex_record_id":"zenodo:4756381","title":"Data from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications for grain growth and radial drift\""},"highlight":{"citation":["Tazzari, Marco (2021): <span class=\"highlight\">Data</span> from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations"],"title.exact_value":["<span class=\"highlight\">Data from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications</span>"],"title":["<span class=\"highlight\">Data</span> from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:4756282","_score":18.584112,"_source":{"citation":"Marco Tazzari (2021): Data from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the Lupus region\". Zenodo. Dataset. https://zenodo.org/record/4756282","content_type":["Dataset"],"contributors":[{"affiliation":["University of Cambridge"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-3590-5814"],"value":"Marco Tazzari"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-05-13"}],"format":"electronic resource","funding_information":[{"award_number":"855130","award_uri":"info:eu-repo/grantAgreement/EC/Horizon 2020 Framework Programme - European Research Council - Synergy grant/855130/","funder_identifier":"10.13039/100010661","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"},{"award_number":"823823","award_uri":"info:eu-repo/grantAgreement/EC/H2020/823823/","funder_identifier":"10.13039/100010661","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"},{"award_number":"ST/S000623/1","award_uri":"info:eu-repo/grantAgreement/RCUK/STFC/ST%2FS000623%2F1/","funder_identifier":"10.13039/501100000690","funder_identifier_type":"Crossref Funder ID","funder_name":"Research Councils UK"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.4756282"},{"kind":"url","value":"https://zenodo.org/record/4756282"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsCompiledBy","uri":"arXiv:2010.02248"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.4756281"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/4756282","subjects":[{"kind":"Subject scheme not provided","value":["protoplanetary discs"]},{"kind":"Subject scheme not provided","value":["protoplanetary disks"]},{"kind":"Subject scheme not provided","value":["planet formation"]},{"kind":"Subject scheme not provided","value":["grain growth"]},{"kind":"Subject scheme not provided","value":["sub-mm/mm observations"]},{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["Lupus"]}],"summary":["\u003cp\u003eTable 1 and Table 2 from Tazzari et al., 2021, \u0026quot;The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the Lupus region\u0026quot;, Monthly Notices of the Royal Astronomical Society, arXiv:2010.02248\u003c/p\u003e\n\n\u003cp\u003eBoth tables are available in IPAC format, which is in human- and machine-readable:\u003c/p\u003e\n\n\u003cpre\u003e\u003ccode class=\"language-python\"\u003efrom astropy.io import ascii\ntb = ascii.read('Table1.txt', format='ipac')\u003c/code\u003e\u003c/pre\u003e\n\n\u003cp\u003eTable comments (stored at the beginning of the ASCII file as lines starting with \u0026quot;/\u0026quot;) can be read as:\u003c/p\u003e\n\n\u003cpre\u003e\u003ccode class=\"language-python\"\u003etb.meta['comments']\n\u003c/code\u003e\u003c/pre\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:4756282","title":"Data from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the Lupus region\""},"highlight":{"citation":["Marco Tazzari (2021): <span class=\"highlight\">Data</span> from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics"],"title.exact_value":["<span class=\"highlight\">Data from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the</span>"],"title":["<span class=\"highlight\">Data</span> from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:1241122","_score":18.209042,"_source":{"citation":"Archibald, Anne M., Gusinskaia, Nina V., Hessels, Jason W. T., Deller, Adam T., Kaplan, David L., Lorimer, Duncan R., Lynch, Ryan S., Ransom, Scott M., Stairs, Ingrid H. (2018): Data supporting \"Universality of Free Fall Shown by Orbital Motion of a Pulsar in a Stellar Triple System\". Zenodo. Dataset. https://zenodo.org/record/1241122","content_type":["Dataset"],"contributors":[{"affiliation":["Anton Pannekoek Institute"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-0638-3340"],"value":"Archibald, Anne M."},{"affiliation":["Anton Pannekoek Institute"],"kind":"Creator","value":"Gusinskaia, Nina V."},{"affiliation":["Anton Pannekoek Institute, ASTRON"],"kind":"Creator","value":"Hessels, Jason W. T."},{"affiliation":["Swinburne"],"kind":"Creator","value":"Deller, Adam T."},{"affiliation":["University of Wisconsin-Milwaukee"],"kind":"Creator","value":"Kaplan, David L."},{"affiliation":["West Virginia University, Center for Gravitational Waves and Cosmology"],"kind":"Creator","value":"Lorimer, Duncan R."},{"affiliation":["Green Bank Observatory, Center for Gravitational Waves and Cosmology"],"kind":"Creator","value":"Lynch, Ryan S."},{"affiliation":["National Radio Astronomy Observatory Charlottesville"],"kind":"Creator","value":"Ransom, Scott M."},{"affiliation":["University of British Columbia"],"kind":"Creator","value":"Stairs, Ingrid H."}],"dates":[{"kind":"Publication date","value":"2018"},{"kind":"Issued","value":"2018-07-01"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.1241122"},{"kind":"url","value":"https://zenodo.org/record/1241122"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.1241121"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by-sa/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/1241122","subjects":[{"kind":"Subject scheme not provided","value":["pulsar"]},{"kind":"Subject scheme not provided","value":["timing"]},{"kind":"Subject scheme not provided","value":["TOA"]},{"kind":"Subject scheme not provided","value":["gravity"]}],"summary":["\u003cp\u003eThis is a collection of data supporting the research paper \u0026quot;Orbital Motion of a Pulsar in a Stellar Triple System Shows Universality of Free Fall\u0026quot;.\u003c/p\u003e\n\n\u003cp\u003eThe main data content (the \u0026quot;.tim\u0026quot; file) is a set of pulse arrival times, the primary input to the fitting process, in tempo2 format. These times are annotated with post-fit residuals and derivatives with respect to fit parameters using the tempo2 format\u0026#39;s per-TOA flags.\u003c/p\u003e\n\n\u003cp\u003eAdditional files include the data that went into several figures, plus the above converted to CSV format - but note that the CSV format does not record the pulse arrival times with sufficient precision to permit fitting. Derivative and uncertainty information may permit reanalysis of the systematics.\u003c/p\u003e"],"timdex_record_id":"zenodo:1241122","title":"Data supporting \"Universality of Free Fall Shown by Orbital Motion of a Pulsar in a Stellar Triple System\""},"highlight":{"summary":["<p>This is a collection of <span class=\"highlight\">data</span> supporting the research paper &quot;Orbital Motion of a Pulsar in a Stellar","</p>\n\n<p>The main <span class=\"highlight\">data</span> content (the &quot;.tim&quot; file) is a set of pulse arrival times, the primary","</p>\n\n<p>Additional files include the <span class=\"highlight\">data</span> that went into several figures, plus the above converted to"],"citation":["., Stairs, Ingrid H. (2018): <span class=\"highlight\">Data</span> supporting \"Universality of Free Fall Shown by Orbital Motion of a"],"title.exact_value":["<span class=\"highlight\">Data supporting \"Universality of Free Fall Shown by Orbital Motion of a Pulsar in a Stellar Triple System</span>"],"title":["<span class=\"highlight\">Data</span> supporting \"Universality of Free Fall Shown by Orbital Motion of a Pulsar in a Stellar Triple System"]}},{"_index":"whoas-2022-07-06t15-32-41z","_type":"_doc","_id":"whoas:1912-24528","_score":18.074003,"_source":{"citation":"Donatelli, C., Ganju, N. K., Kalra, T. S., Fagherazzi, S., \u0026 Leonardi, N. (2019). Dataset of numerical modelling results of wave thrust on salt marsh boundaries with different seagrass coverages in a shallow back-barrier estuary. Data in Brief, 25, 104197.","content_type":["Article"],"contributors":[{"kind":"author","value":"Donatelli, Carmine"},{"kind":"author","value":"Ganju, Neil K."},{"kind":"author","value":"Kalra, Tarandeep S."},{"kind":"author","value":"Fagherazzi, Sergio"},{"kind":"author","value":"Leonardi, Nicoletta"}],"dates":[{"kind":"accessioned","value":"2019-09-10T14:28:06Z"},{"kind":"available","value":"2019-09-10T14:28:06Z"},{"kind":"Publication date","value":"2019-07-06"}],"format":"electronic resource","funding_information":[{"funder_name":"This study was supported by the Department of the Interior Hurricane Sandy Recovery program (ID G16AC00455, sub-award to University of Liverpool). S.F. was partly supported by NSF awards 1637630 (PIE LTER) and 1832221 (VCR LTER). We further acknowledge partial support from the Environmental Change Research group at University of Liverpool, and University of Liverpool library for publication fees."}],"identifiers":[{"kind":"uri","value":"https://hdl.handle.net/1912/24528"},{"kind":"doi","value":"10.1016/j.dib.2019.104197"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"https://hdl.handle.net/1912/24528"}],"notes":[{"value":["© The Author(s), 2019. This article is distributed under the terms of the Creative Commons Attribution License. The definitive version was published in Donatelli, C., Ganju, N. K., Kalra, T. S., Fagherazzi, S., \u0026 Leonardi, N. (2019). Dataset of numerical modelling results of wave thrust on salt marsh boundaries with different seagrass coverages in a shallow back-barrier estuary. Data in Brief, 25, 104197, doi:10.1016/j.dib.2019.104197."]}],"publication_information":["Elsevier"],"related_items":[{"uri":"https://doi.org/10.1016/j.dib.2019.104197"}],"rights":[{},{"uri":"http://creativecommons.org/licenses/by/4.0/"}],"source":"Woods Hole Open Access Server","source_link":"https://darchive.mblwhoilibrary.org/handle/1912/24528","subjects":[{"kind":"Subject scheme not provided","value":["Vegetation","COAWST","Wave thrust"]}],"summary":["This article contains data on the effects of seagrass decline on wave energy along the shoreline of Barnegat Bay (USA) previously evaluated in Donatelli et al., 2019. This study was carried out applying the Coupled-Ocean-Atmosphere-Wave-Sediment Transport (COAWST) numerical modelling framework to six historical maps of seagrass distribution. A new routine recently implemented in COAWST was used, which explicitly computes the wave thrust acting on salt marsh boundaries. The numerical modelling results are reported in terms of wind-wave heights for different seagrass coverages, wind speeds and directions. From a comparison with a numerical experiment without submerged aquatic vegetation, we show how the computed wave thrust on marsh boundaries can be reduced by seagrass beds."],"timdex_record_id":"whoas:1912-24528","title":"Dataset of numerical modelling results of wave thrust on salt marsh boundaries with different seagrass coverages in a shallow back-barrier estuary"},"highlight":{"summary":["This article contains <span class=\"highlight\">data</span> on the effects of seagrass decline on wave energy along the shoreline of Barnegat"],"citation":["<span class=\"highlight\">Data</span> in Brief, 25, 104197."],"title.exact_value":["<span class=\"highlight\">Dataset of numerical modelling results of wave thrust on salt marsh boundaries with different seagrass</span>"],"notes.value":["<span class=\"highlight\">Data</span> in Brief, 25, 104197, doi:10.1016/j.dib.2019.104197."]}},{"_index":"jpal-2022-07-06t15-32-27z","_type":"_doc","_id":"jpal:doi:10.7910-DVN-TDFJ7X","_score":17.446787,"_source":{"alternate_titles":[{"kind":"AlternativeTitle","value":"Education, HIV, and Early Fertility: Experimental Evidence from Kenya"}],"citation":"Duflo, Esther, Dupas, Pascaline, Kremer, Michael (2013): Data on Kenyan Youths. Harvard Dataverse. Dataset. https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/TDFJ7X","content_type":["Dataset"],"contributors":[{"affiliation":["Massachusetts Institute of Technology"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-6105-617X"],"value":"Duflo, Esther"},{"affiliation":["Stanford University"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-0140-9417"],"value":"Dupas, Pascaline"},{"affiliation":["Harvard University"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-7914-5269"],"value":"Kremer, Michael"},{"affiliation":["Massachusetts Institute of Technology"],"kind":"ContactPerson","value":"Duflo, Esther"},{"affiliation":["Stanford University"],"kind":"ContactPerson","value":"Dupas, Pascaline"},{"affiliation":["Harvard University"],"kind":"ContactPerson","value":"Kremer, Michael"},{"kind":"Distributor","value":"Jameel Poverty Action Lab"}],"dates":[{"kind":"Publication date","value":"2013"},{"kind":"Issued","value":"2012-12"},{"kind":"Submitted","value":"2013-09-17"},{"kind":"Updated","value":"2020-03-31"}],"edition":"4.4","file_formats":["text/plain; charset=US-ASCII","application/x-stata","application/msword"],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.7910/DVN/TDFJ7X"}],"publication_information":["Harvard Dataverse"],"related_items":[{"relationship":"IsCitedBy","uri":"https://doi.org/10.1257/aer.20121607"}],"rights":[{"uri":"info:eu-repo/semantics/openAccess"},{"uri":"http://creativecommons.org/publicdomain/zero/1.0"}],"source":"Abdul Latif Jameel Poverty Action Lab Dataverse","source_link":"https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/TDFJ7X","subjects":[{"kind":"Subject scheme not provided","value":["Social Sciences"]},{"kind":"Subject scheme not provided","value":["HIV, Kenya, uniforms, Herpes (HSV2), sexually transmitted infection(STI), students, drop-out, pregnancy, teacher training, AIDS/HIV curriculum, risky sexual behavior."]}],"summary":["A seven-year randomized evaluation suggests education subsidies reduce adolescent girls' dropout, pregnancy, and marriage but not sexually transmitted infection (STI). The government's HIV curriculum, which stresses abstinence until marriage, does not reduce pregnancy or STI. Both programs combined reduce STI more, but cut dropout and pregnancy less, than education subsidies alone. These results are inconsistent with a model of schooling and sexual behavior in which both pregnancy and STI are determined by one factor (unprotected sex), but consistent with a two-factor model in which choices between committed and casual relationships also affect these outcomes.\r\n\r\nThis data was collected as a part of the study \"Education, HIV, and Early Fertility: Experimental Evidence from Kenya.\"  Details on sample construction and data collection for this survey data can be found in the paper.  The 2012 version of the paper is available here: http://www.stanford.edu/~pdupas/DDK_EducFertHIV.pdf.  Note that all sections of data collected for the study are not currently available and will be released in the future."],"timdex_record_id":"jpal:doi:10.7910-DVN-TDFJ7X","title":"Data on Kenyan Youths"},"highlight":{"summary":["This <span class=\"highlight\">data</span> was collected as a part of the study \"Education, HIV, and Early Fertility: Experimental Evidence","Details on sample construction and <span class=\"highlight\">data</span> collection for this survey <span class=\"highlight\">data</span> can be found in the paper.","Note that all sections of <span class=\"highlight\">data</span> collected for the study are not currently available and will be released"],"citation":["Duflo, Esther, Dupas, Pascaline, Kremer, Michael (2013): <span class=\"highlight\">Data</span> on Kenyan Youths. Harvard Dataverse."],"title.exact_value":["<span class=\"highlight\">Data on Kenyan Youths</span>"],"title":["<span class=\"highlight\">Data</span> on Kenyan Youths"]}},{"_index":"jpal-2022-07-06t15-32-27z","_type":"_doc","_id":"jpal:doi:10.7910-DVN-DBX9YW","_score":17.358427,"_source":{"citation":"Abhijit Banerjee, Jennifer Bussell, Sarika Gupta, Rema Hanna, Ben Olken (2021): Data for Haqdarshak: Leveraging Technology and Entrepreneurship to Increase Access to Welfare Programs. Harvard Dataverse. Dataset. https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/DBX9YW","content_type":["Dataset"],"contributors":[{"affiliation":["Massachusetts Institute of Technology"],"kind":"Creator","value":"Abhijit Banerjee"},{"affiliation":["University of California, Berkeley"],"kind":"Creator","value":"Jennifer Bussell"},{"affiliation":["Harvard University"],"kind":"Creator","value":"Sarika Gupta"},{"affiliation":["Harvard University"],"kind":"Creator","value":"Rema Hanna"},{"affiliation":["Massachusetts Institute of Technology"],"kind":"Creator","value":"Ben Olken"},{"affiliation":["Harvard University"],"kind":"ContactPerson","value":"Weiss, Alexa"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Submitted","value":"2021-08-10"},{"kind":"Updated","value":"2021-08-10"}],"edition":"2.0","file_formats":["application/pdf","application/pdf","application/pdf","application/pdf","application/pdf","application/x-tex","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","text/tab-separated-values","application/x-tex","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","text/tab-separated-values","text/tab-separated-values","application/x-tex","application/x-tex","application/x-tex","application/pdf","application/x-tex","application/x-tex","application/x-tex","application/x-tex","text/tab-separated-values","text/tab-separated-values","application/x-tex","application/x-tex","application/x-tex","application/x-tex","text/tab-separated-values","text/tab-separated-values","text/tab-separated-values","application/x-stata-syntax","application/x-tex","application/x-tex","application/x-tex","application/x-tex","text/tab-separated-values","application/x-tex","text/tab-separated-values","text/tab-separated-values","text/tab-separated-values","text/tab-separated-values","text/tab-separated-values","text/tab-separated-values","text/tab-separated-values","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/pdf","text/tab-separated-values","application/x-tex","text/tab-separated-values","text/tab-separated-values","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex"],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.7910/DVN/DBX9YW"}],"publication_information":["Harvard Dataverse"],"rights":[{"uri":"info:eu-repo/semantics/openAccess"},{"uri":"https://creativecommons.org/publicdomain/zero/1.0/"}],"source":"Abdul Latif Jameel Poverty Action Lab Dataverse","source_link":"https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/DBX9YW","subjects":[{"kind":"Subject scheme not provided","value":["Social Sciences"]}],"summary":["This package contains replication data for the project \"Haqdarshak: Leveraging Technology and Entrepreneurship to Increase Access to Welfare Programs.” The package contains two main sets of data: i) de-identified raw data files for baseline, intervention and endline for the pilot sample (646 households), conducted in 10 Indian villages in Dausa district, Rajasthan, from December 2017 to April 2019; ii) the baseline data collected for the main experimental sample (4808 households), which was launched in July 2019 across 94 villages in the district of Sikar, Jhunjhunu and Bhilwara, and completed in February 2020. The main intervention and endline were put on pause because of COVID-19, so there is only baseline data for the main experiment. The code, produced in Stata, contains both cleaning and analysis code, which generate intermediate data and latex tables, respectively. For further details on the data or code, please see the readme file. Finally, the package also contains the survey instruments used in data collection as well as a narrative report from the project that provides analysis on the pilot and baseline data."],"timdex_record_id":"jpal:doi:10.7910-DVN-DBX9YW","title":"Data for Haqdarshak: Leveraging Technology and Entrepreneurship to Increase Access to Welfare Programs"},"highlight":{"summary":["This package contains replication <span class=\"highlight\">data</span> for the project \"Haqdarshak: Leveraging Technology and Entrepreneurship","The package contains two main sets of <span class=\"highlight\">data</span>: i) de-identified raw <span class=\"highlight\">data</span> files for baseline, intervention","10 Indian villages in Dausa district, Rajasthan, from December 2017 to April 2019; ii) the baseline <span class=\"highlight\">data</span>","For further details on the <span class=\"highlight\">data</span> or code, please see the readme file.","report from the project that provides analysis on the pilot and baseline <span class=\"highlight\">data</span>."],"citation":["Abhijit Banerjee, Jennifer Bussell, Sarika Gupta, Rema Hanna, Ben Olken (2021): <span class=\"highlight\">Data</span> for Haqdarshak:"],"title.exact_value":["<span class=\"highlight\">Data for Haqdarshak: Leveraging Technology and Entrepreneurship to Increase Access to Welfare Programs</span>"],"title":["<span class=\"highlight\">Data</span> for Haqdarshak: Leveraging Technology and Entrepreneurship to Increase Access to Welfare Programs"]}},{"_index":"jpal-2022-07-06t15-32-27z","_type":"_doc","_id":"jpal:doi:10.7910-DVN-VAFYV1","_score":17.274666,"_source":{"citation":"Karthik Muralidharan, Paul Niehaus, Sandip Sukhtankar, Jeffrey Weaver (2021): Data for the \"Targeted Unconditional Framed Cash Transfers for Early Childhood Health and Nutrition Outcomes\" project. Harvard Dataverse. Dataset. https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/VAFYV1","content_type":["Dataset"],"contributors":[{"affiliation":["University of California, San Diego"],"kind":"Creator","value":"Karthik Muralidharan"},{"affiliation":["University of California, San Diego"],"kind":"Creator","value":"Paul Niehaus"},{"affiliation":["University of Virginia"],"kind":"Creator","value":"Sandip Sukhtankar"},{"affiliation":["University of Southern California"],"kind":"Creator","value":"Jeffrey Weaver"},{"affiliation":["J-PAL"],"kind":"ContactPerson","value":"Akanksha Saletore"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Submitted","value":"2021-01-28"},{"kind":"Updated","value":"2021-06-30"}],"edition":"3.0","file_formats":["application/pdf","application/pdf","text/tab-separated-values","application/pdf","text/tab-separated-values","application/pdf","text/tab-separated-values","application/pdf","text/tab-separated-values","application/pdf","text/tab-separated-values","application/pdf","text/tab-separated-values","application/pdf","text/tab-separated-values"],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.7910/DVN/VAFYV1"}],"publication_information":["Harvard Dataverse"],"rights":[{"uri":"info:eu-repo/semantics/openAccess"},{"uri":"https://creativecommons.org/publicdomain/zero/1.0/"}],"source":"Abdul Latif Jameel Poverty Action Lab Dataverse","source_link":"https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/VAFYV1","subjects":[{"kind":"Subject scheme not provided","value":["Social Sciences"]}],"summary":["This package contains data for the RCT \"Targeted Unconditional Framed Cash Transfers for Early Childhood Health and Nutrition Outcomes.\" The package includes  data from the first two phases of the trial, conducted between September 2018 and December 2019 in 8 districts in a single Indian state. The datasets contain cleaned data from surveys given at the household level, and include anthropometric and reported data on mothers and children. Observations are at the child level. For further details on the data, please see the readme file."],"timdex_record_id":"jpal:doi:10.7910-DVN-VAFYV1","title":"Data for the \"Targeted Unconditional Framed Cash Transfers for Early Childhood Health and Nutrition Outcomes\" project"},"highlight":{"summary":["This package contains <span class=\"highlight\">data</span> for the RCT \"Targeted Unconditional Framed Cash Transfers for Early Childhood","The package includes  <span class=\"highlight\">data</span> from the first two phases of the trial, conducted between September 2018 and","The datasets contain cleaned <span class=\"highlight\">data</span> from surveys given at the household level, and include anthropometric","and reported <span class=\"highlight\">data</span> on mothers and children.","For further details on the <span class=\"highlight\">data</span>, please see the readme file."],"citation":["Karthik Muralidharan, Paul Niehaus, Sandip Sukhtankar, Jeffrey Weaver (2021): <span class=\"highlight\">Data</span> for the \"Targeted"],"title.exact_value":["<span class=\"highlight\">Data for the \"Targeted Unconditional Framed Cash Transfers for Early Childhood Health and Nutrition Outcomes</span>"],"title":["<span class=\"highlight\">Data</span> for the \"Targeted Unconditional Framed Cash Transfers for Early Childhood Health and Nutrition Outcomes"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5029530","_score":16.52032,"_source":{"citation":"Kshitij Aggarwal, Devansh Agarwal, Evan F Lewis, Reshma Anna-Thomas, Jacob Cardinal Tremblay, Sarah Burke-Spolaor, Maura McLaughlin, Duncan Lorimer (2021): Dataset corresponding to \"Comprehensive analysis of a dense sample of FRB 121102 bursts\". Zenodo. Dataset. https://zenodo.org/record/5029530","content_type":["Dataset"],"contributors":[{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-2059-0525"],"value":"Kshitij Aggarwal"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-0385-491X"],"value":"Devansh Agarwal"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-2972-522X"],"value":"Evan F Lewis"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-8057-0633"],"value":"Reshma Anna-Thomas"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-9852-6825"],"value":"Jacob Cardinal Tremblay"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-4052-7838"],"value":"Sarah Burke-Spolaor"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-7697-7422"],"value":"Maura McLaughlin"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-1301-966X"],"value":"Duncan Lorimer"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-06-24"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5029530"},{"kind":"url","value":"https://zenodo.org/record/5029530"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5029529"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5029530","subjects":[{"kind":"Subject scheme not provided","value":["Fast Radio Bursts"]},{"kind":"Subject scheme not provided","value":["Markov  Chain  Monte  Carlo"]},{"kind":"Subject scheme not provided","value":["Observational Astronomy"]},{"kind":"Subject scheme not provided","value":["Astronomy  data  analysis"]}],"summary":["\u003cp\u003eRaw dataset corresponding to publication: \u003ca href=\"https://ui.adsabs.harvard.edu/abs/2021arXiv210705658A/abstract\"\u003e\u0026quot;Comprehensive analysis of a dense sample of FRB 121102 bursts\u0026quot;\u003c/a\u003e. The dataset consists of raw filterbank format files from the two observations.\u003c/p\u003e"],"timdex_record_id":"zenodo:5029530","title":"Dataset corresponding to \"Comprehensive analysis of a dense sample of FRB 121102 bursts\""},"highlight":{"title.exact_value":["<span class=\"highlight\">Dataset corresponding to \"Comprehensive analysis of a dense sample of FRB 121102 bursts\"</span>"],"subjects.value":["Astronomy  <span class=\"highlight\">data</span>  analysis"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5902893","_score":15.819018,"_source":{"citation":"Fiorenzo Stoppa, Paul Vreeswijk (2022): Dataset for: AutoSourceID-Light. Zenodo. Dataset. https://zenodo.org/record/5902893","content_type":["Dataset"],"contributors":[{"affiliation":["Radboud University"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-3424-8528"],"value":"Fiorenzo Stoppa"},{"affiliation":["Radboud University"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-7572-9088"],"value":"Paul Vreeswijk"}],"dates":[{"kind":"Publication date","value":"2022"},{"kind":"Issued","value":"2022-01-27"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5902893"},{"kind":"url","value":"https://zenodo.org/record/5902893"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5902892"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5902893","subjects":[{"kind":"Subject scheme not provided","value":["Machine learning"]},{"kind":"Subject scheme not provided","value":["Astronomy"]}],"summary":["\u003cp\u003eThis is the dataset used in the paper AutoSourceID-Light (\u003cstrong\u003e\u003ca href=\"https://arxiv.org/abs/2202.00489\"\u003eArXiv preperint\u003c/a\u003e\u003c/strong\u003e)\u0026nbsp;for Training, Test and Validation sets.\u0026nbsp;AutoSourceID-Light (ASID-L) is\u0026nbsp;an innovative framework that uses computer vision techniques that can naturally deal with large amounts of data and rapidly localize sources in optical images.\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003eThe dataset is made of\u0026nbsp;3 fields images taken with\u0026nbsp;the MeerLICHT telescope:\u0026nbsp;_20200601_191800_ (Omega Centauri globular cluster),\u0026nbsp;_20210401_173445_(Fornax galaxy cluster)\u0026nbsp;and\u0026nbsp;_20210910_022724_ (\u0026#39;empty\u0026#39; CDF-S).\u003c/p\u003e\n\n\u003cp\u003eFor each field, 2\u0026nbsp;files are provided: the optical image (_red_cosmics_nobkgsub.fits) and the catalog of EDR3 Gaia sources that match the location of the fields\u0026nbsp;(_GaiaEDR3_cat_SNR_redimage.fits).\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003eIf you use the dataset, please cite the appropriate DOIs.\u003c/p\u003e\n\n\u003cp\u003eCode available at\u0026nbsp;\u003ca href=\"https://github.com/FiorenSt/AutoSourceID-Light/tree/v0.0.2\"\u003e\u003cstrong\u003ehttps://github.com/FiorenSt/AutoSourceID-Light\u003c/strong\u003e\u003c/a\u003e\u0026nbsp; (\u003ca href=\"https://zenodo.org/record/6414546#.YkwoeihByUk\"\u003eZenodo repository\u003c/a\u003e)\u003c/p\u003e"],"timdex_record_id":"zenodo:5902893","title":"Dataset for: AutoSourceID-Light"},"highlight":{"summary":["innovative framework that uses computer vision techniques that can naturally deal with large amounts of <span class=\"highlight\">data</span>"],"title.exact_value":["<span class=\"highlight\">Dataset for: AutoSourceID-Light</span>"]}}]},"aggregations":{"languages":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"en_us","doc_count":122},{"key":"en","doc_count":87},{"key":"el","doc_count":1},{"key":"fr","doc_count":1}]},"content_type":{"doc_count_error_upper_bound":0,"sum_other_doc_count":3,"buckets":[{"key":"dataset","doc_count":218},{"key":"article","doc_count":132},{"key":"working paper","doc_count":70},{"key":"software","doc_count":58},{"key":"text","doc_count":36},{"key":"preprint","doc_count":17},{"key":"journalarticle","doc_count":9},{"key":"conferencepaper","doc_count":6},{"key":"other","doc_count":5},{"key":"image","doc_count":3}]},"collections":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[]},"subjects":{"doc_count":1143,"subject_names":{"doc_count_error_upper_bound":7,"sum_other_doc_count":1444,"buckets":[{"key":"social sciences","doc_count":99},{"key":"astronomy","doc_count":46},{"key":"gas hydrate","doc_count":13},{"key":"radio astronomy","doc_count":13},{"key":"medicine, health and life sciences","doc_count":11},{"key":"astrophysics","doc_count":10},{"key":"idl","doc_count":10},{"key":"sediment transport","doc_count":10},{"key":"machine learning","doc_count":9},{"key":"python","doc_count":8}]}},"content_format":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"electronic resource","doc_count":557}]},"literary_form":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[]},"source":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"zenodo","doc_count":242},{"key":"woods hole open access server","doc_count":146},{"key":"abdul latif jameel poverty action lab dataverse","doc_count":99},{"key":"dspace@mit","doc_count":70}]},"contributors":{"doc_count":2787,"contributor_names":{"doc_count_error_upper_bound":12,"sum_other_doc_count":2567,"buckets":[{"key":"duflo, esther","doc_count":47},{"key":"massachusetts institute of technology. center for energy and environmental policy research.","doc_count":46},{"key":"banerjee, abhijit","doc_count":22},{"key":"danehkar, ashkbiz","doc_count":17},{"key":"ganju, neil k.","doc_count":16},{"key":"glennerster, rachel","doc_count":16},{"key":"ten brink, uri s.","doc_count":16},{"key":"warner, john c.","doc_count":15},{"key":"greenstone, michael","doc_count":13},{"key":"ruppel, carolyn d.","doc_count":12}]}}}} + recorded_at: Wed, 06 Jul 2022 15:35:56 GMT +- request: + method: post + uri: http://localhost:9200/timdex-prod/_search + body: + encoding: UTF-8 + string: '{"from":"0","size":20,"query":{"bool":{"should":[{"prefix":{"title.exact_value":{"value":"data","boost":15.0}}},{"term":{"title":{"value":"data","boost":1.0}}},{"nested":{"path":"contributors","query":{"term":{"contributors.value":{"value":"data","boost":0.1}}}}}],"must":[{"multi_match":{"query":"data"}}],"filter":[{"bool":{"should":[{"term":{"source":"Zenodo"}},{"term":{"source":"DSpace@MIT"}}]}}]}},"highlight":{"pre_tags":["\u003cspan + class=\"highlight\"\u003e"],"post_tags":["\u003c/span\u003e"],"fields":{"*":{}}},"aggregations":{"collections":{"terms":{"field":"collections.keyword"}},"contributors":{"nested":{"path":"contributors"},"aggs":{"contributor_names":{"terms":{"field":"contributors.value.keyword"}}}},"content_type":{"terms":{"field":"content_type"}},"content_format":{"terms":{"field":"format"}},"languages":{"terms":{"field":"languages.keyword"}},"literary_form":{"terms":{"field":"literary_form"}},"source":{"terms":{"field":"source"}},"subjects":{"nested":{"path":"subjects"},"aggs":{"subject_names":{"terms":{"field":"subjects.value.keyword"}}}}}}' + headers: + User-Agent: + - 'opensearch-ruby/2.0.0 (RUBY_VERSION: 2.7.6; darwin x86_64; Faraday v1.10.0)' + Content-Type: + - application/json + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=UTF-8 + Content-Length: + - '16146' + body: + encoding: ASCII-8BIT + string: !binary |- + {"took":67,"timed_out":false,"_shards":{"total":4,"successful":4,"skipped":0,"failed":0},"hits":{"total":{"value":312,"relation":"eq"},"max_score":20.448364,"hits":[{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5728409","_score":20.448364,"_source":{"citation":"Stevens, Abigail (2021): Data for time series tutorial. Zenodo. Dataset. https://zenodo.org/record/5728409","content_type":["Dataset"],"contributors":[{"affiliation":["Michigan State Univ. and Univ. of Michigan"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-5041-3079"],"value":"Stevens, Abigail"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-11-25"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5728409"},{"kind":"url","value":"https://zenodo.org/record/5728409"}],"languages":["en"],"notes":[{"kind":"Other","value":["{\"references\": [\"Wilson-Hodge, C. et al. (2018). \\\"NICER and Fermi GBM Observations of the First Galactic Ultraluminous X-Ray Pulsar Swift J0243.6+6124,\\\" ApJ, 863, 9.\", \"Stevens, A.L. et al. (2018). \\\" A NICER Discovery of a Low-frequency Quasi-periodic Oscillation in the Soft-intermediate State of MAXI J1535-571,\\\" ApJ, 865, L15.\"]}"]}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5728408"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5728409","subjects":[{"kind":"Subject scheme not provided","value":["astronomy"]}],"summary":["\u003cp\u003eThese are sample data files to be used in the time series tutorial found here: \u003ca href=\"https://github.com/abigailStev/timeseries-tutorial\"\u003ehttps://github.com/abigailStev/timeseries-tutorial \u003c/a\u003e\u003c/p\u003e\n\n\u003cp\u003eThey are public datasets from the NICER X-ray Timing Instrument of a black hole, MAXI J1535-571, and a neutron star, Swift J0243.6+6124. There are also Good Time Intervals I created for each of the photon event lists.\u003c/p\u003e"],"timdex_record_id":"zenodo:5728409","title":"Data for time series tutorial"},"highlight":{"summary":["<p>These are sample <span class=\"highlight\">data</span> files to be used in the time series tutorial found here: <a href=\"https://github.com"],"citation":["Stevens, Abigail (2021): <span class=\"highlight\">Data</span> for time series tutorial. Zenodo."],"title.exact_value":["<span class=\"highlight\">Data for time series tutorial</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span> for time series tutorial"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:3242151","_score":19.489151,"_source":{"citation":"Deacon, Niall R, Henning, Thomas, Kossakowski, Diana E. (2019): Data-driven stellar parameters for southern TESS FGK targets. Zenodo. JournalArticle. https://zenodo.org/record/3242151","content_type":["JournalArticle"],"contributors":[{"affiliation":["MPIA"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-2440-7350"],"value":"Deacon, Niall R"},{"affiliation":["MPIA"],"kind":"Creator","value":"Henning, Thomas"},{"affiliation":["MPIA"],"kind":"Creator","value":"Kossakowski, Diana E."}],"dates":[{"kind":"Publication date","value":"2019"},{"kind":"Issued","value":"2019-06-09"}],"edition":"1.0","format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.3242151"},{"kind":"url","value":"https://zenodo.org/record/3242151"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.3242150"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/3242151","subjects":[{"kind":"Subject scheme not provided","value":["astronomy, exoplanet, tess, stellar parameters"]}],"summary":["\u003cp\u003ePresented here are the extended tables for Deacon et al. (2019)\u003c/p\u003e\n\n\u003cp\u003eTable3: This table presents stellar parameters for southern FGK stars that are likely high priority targets for the TESS mission. The parameters are presented in the same way as in the tables in the paper with the exception of several additional flags.\u003cbr\u003e\n\u003cbr\u003e\nfeh_flag - set if an object has an estimated Fe/H value of \u0026gt;0.55. This normally indicates the code is hitting the edge of the metallicity grid and likely means the object cannot be well described by our model rather than it being extremely high metallicity\u003cbr\u003e\n\u003cbr\u003e\nTable A1: A compilation of Gaia astrometry for TESS targets is presented as described in the paper\u003cbr\u003e\n\u003cbr\u003e\nfeh_not_measured_flag - set when we do not have Skymapper u or v data and thus cannot reliably estimate an objects metallicity. In these cases Fe/H is set to -1, the typical value in the solar neighbourhood\u003cbr\u003e\n\u003cbr\u003e\nav_lim_flag - set if we do not find a statistically significant constrain on the star\u0026#39;s extinction. In this case we quote an upper limit based on other studies (this is detailed further in the paper)\u003cbr\u003e\n\u003cbr\u003e\nteff_flag - indicates that the best-fitting effective temperature value fell outside our grid. Thus we quote either the lower limit (7000K) or the upper limit (4600K for dwarfs, 4000K for giants). For such objects all other parameters are set to null values (-99.9 for all parameters except extinction which is set to 99.9)\u003cbr\u003e\n\u003cbr\u003e\nteff_lower_lim_flag - set if the lower limit of our T_eff confidence bound falls outside the range of our training sample.\u003cbr\u003e\n\u003cbr\u003e\nteff_upper_lim_flag - set if the upper limit of our T_eff confidence bound falls outside the range of our training sample.\u003cbr\u003e\n\u003cbr\u003e\n\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:3242151","title":"Data-driven stellar parameters for southern TESS FGK targets"},"highlight":{"summary":["as described in the paper<br>\n<br>\nfeh_not_measured_flag - set when we do not have Skymapper u or v <span class=\"highlight\">data</span>"],"citation":["Deacon, Niall R, Henning, Thomas, Kossakowski, Diana E. (2019): <span class=\"highlight\">Data</span>-driven stellar parameters for southern"],"title.exact_value":["<span class=\"highlight\">Data-driven stellar parameters for southern TESS FGK targets</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span>-driven stellar parameters for southern TESS FGK targets"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5727583","_score":19.343845,"_source":{"citation":"Taubenberger Stefan (2021): Data for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae\". Zenodo. Dataset. https://zenodo.org/record/5727583","content_type":["Dataset"],"contributors":[{"affiliation":["Max-Planck-Institut für Astrophysik"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-4265-1958"],"value":"Taubenberger Stefan"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-11-25"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5727583"},{"kind":"url","value":"https://zenodo.org/record/5727583"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsSupplementTo","uri":"https://doi.org/10.1007/978-3-319-21846-5_37"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5727582"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5727583","subjects":[{"kind":"Subject scheme not provided","value":["supernovae"]},{"kind":"Subject scheme not provided","value":["thermonuclear"]}],"summary":["\u003cp\u003eData needed to recreate Figure 1 of Taubenberger\u0026nbsp; S., \u003ca href=\"https://ui.adsabs.harvard.edu/abs/2017hsn..book..317T/abstract\"\u003e\u0026quot;The Extremes of Thermonuclear Supernovae\u0026quot;\u003c/a\u003e, in\u0026nbsp;A. W. Alsabti, P. Murdin, eds., \u0026ldquo;Handbook of Supernovae\u0026rdquo;, Springer, ISBN: 978-3-319-20794-0 (2017). A detailed README is included.\u003c/p\u003e"],"timdex_record_id":"zenodo:5727583","title":"Data for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae\""},"highlight":{"summary":["<p><span class=\"highlight\">Data</span> needed to recreate Figure 1 of Taubenberger&nbsp; S., <a href=\"https://ui.adsabs.harvard.edu/"],"citation":["Taubenberger Stefan (2021): <span class=\"highlight\">Data</span> for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae"],"title.exact_value":["<span class=\"highlight\">Data for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae\"</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span> for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:3820679","_score":19.08733,"_source":{"citation":"Martínez-Palomera, Jorge, Bloom, Joshua S., Abrahams, Ellianna S. (2020): Data from: \"Deep Generative Modeling of Periodic Variable Stars Using Physical Parameters\". Zenodo. Dataset. https://zenodo.org/record/3820679","content_type":["Dataset"],"contributors":[{"affiliation":["University of California Berkeley"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-7395-4935"],"value":"Martínez-Palomera, Jorge"},{"affiliation":["University of California Berkeley"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-7777-216X"],"value":"Bloom, Joshua S."},{"affiliation":["University of California Berkeley"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-9879-1183"],"value":"Abrahams, Ellianna S."}],"dates":[{"kind":"Publication date","value":"2020"},{"kind":"Issued","value":"2020-05-20"}],"edition":"0.1","format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.3820679"},{"kind":"url","value":"https://zenodo.org/record/3820679"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsSupplementTo","uri":"arXiv:2005.07773"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.3820678"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/3820679","subjects":[{"kind":"Subject scheme not provided","value":["periodic variables"]},{"kind":"Subject scheme not provided","value":["light curves"]},{"kind":"Subject scheme not provided","value":["cross-matching validation"]},{"kind":"Subject scheme not provided","value":["ogle3"]},{"kind":"Subject scheme not provided","value":["gaia-dr2"]},{"kind":"Subject scheme not provided","value":["variational autoencoder"]},{"kind":"Subject scheme not provided","value":["generative models"]}],"summary":["\u003cp\u003eThis dataset was used for the training of a conditioned Variational Autoencoder that generates physically informed light curves of periodic variable stars. The light curves correspond to data obtained from The Optical Gravitational Lensing Experiment (\u003ca href=\"https://ui.adsabs.harvard.edu/abs/1992AcA....42..253U/abstract\"\u003eOGLE\u003c/a\u003e), while ancillary information was obtained from the Gaia Data Release 2 (\u003ca href=\"https://ui.adsabs.harvard.edu/link_gateway/2016A\u0026amp;A...595A...1G/doi:10.1051/0004-6361/201629272\"\u003eGAIA DR2\u003c/a\u003e). This repository contains the preprocessed OGLE light curves and the GAIA measurements corresponding to each cross-matched source. We also provided a subsample of cross-matched sources that were carefully validated following several steps described in the companion article (paper reference).\u003c/p\u003e\n\n\u003cp\u003eThis dataset is realized in tandem with the corresponding\u0026nbsp;\u003ca href=\"https://github.com/jorgemarpa/PELS-VAE\"\u003eGitHub\u003c/a\u003e\u0026nbsp;and\u0026nbsp;\u003ca href=\"https://arxiv.org/abs/2005.07773\"\u003earticle\u003c/a\u003e.\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:3820679","title":"Data from: \"Deep Generative Modeling of Periodic Variable Stars Using Physical Parameters\""},"highlight":{"summary":["The light curves correspond to <span class=\"highlight\">data</span> obtained from The Optical Gravitational Lensing Experiment (<a href","abs/1992AcA....42..253U/abstract\">OGLE</a>), while ancillary information was obtained from the Gaia <span class=\"highlight\">Data</span>"],"citation":["., Abrahams, Ellianna S. (2020): <span class=\"highlight\">Data</span> from: \"Deep Generative Modeling of Periodic Variable Stars Using"],"title.exact_value":["<span class=\"highlight\">Data from: \"Deep Generative Modeling of Periodic Variable Stars Using Physical Parameters\"</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span> from: \"Deep Generative Modeling of Periodic Variable Stars Using Physical Parameters\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:3628656","_score":19.01915,"_source":{"citation":"Huang, Jane (2020): Data from  \"A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk\". Zenodo. Dataset. https://zenodo.org/record/3628656","content_type":["Dataset"],"contributors":[{"affiliation":["Center for Astrophysics | Harvard \u0026 Smithsonian"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-6947-6072"],"value":"Huang, Jane"}],"dates":[{"kind":"Publication date","value":"2020"},{"kind":"Issued","value":"2020-01-29"}],"edition":"1","format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.3628656"},{"kind":"url","value":"https://zenodo.org/record/3628656"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.3628655"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/3628656","subjects":[{"kind":"Subject scheme not provided","value":["GM Aur"]},{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["Protoplanetary disks"]}],"summary":["\u003cp\u003eImage cubes, self-calibrated visibilities, and self-calibration and imaging scripts for data associated with Huang et al., 2020, \u0026quot;A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk,\u0026quot; The Astrophysical Journal, 891, 48,\u0026nbsp;arXiv:2001.11040\u003c/p\u003e\n\n\u003cp\u003eThe raw data are available on the ALMA archive under program IDs\u0026nbsp;2017.1.01151.S and\u0026nbsp;2018.1.01230.S (PI: Jane Huang).\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eScripts:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003ereduction_utils.py: Set of helper functions for self-calibration scripts\u003c/p\u003e\n\n\u003cp\u003eB4continuumreduction.py: Self-calibration and imaging script for Band 4\u0026nbsp;(2.1 mm) continuum (GMAurB4continuumfinal.image.fits) from GMAurB4continuum.final.ms.tgz\u003c/p\u003e\n\n\u003cp\u003eB6continuumreduction.py: Self-calibration and imaging script for Band 6 (1.1 mm) continuum (GMAurB6continuumfinal.image.fits) from GMAurB6continuum.final.ms.tgz\u003c/p\u003e\n\n\u003cp\u003eHCOp_imaging.py: Script producing GMAur_HCOp_continuumsubtracted.image.fits and GMAur_HCOp_withcontinuum.image.fits from GMAurB6_HCOp.ms.contsub.cvel and GMAurB6_HCOp.ms.cvel, respectively\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eMeasurement sets:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eGMAurB4continuumfinal.ms.tgz: Self-calibrated 2.1 mm continuum visibilities for GM Aur\u003c/p\u003e\n\n\u003cp\u003eGMAurB6continuumfinal.ms.tgz: Self-calibrated 1.1 mm continuum visibilities for GM Aur\u003c/p\u003e\n\n\u003cp\u003eGMAurB6_HCOp.ms.cvel.tgz: Self-calibrated HCO\u003csup\u003e+\u0026nbsp;\u003c/sup\u003e3-2 visibilities\u0026nbsp;without continuum subtraction\u003c/p\u003e\n\n\u003cp\u003eGMAurB6_HCOp.ms.contsub.cvel.tgz: Self-calibrated HCO\u003csup\u003e+\u0026nbsp;\u003c/sup\u003e3-2 visibilities\u0026nbsp;with\u0026nbsp;continuum subtraction\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eImages:\u0026nbsp;\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eGMAurB6continuumfinal.image.fits: 1.1 mm continuum image of GM Aur\u003c/p\u003e\n\n\u003cp\u003eGMAurB4continuumfinal.image.fits: 2.1 mm continuum image of GM Aur\u003c/p\u003e\n\n\u003cp\u003eGMAur_HCOp_withcontinuum.image.fits: HCO\u003csup\u003e+\u0026nbsp;\u003c/sup\u003e3-2 image cube toward GM Aur without continuum subtraction\u003c/p\u003e\n\n\u003cp\u003eGMAur_HCOp_continuumsubtracted.image.fits:\u0026nbsp;HCO\u003csup\u003e+\u0026nbsp;\u003c/sup\u003e3-2 image cube toward GM Aur with\u0026nbsp;continuum subtraction\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:3628656","title":"Data from  \"A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk\""},"highlight":{"summary":["<p>Image cubes, self-calibrated visibilities, and self-calibration and imaging scripts for <span class=\"highlight\">data</span> associated","protoplanetary disk,&quot; The Astrophysical Journal, 891, 48,&nbsp;arXiv:2001.11040</p>\n\n<p>The raw <span class=\"highlight\">data</span>"],"citation":["Huang, Jane (2020): <span class=\"highlight\">Data</span> from  \"A multi-frequency ALMA characterization of substructures in the GM Aur"],"title.exact_value":["<span class=\"highlight\">Data from  \"A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span> from  \"A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:4454165","_score":18.887436,"_source":{"citation":"Law, Charles John (2021): Data from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6-0.4\". Zenodo. Dataset. https://zenodo.org/record/4454165","content_type":["Dataset"],"contributors":[{"affiliation":["Center for Astrophysics | Harvard \u0026 Smithsonian"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-1413-1776"],"value":"Law, Charles John"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-01-21"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.4454165"},{"kind":"url","value":"https://zenodo.org/record/4454165"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.4454164"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/aas"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/4454165","subjects":[{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["Complex organic molecules"]},{"kind":"Subject scheme not provided","value":["Massive star formation"]}],"summary":["\u003cp\u003eNon-continuum-subtracted\u0026nbsp;spectral line image cubes associated with Law et al., 2021, \u0026quot;Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6-0.4,\u0026quot;\u0026nbsp;The Astrophysical Journal [arXiv:2101.07801].\u003c/p\u003e\n\n\u003cp\u003eThe raw data are available on the ALMA archive under program ID\u0026nbsp;2015.1.00106.S (PI: Qizhou\u0026nbsp;Zhang).\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eDatasets:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eG10_6_spw25.fits: Image cube from ~233-235 GHz\u003c/p\u003e\n\n\u003cp\u003eG10_6_spw27.fits: Image cube from ~231-233\u0026nbsp;GHz\u003c/p\u003e\n\n\u003cp\u003eG10_6_spw29.fits: Image cube from ~219-221\u0026nbsp;GHz\u003c/p\u003e\n\n\u003cp\u003eG10_6_spw31.fits: Image cube from ~217-219\u0026nbsp;GHz\u003c/p\u003e"],"timdex_record_id":"zenodo:4454165","title":"Data from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6-0.4\""},"highlight":{"summary":["</p>\n\n<p>The raw <span class=\"highlight\">data</span> are available on the ALMA archive under program ID&nbsp;2015.1.00106.S (PI: Qizhou"],"citation":["Law, Charles John (2021): <span class=\"highlight\">Data</span> from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive"],"title.exact_value":["<span class=\"highlight\">Data from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span> from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:6542596","_score":18.850346,"_source":{"citation":"Heimersheim, Stefan, Sartorio, Nina S., Fialkov, Anastasia, Lorimer, Duncan R. (2022): Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\". Zenodo. Software. https://zenodo.org/record/6542596","content_type":["Software"],"contributors":[{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-9631-4212"],"value":"Heimersheim, Stefan"},{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-2138-5192"],"value":"Sartorio, Nina S."},{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK; Kavli Institute for Cosmology, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-1369-633X"],"value":"Fialkov, Anastasia"},{"affiliation":["West Virginia University, Department of Physics and Astronomy, P. O. Box 6315, Morgantown, WV, USA; Center for Gravitational Waves and Cosmology, West Virginia University, Chestnut Ridge Research Building, Morgantown, WV, USA"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-1301-966X"],"value":"Lorimer, Duncan R."}],"dates":[{"kind":"Publication date","value":"2022"},{"kind":"Issued","value":"2022-05-14"}],"format":"electronic resource","funding_information":[{"award_number":"1430284","award_uri":"info:eu-repo/grantAgreement/NSF/Directorate+for+Mathematical+%26+Physical+Sciences/1430284/","funder_identifier":"10.13039/100000001","funder_identifier_type":"Crossref Funder ID","funder_name":"National Science Foundation"},{"award_number":"1458952","award_uri":"info:eu-repo/grantAgreement/NSF//1458952/","funder_identifier":"10.13039/100000001","funder_identifier_type":"Crossref Funder ID","funder_name":"National Science Foundation"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.6542596"},{"kind":"url","value":"https://zenodo.org/record/6542596"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsSupplementTo","uri":"https://arxiv.org/abs/2107.14242"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5504050"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/6542596","summary":["\u003cp\u003eThis upload contains the data and code used for our Fast Radio Burst forecast, constraining reionization and cosmological parameters (\u003ca href=\"https://arxiv.org/abs/2107.14242\"\u003earXiv:2107.14242\u003c/a\u003e). The data includes both, the generated synthetic observations, as well as the Nested Sampling chains used to produce the results and figures.\u003c/p\u003e\n\n\u003cp\u003eThe minimal set to run the analysis (FlexKnotFRB-small) takes up 6.5 GB (uncompressed) of disk space and can be used to reproduce everything except the high-resolution version of Figure 3. (That version can also be reproduce but would take ~24h.) The full set (FlexKnotFRB-full) takes 31 GB and contains pre-computed cache files allowing to regenerate all paper plots quickly (\u0026lt;\u0026lt;1h). Finally the extra chains which contain additional runs with different seeds and a run with different priors take 68 GB of disk space uncompressed.\u003c/p\u003e\n\n\u003cp\u003eThe most recent code (but not the Nested Sampling chains) is also available on \u003ca href=\"https://github.com/Stefan-Heimersheim/FlexKnotFRB\"\u003eGitHub\u003c/a\u003e.\u003c/p\u003e"],"timdex_record_id":"zenodo:6542596","title":"Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\""},"highlight":{"summary":["<p>This upload contains the <span class=\"highlight\">data</span> and code used for our Fast Radio Burst forecast, constraining reionization","The <span class=\"highlight\">data</span> includes both, the generated synthetic observations, as well as the Nested Sampling chains used"],"citation":["., Fialkov, Anastasia, Lorimer, Duncan R. (2022): <span class=\"highlight\">Data</span> and Code for \"What it Takes to Measure Reionization"],"title.exact_value":["<span class=\"highlight\">Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\"</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span> and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5504051","_score":18.850346,"_source":{"citation":"Heimersheim, Stefan, Sartorio, Nina S., Fialkov, Anastasia, Lorimer, Duncan R. (2021): Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\". Zenodo. Software. https://zenodo.org/record/5504051","content_type":["Software"],"contributors":[{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-9631-4212"],"value":"Heimersheim, Stefan"},{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-2138-5192"],"value":"Sartorio, Nina S."},{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK; Kavli Institute for Cosmology, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-1369-633X"],"value":"Fialkov, Anastasia"},{"affiliation":["West Virginia University, Department of Physics and Astronomy, P. O. Box 6315, Morgantown, WV, USA; Center for Gravitational Waves and Cosmology, West Virginia University, Chestnut Ridge Research Building, Morgantown, WV, USA"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-1301-966X"],"value":"Lorimer, Duncan R."}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-09-14"}],"format":"electronic resource","funding_information":[{"award_number":"1430284","award_uri":"info:eu-repo/grantAgreement/NSF/Directorate+for+Mathematical+%26+Physical+Sciences/1430284/","funder_identifier":"10.13039/100000001","funder_identifier_type":"Crossref Funder ID","funder_name":"National Science Foundation"},{"award_number":"1458952","award_uri":"info:eu-repo/grantAgreement/NSF//1458952/","funder_identifier":"10.13039/100000001","funder_identifier_type":"Crossref Funder ID","funder_name":"National Science Foundation"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5504051"},{"kind":"url","value":"https://zenodo.org/record/5504051"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsSupplementTo","uri":"https://arxiv.org/abs/2107.14242"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5504050"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5504051","summary":["\u003cp\u003eThis upload contains the data and code used for our Fast Radio Burst forecast, constraining reionization and cosmological parameters (\u003ca href=\"https://arxiv.org/abs/2107.14242\"\u003earxiv/2107.14242\u003c/a\u003e). The data includes both, the generated synthetic observations, as well as the Nested Sampling chains used to produce the results and figures.\u003cbr\u003e\nThe most recent code (though not the Nested Sampling chains) is also available on \u003ca href=\"https://github.com/Stefan-Heimersheim/FlexKnotFRB\"\u003eGitHub\u003c/a\u003e.\u003c/p\u003e"],"timdex_record_id":"zenodo:5504051","title":"Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\""},"highlight":{"summary":["<p>This upload contains the <span class=\"highlight\">data</span> and code used for our Fast Radio Burst forecast, constraining reionization","The <span class=\"highlight\">data</span> includes both, the generated synthetic observations, as well as the Nested Sampling chains used"],"citation":["., Fialkov, Anastasia, Lorimer, Duncan R. (2021): <span class=\"highlight\">Data</span> and Code for \"What it Takes to Measure Reionization"],"title.exact_value":["<span class=\"highlight\">Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\"</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span> and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:3928862","_score":18.831516,"_source":{"citation":"Jane Huang (2020): Data from \"Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup\". Zenodo. Dataset. https://zenodo.org/record/3928862","content_type":["Dataset"],"contributors":[{"affiliation":["Center for Astrophysics | Harvard \u0026 Smithsonian"],"kind":"Creator","value":"Jane Huang"}],"dates":[{"kind":"Publication date","value":"2020"},{"kind":"Issued","value":"2020-07-07"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.3928862"},{"kind":"url","value":"https://zenodo.org/record/3928862"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.3928861"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/3928862","subjects":[{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["protoplanetary disks"]},{"kind":"Subject scheme not provided","value":["RU Lup"]}],"summary":["\u003cp\u003eImage cubes, self-calibrated visibilities, and self-calibration and imaging scripts for data from Huang et al., 2020, \u0026quot;Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup,\u0026quot; accepted for publication by The Astrophysical Journal, arXiv:2007.02974\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003eThe raw ALMA data can be found at the ALMA archive under program ID 2018.1.01201.S (PI: Jane Huang).\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eScripts:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eselfcal_C43-5.py, selfcal_C43-2.py, selfcal_ACA.py: self-calibration scripts for observation of RU Lup in various ALMA configurations\u003c/p\u003e\n\n\u003cp\u003eimaging.py: imaging script used for all lines\u003c/p\u003e\n\n\u003cp\u003ereductionutils.py can be downloaded from\u0026nbsp;\u003ca href=\"https://zenodo.org/record/3628656\"\u003ehttps://zenodo.org/record/3628656\u003c/a\u003e\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eMeasurement sets:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eRULupcontinuum.ms.tgz: Continuum visibilities for \u0026quot;RULupallcontinuum.image.pbcor.fits\u0026quot; (the high-resolution ALMA continuum data can be found on the \u003ca href=\"https://bulk.cv.nrao.edu/almadata/lp/DSHARP/\"\u003eDSHARP\u003c/a\u003e page)\u003c/p\u003e\n\n\u003cp\u003eRULup_12CO.ms.contsub.tgz: Continuum-subtracted visibilities for the \u003csup\u003e12\u003c/sup\u003eCO J=2-1 line toward RU Lup\u003c/p\u003e\n\n\u003cp\u003eRULup_12CO_nocontsub.ms.tgz: Visibilities for the \u003csup\u003e12\u003c/sup\u003eCO J=2-1 line (no continuum subtraction) toward RU Lup, used to make the \u0026#39;RULup_12COpeakintensity.fits\u0026#39; file.\u003c/p\u003e\n\n\u003cp\u003eRULup_13CO.ms.contsub.tgz: Continuum-subtracted visibilities for the \u003csup\u003e13\u003c/sup\u003eCO J=2-1 line toward RU Lup\u003c/p\u003e\n\n\u003cp\u003eRULup_C18O.ms.contsub.tgz: Continuum-subtracted visibilities for the C\u003csup\u003e18\u003c/sup\u003eO J=2-1 line toward RU Lup\u003c/p\u003e\n\n\u003cp\u003eRULup_DCOp.ms.contsub.tgz: Continuum-subtracted visibilities for the\u0026nbsp; DCO\u003csup\u003e+\u003c/sup\u003e J=3-2 line toward RU Lup\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eImages: \u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eRULup12CO.1sigcut.pbcor.mom0.fits: Integrated intensity map of \u003csup\u003e12\u003c/sup\u003eCO J=2-1 appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULup12CO.pbcor.mom1.fits: \u003csup\u003e12\u003c/sup\u003eCO J=2-1 intensity-weighted velocity map appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULup13CO.pbcor.mom0.fits: Integrated intensity map of \u003csup\u003e13\u003c/sup\u003eCO J=2-1 appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULup13CO.pbcor.mom1.fits: \u003csup\u003e13\u003c/sup\u003eCO J=2-1 intensity-weighted velocity map appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULupC18O.pbcor.mom0.fits: Integrated intensity map of C\u003csup\u003e18\u003c/sup\u003eO J=2-1 appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULupC18O.pbcor.mom1.fits: C\u003csup\u003e18\u003c/sup\u003eO J=2-1 intensity-weighted velocity map appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULup12CO.image.pbcor.fits: \u003csup\u003e12\u003c/sup\u003eCO J=2-1 image cube appearing in Fig. 2\u003c/p\u003e\n\n\u003cp\u003eRULupC18O.image.pbcor.fits: C\u003csup\u003e18\u003c/sup\u003eO J=2-1 image cube appearing in Fig. 2\u003c/p\u003e\n\n\u003cp\u003eRULup13CO.image.pbcor.fits: \u003csup\u003e12\u003c/sup\u003eCO J=2-1 image cube appearing in Fig. 3\u003c/p\u003e\n\n\u003cp\u003eRULup_12COpeakintensity.fits: Peak intensity image of \u003csup\u003e12\u003c/sup\u003eCO used to make Figure 4\u003c/p\u003e\n\n\u003cp\u003eRULupDCOp.pbcor.mom0.fits: Integrated intensity map of DCO\u003csup\u003e+\u003c/sup\u003e J=3-2 appearing in Fig. 10\u003c/p\u003e\n\n\u003cp\u003eRULupDCOp.image.pbcor.fits: DCO\u003csup\u003e+\u003c/sup\u003e J=3-2 image cube appearing in Fig. 11\u003c/p\u003e\n\n\u003cp\u003eRULupallcontinuum.image.pbcor.fits: Continuum image appearing in Fig. 12\u003c/p\u003e\n\n\u003cp\u003eRULup12COinitial.mask.image.fits: \u003csup\u003e12\u003c/sup\u003eCO CLEAN mask shown in Fig. 13\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:3928862","title":"Data from \"Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup\""},"highlight":{"summary":["<p>Image cubes, self-calibrated visibilities, and self-calibration and imaging scripts for <span class=\"highlight\">data</span> from","accepted for publication by The Astrophysical Journal, arXiv:2007.02974&nbsp;</p>\n\n<p>The raw ALMA <span class=\"highlight\">data</span>","visibilities for &quot;RULupallcontinuum.image.pbcor.fits&quot; (the high-resolution ALMA continuum <span class=\"highlight\">data</span>"],"citation":["Jane Huang (2020): <span class=\"highlight\">Data</span> from \"Large-scale CO spirals and complex kinematics associated with the T Tauri"],"title.exact_value":["<span class=\"highlight\">Data from \"Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup\"</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span> from \"Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:2556767","_score":18.76409,"_source":{"citation":"Moldon, Javier, Ghirlanda, Giancarlo (2019): Data processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science. Zenodo. Dataset. https://zenodo.org/record/2556767","content_type":["Dataset"],"contributors":[{"affiliation":["The University of Manchester"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-8079-7608"],"value":"Moldon, Javier"},{"affiliation":["Instituto Nazionale di Astrofisica"],"kind":"Creator","value":"Ghirlanda, Giancarlo"},{"affiliation":["The University of Manchester"],"kind":"ContactPerson","identifier":["https://orcid.org/0000-0002-8079-7608"],"value":"Moldon, Javier"},{"affiliation":["Instituto Nazionale di Astrofisica"],"kind":"Researcher","value":"Ghirlanda, Giancarlo"}],"dates":[{"kind":"Publication date","value":"2019"},{"kind":"Issued","value":"2019-02-04"}],"edition":"1","format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.2556767"},{"kind":"url","value":"https://zenodo.org/record/2556767"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.2556766"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/2556767","subjects":[{"kind":"Subject scheme not provided","value":["interferometry"]},{"kind":"Subject scheme not provided","value":["radio"]},{"kind":"Subject scheme not provided","value":["e-MERLIN"]},{"kind":"Subject scheme not provided","value":["astronomy"]},{"kind":"Subject scheme not provided","value":["gravitational wave"]}],"summary":["\u003cp\u003eData processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e\n\n\u003cul\u003e\n\t\u003cli\u003einfo.txt contains a general description of how the data was processed and the main results.\u003c/li\u003e\n\t\u003cli\u003epipeline.tar contains the data pipeline used to process the e-MERLIN observations\u003c/li\u003e\n\t\u003cli\u003eimaging.py is the script used to produce the final images\u003c/li\u003e\n\t\u003cli\u003eCY6213_images.tar contain the final images of the target source (not corrected by calibration factor, described in the imaging script).\u003c/li\u003e\n\u003c/ul\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:2556767","title":"Data processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science"},"highlight":{"summary":["<p><span class=\"highlight\">Data</span> processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science","</p>\n\n<p>&nbsp;</p>\n\n<ul>\n\t<li>info.txt contains a general description of how the <span class=\"highlight\">data</span> was processed","</li>\n\t<li>pipeline.tar contains the <span class=\"highlight\">data</span> pipeline used to process the e-MERLIN observations</li>\n\t<li"],"citation":["Moldon, Javier, Ghirlanda, Giancarlo (2019): <span class=\"highlight\">Data</span> processing scripts and images from e-MERLIN project"],"title.exact_value":["<span class=\"highlight\">Data processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span> processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:6410045","_score":18.673622,"_source":{"citation":"Law, Charles John, Crystian, Sage, Teague, Richard, Öberg, Karin I., Rich, Evan A., Andrews, Sean M., Bae, Jaehan, Flaherty, Kevin, Guzmán, Viviana V., Huang, Jane, Ilee, John D., Kastner, Joel H., Loomis, Ryan A., Long, Feng, Pérez, Laura M., Pérez, Sebastián, Qi, Chunhua, Rosotti, Giovanni P., Ruíz-Rodríguez, Dary, Tsukagoshi, Takashi, Wilner, David J. (2022): Data from \"CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks\". Zenodo. Dataset. https://zenodo.org/record/6410045","content_type":["Dataset"],"contributors":[{"kind":"Creator","identifier":["https://orcid.org/0000-0003-1413-1776"],"value":"Law, Charles John"},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-1050-278X"],"value":"Crystian, Sage"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-1534-5186"],"value":"Teague, Richard"},{"kind":"Creator","identifier":["https://orcid.org/0000-0001-8798-1347"],"value":"Öberg, Karin I."},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-1779-8181"],"value":"Rich, Evan A."},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-2253-2270"],"value":"Andrews, Sean M."},{"kind":"Creator","identifier":["https://orcid.org/0000-0001-7258-770X"],"value":"Bae, Jaehan"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-2657-1314"],"value":"Flaherty, Kevin"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-4784-3040"],"value":"Guzmán, Viviana V."},{"kind":"Creator","identifier":["https://orcid.org/0000-0001-6947-6072"],"value":"Huang, Jane"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-1008-1142"],"value":"Ilee, John D."},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-3138-8250"],"value":"Kastner, Joel H."},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-8932-1219"],"value":"Loomis, Ryan A."},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-7607-719X"],"value":"Long, Feng"},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-1199-9564"],"value":"Pérez, Laura M."},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-2953-755X"],"value":"Pérez, Sebastián"},{"kind":"Creator","identifier":["https://orcid.org/0000-0001-8642-1786"],"value":"Qi, Chunhua"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-4853-5736"],"value":"Rosotti, Giovanni P."},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-3573-8163"],"value":"Ruíz-Rodríguez, Dary"},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-6034-2892"],"value":"Tsukagoshi, Takashi"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-1526-7587"],"value":"Wilner, David J."}],"dates":[{"kind":"Publication date","value":"2022"},{"kind":"Issued","value":"2022-04-03"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.6410045"},{"kind":"url","value":"https://zenodo.org/record/6410045"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.6410044"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/aas"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/6410045","subjects":[{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["Protoplanetary Disks"]},{"kind":"Subject scheme not provided","value":["CO Line Emission"]}],"summary":["\u003cp\u003eCO line emission image cubes (\u0026quot;[DISK]_CO_cube.fits\u0026quot;), line+continuum\u0026nbsp;image cubes (\u0026quot;[DISK]_CO_cube_wcont.fits\u0026quot;), and zeroth moment maps (\u0026quot;[DISK]_CO_M0.fits\u0026quot;) associated with Law et al., 2022, \u0026quot;CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks,\u0026quot;\u0026nbsp;The Astrophysical Journal\u003c/p\u003e\n\n\u003cp\u003eCO line emission image cubes from the DSHARP ALMA Large Program (for HD 142666, MY Lup, GW Lup, WaOph 6, DoAr 25) can be found at:\u0026nbsp;https://bulk.cv.nrao.edu/almadata/lp/DSHARP/ and are not included here.\u003c/p\u003e\n\n\u003cp\u003eThe raw data are available on the ALMA archive (see Table 1 in the paper for a\u0026nbsp;listing of the relevant\u0026nbsp;ALMA project codes).\u003c/p\u003e"],"timdex_record_id":"zenodo:6410045","title":"Data from \"CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks\""},"highlight":{"summary":["</p>\n\n<p>The raw <span class=\"highlight\">data</span> are available on the ALMA archive (see Table 1 in the paper for a&nbsp;listing"],"citation":["., Ruíz-Rodríguez, Dary, Tsukagoshi, Takashi, Wilner, David J. (2022): <span class=\"highlight\">Data</span> from \"CO Line Emission Surfaces"],"title.exact_value":["<span class=\"highlight\">Data from \"CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks\"</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span> from \"CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:4756381","_score":18.66253,"_source":{"citation":"Tazzari, Marco (2021): Data from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications for grain growth and radial drift\". Zenodo. Dataset. https://zenodo.org/record/4756381","content_type":["Dataset"],"contributors":[{"affiliation":["University of Cambridge"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-3590-5814"],"value":"Tazzari, Marco"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-06-21"}],"format":"electronic resource","funding_information":[{"award_number":"291227","award_uri":"info:eu-repo/grantAgreement/EC/FP7/291227/","funder_identifier":"10.13039/100011102","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"},{"award_number":"823823","award_uri":"info:eu-repo/grantAgreement/EC/H2020/823823/","funder_identifier":"10.13039/100010661","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"},{"award_number":"ST/S000623/1","award_uri":"info:eu-repo/grantAgreement/RCUK/STFC/ST%2FS000623%2F1/","funder_identifier":"10.13039/501100000690","funder_identifier_type":"Crossref Funder ID","funder_name":"Research Councils UK"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.4756381"},{"kind":"url","value":"https://zenodo.org/record/4756381"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsCompiledBy","uri":"arXiv:2010.02249"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.4756380"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/4756381","summary":["\u003cp\u003eTable 1, Table 2, and Table 3 from Tazzari et al., 2021,\u0026nbsp;\u0026quot;Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications for grain growth and radial drift\u0026quot;, Monthly Notices of the Royal Astronomical Society, arXiv:2010.02249\u003c/p\u003e\n\n\u003cp\u003eBoth tables are available in IPAC format, which is in human- and machine-readable:\u003c/p\u003e\n\n\u003cpre\u003e\u003ccode class=\"language-python\"\u003efrom astropy.io import ascii\ntb = ascii.read('Table1.txt', format='ipac')\u003c/code\u003e\u003c/pre\u003e\n\n\u003cp\u003eTable comments (stored at the beginning of the ASCII file as lines starting with \u0026quot;/\u0026quot;) can be read as:\u003c/p\u003e\n\n\u003cpre\u003e\u003ccode class=\"language-python\"\u003etb.meta['comments']\n\u003c/code\u003e\u003c/pre\u003e"],"timdex_record_id":"zenodo:4756381","title":"Data from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications for grain growth and radial drift\""},"highlight":{"citation":["Tazzari, Marco (2021): <span class=\"highlight\">Data</span> from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations"],"title.exact_value":["<span class=\"highlight\">Data from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span> from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:4756282","_score":18.584112,"_source":{"citation":"Marco Tazzari (2021): Data from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the Lupus region\". Zenodo. Dataset. https://zenodo.org/record/4756282","content_type":["Dataset"],"contributors":[{"affiliation":["University of Cambridge"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-3590-5814"],"value":"Marco Tazzari"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-05-13"}],"format":"electronic resource","funding_information":[{"award_number":"855130","award_uri":"info:eu-repo/grantAgreement/EC/Horizon 2020 Framework Programme - European Research Council - Synergy grant/855130/","funder_identifier":"10.13039/100010661","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"},{"award_number":"823823","award_uri":"info:eu-repo/grantAgreement/EC/H2020/823823/","funder_identifier":"10.13039/100010661","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"},{"award_number":"ST/S000623/1","award_uri":"info:eu-repo/grantAgreement/RCUK/STFC/ST%2FS000623%2F1/","funder_identifier":"10.13039/501100000690","funder_identifier_type":"Crossref Funder ID","funder_name":"Research Councils UK"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.4756282"},{"kind":"url","value":"https://zenodo.org/record/4756282"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsCompiledBy","uri":"arXiv:2010.02248"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.4756281"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/4756282","subjects":[{"kind":"Subject scheme not provided","value":["protoplanetary discs"]},{"kind":"Subject scheme not provided","value":["protoplanetary disks"]},{"kind":"Subject scheme not provided","value":["planet formation"]},{"kind":"Subject scheme not provided","value":["grain growth"]},{"kind":"Subject scheme not provided","value":["sub-mm/mm observations"]},{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["Lupus"]}],"summary":["\u003cp\u003eTable 1 and Table 2 from Tazzari et al., 2021, \u0026quot;The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the Lupus region\u0026quot;, Monthly Notices of the Royal Astronomical Society, arXiv:2010.02248\u003c/p\u003e\n\n\u003cp\u003eBoth tables are available in IPAC format, which is in human- and machine-readable:\u003c/p\u003e\n\n\u003cpre\u003e\u003ccode class=\"language-python\"\u003efrom astropy.io import ascii\ntb = ascii.read('Table1.txt', format='ipac')\u003c/code\u003e\u003c/pre\u003e\n\n\u003cp\u003eTable comments (stored at the beginning of the ASCII file as lines starting with \u0026quot;/\u0026quot;) can be read as:\u003c/p\u003e\n\n\u003cpre\u003e\u003ccode class=\"language-python\"\u003etb.meta['comments']\n\u003c/code\u003e\u003c/pre\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:4756282","title":"Data from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the Lupus region\""},"highlight":{"citation":["Marco Tazzari (2021): <span class=\"highlight\">Data</span> from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics"],"title.exact_value":["<span class=\"highlight\">Data from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span> from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:1241122","_score":18.209042,"_source":{"citation":"Archibald, Anne M., Gusinskaia, Nina V., Hessels, Jason W. T., Deller, Adam T., Kaplan, David L., Lorimer, Duncan R., Lynch, Ryan S., Ransom, Scott M., Stairs, Ingrid H. (2018): Data supporting \"Universality of Free Fall Shown by Orbital Motion of a Pulsar in a Stellar Triple System\". Zenodo. Dataset. https://zenodo.org/record/1241122","content_type":["Dataset"],"contributors":[{"affiliation":["Anton Pannekoek Institute"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-0638-3340"],"value":"Archibald, Anne M."},{"affiliation":["Anton Pannekoek Institute"],"kind":"Creator","value":"Gusinskaia, Nina V."},{"affiliation":["Anton Pannekoek Institute, ASTRON"],"kind":"Creator","value":"Hessels, Jason W. T."},{"affiliation":["Swinburne"],"kind":"Creator","value":"Deller, Adam T."},{"affiliation":["University of Wisconsin-Milwaukee"],"kind":"Creator","value":"Kaplan, David L."},{"affiliation":["West Virginia University, Center for Gravitational Waves and Cosmology"],"kind":"Creator","value":"Lorimer, Duncan R."},{"affiliation":["Green Bank Observatory, Center for Gravitational Waves and Cosmology"],"kind":"Creator","value":"Lynch, Ryan S."},{"affiliation":["National Radio Astronomy Observatory Charlottesville"],"kind":"Creator","value":"Ransom, Scott M."},{"affiliation":["University of British Columbia"],"kind":"Creator","value":"Stairs, Ingrid H."}],"dates":[{"kind":"Publication date","value":"2018"},{"kind":"Issued","value":"2018-07-01"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.1241122"},{"kind":"url","value":"https://zenodo.org/record/1241122"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.1241121"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by-sa/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/1241122","subjects":[{"kind":"Subject scheme not provided","value":["pulsar"]},{"kind":"Subject scheme not provided","value":["timing"]},{"kind":"Subject scheme not provided","value":["TOA"]},{"kind":"Subject scheme not provided","value":["gravity"]}],"summary":["\u003cp\u003eThis is a collection of data supporting the research paper \u0026quot;Orbital Motion of a Pulsar in a Stellar Triple System Shows Universality of Free Fall\u0026quot;.\u003c/p\u003e\n\n\u003cp\u003eThe main data content (the \u0026quot;.tim\u0026quot; file) is a set of pulse arrival times, the primary input to the fitting process, in tempo2 format. These times are annotated with post-fit residuals and derivatives with respect to fit parameters using the tempo2 format\u0026#39;s per-TOA flags.\u003c/p\u003e\n\n\u003cp\u003eAdditional files include the data that went into several figures, plus the above converted to CSV format - but note that the CSV format does not record the pulse arrival times with sufficient precision to permit fitting. Derivative and uncertainty information may permit reanalysis of the systematics.\u003c/p\u003e"],"timdex_record_id":"zenodo:1241122","title":"Data supporting \"Universality of Free Fall Shown by Orbital Motion of a Pulsar in a Stellar Triple System\""},"highlight":{"summary":["<p>This is a collection of <span class=\"highlight\">data</span> supporting the research paper &quot;Orbital Motion of a Pulsar in a Stellar","</p>\n\n<p>The main <span class=\"highlight\">data</span> content (the &quot;.tim&quot; file) is a set of pulse arrival times, the primary","</p>\n\n<p>Additional files include the <span class=\"highlight\">data</span> that went into several figures, plus the above converted to"],"citation":["., Stairs, Ingrid H. (2018): <span class=\"highlight\">Data</span> supporting \"Universality of Free Fall Shown by Orbital Motion of a"],"title.exact_value":["<span class=\"highlight\">Data supporting \"Universality of Free Fall Shown by Orbital Motion of a Pulsar in a Stellar Triple System</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"title":["<span class=\"highlight\">Data</span> supporting \"Universality of Free Fall Shown by Orbital Motion of a Pulsar in a Stellar Triple System"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5029530","_score":16.52032,"_source":{"citation":"Kshitij Aggarwal, Devansh Agarwal, Evan F Lewis, Reshma Anna-Thomas, Jacob Cardinal Tremblay, Sarah Burke-Spolaor, Maura McLaughlin, Duncan Lorimer (2021): Dataset corresponding to \"Comprehensive analysis of a dense sample of FRB 121102 bursts\". Zenodo. Dataset. https://zenodo.org/record/5029530","content_type":["Dataset"],"contributors":[{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-2059-0525"],"value":"Kshitij Aggarwal"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-0385-491X"],"value":"Devansh Agarwal"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-2972-522X"],"value":"Evan F Lewis"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-8057-0633"],"value":"Reshma Anna-Thomas"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-9852-6825"],"value":"Jacob Cardinal Tremblay"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-4052-7838"],"value":"Sarah Burke-Spolaor"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-7697-7422"],"value":"Maura McLaughlin"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-1301-966X"],"value":"Duncan Lorimer"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-06-24"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5029530"},{"kind":"url","value":"https://zenodo.org/record/5029530"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5029529"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5029530","subjects":[{"kind":"Subject scheme not provided","value":["Fast Radio Bursts"]},{"kind":"Subject scheme not provided","value":["Markov  Chain  Monte  Carlo"]},{"kind":"Subject scheme not provided","value":["Observational Astronomy"]},{"kind":"Subject scheme not provided","value":["Astronomy  data  analysis"]}],"summary":["\u003cp\u003eRaw dataset corresponding to publication: \u003ca href=\"https://ui.adsabs.harvard.edu/abs/2021arXiv210705658A/abstract\"\u003e\u0026quot;Comprehensive analysis of a dense sample of FRB 121102 bursts\u0026quot;\u003c/a\u003e. The dataset consists of raw filterbank format files from the two observations.\u003c/p\u003e"],"timdex_record_id":"zenodo:5029530","title":"Dataset corresponding to \"Comprehensive analysis of a dense sample of FRB 121102 bursts\""},"highlight":{"title.exact_value":["<span class=\"highlight\">Dataset corresponding to \"Comprehensive analysis of a dense sample of FRB 121102 bursts\"</span>"],"source":["<span class=\"highlight\">Zenodo</span>"],"subjects.value":["Astronomy  <span class=\"highlight\">data</span>  analysis"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5902893","_score":15.819018,"_source":{"citation":"Fiorenzo Stoppa, Paul Vreeswijk (2022): Dataset for: AutoSourceID-Light. Zenodo. Dataset. https://zenodo.org/record/5902893","content_type":["Dataset"],"contributors":[{"affiliation":["Radboud University"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-3424-8528"],"value":"Fiorenzo Stoppa"},{"affiliation":["Radboud University"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-7572-9088"],"value":"Paul Vreeswijk"}],"dates":[{"kind":"Publication date","value":"2022"},{"kind":"Issued","value":"2022-01-27"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5902893"},{"kind":"url","value":"https://zenodo.org/record/5902893"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5902892"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5902893","subjects":[{"kind":"Subject scheme not provided","value":["Machine learning"]},{"kind":"Subject scheme not provided","value":["Astronomy"]}],"summary":["\u003cp\u003eThis is the dataset used in the paper AutoSourceID-Light (\u003cstrong\u003e\u003ca href=\"https://arxiv.org/abs/2202.00489\"\u003eArXiv preperint\u003c/a\u003e\u003c/strong\u003e)\u0026nbsp;for Training, Test and Validation sets.\u0026nbsp;AutoSourceID-Light (ASID-L) is\u0026nbsp;an innovative framework that uses computer vision techniques that can naturally deal with large amounts of data and rapidly localize sources in optical images.\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003eThe dataset is made of\u0026nbsp;3 fields images taken with\u0026nbsp;the MeerLICHT telescope:\u0026nbsp;_20200601_191800_ (Omega Centauri globular cluster),\u0026nbsp;_20210401_173445_(Fornax galaxy cluster)\u0026nbsp;and\u0026nbsp;_20210910_022724_ (\u0026#39;empty\u0026#39; CDF-S).\u003c/p\u003e\n\n\u003cp\u003eFor each field, 2\u0026nbsp;files are provided: the optical image (_red_cosmics_nobkgsub.fits) and the catalog of EDR3 Gaia sources that match the location of the fields\u0026nbsp;(_GaiaEDR3_cat_SNR_redimage.fits).\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003eIf you use the dataset, please cite the appropriate DOIs.\u003c/p\u003e\n\n\u003cp\u003eCode available at\u0026nbsp;\u003ca href=\"https://github.com/FiorenSt/AutoSourceID-Light/tree/v0.0.2\"\u003e\u003cstrong\u003ehttps://github.com/FiorenSt/AutoSourceID-Light\u003c/strong\u003e\u003c/a\u003e\u0026nbsp; (\u003ca href=\"https://zenodo.org/record/6414546#.YkwoeihByUk\"\u003eZenodo repository\u003c/a\u003e)\u003c/p\u003e"],"timdex_record_id":"zenodo:5902893","title":"Dataset for: AutoSourceID-Light"},"highlight":{"summary":["innovative framework that uses computer vision techniques that can naturally deal with large amounts of <span class=\"highlight\">data</span>"],"title.exact_value":["<span class=\"highlight\">Dataset for: AutoSourceID-Light</span>"],"source":["<span class=\"highlight\">Zenodo</span>"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:6045394","_score":15.66041,"_source":{"citation":"Bate, Matthew R (2022): Dataset for Bate (2022): Dust coagulation during the early stages of star formation: molecular cloud collapse and first hydrostatic core evolution. Zenodo. Dataset. https://zenodo.org/record/6045394","content_type":["Dataset"],"contributors":[{"affiliation":["University of Exeter, UK"],"kind":"Creator","value":"Bate, Matthew R"}],"dates":[{"kind":"Publication date","value":"2022"},{"kind":"Issued","value":"2022-02-11"}],"format":"electronic resource","funding_information":[{"award_number":"339248","award_uri":"info:eu-repo/grantAgreement/EC/FP7/339248/","funder_identifier":"10.13039/100011102","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.6045394"},{"kind":"url","value":"https://zenodo.org/record/6045394"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.6045393"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/6045394","subjects":[{"kind":"Subject scheme not provided","value":["Astrophysics"]},{"kind":"Subject scheme not provided","value":["Dust"]},{"kind":"Subject scheme not provided","value":["Hydrodynamics"]},{"kind":"Subject scheme not provided","value":["Methods: Numerical"]},{"kind":"Subject scheme not provided","value":["Protoplanetary Discs"]},{"kind":"Subject scheme not provided","value":["Stars: Formation"]}],"summary":["\u003cp\u003eThis data set contains 6 smoothed particle hydrodynamics (SPH) dump files that were used to produce some of the figures in the journal paper:\u003c/p\u003e\n\n\u003cp\u003eBate, Matthew. R., 2022, Monthly Notices of the Royal Astronomical Society, submitted Feb 2022\u003c/p\u003e\n\n\u003cp\u003eEach of the SPH dump files is from a different calculation of the early stages of star formation: the gravitational collapse of a molecular cloud core, including dust coagulation. \u0026nbsp;Each SPH dump file gives the state of the SPH calculation when the maximum temperature reached 1500 K. \u0026nbsp;The calculations were each performed using 3 million SPH particles and differed by their initial rotation rate, which was parameterised by beta=0, 0.0025, 0.005, 0.01, 0.02, and 0.05 (the magnitude of the ratio of the rotational and gravitational potential energies). \u0026nbsp;The dump files associated with each calculation are:\u003c/p\u003e\n\n\u003cp\u003ebeta=0: \u0026nbsp; \u0026nbsp; \u0026nbsp;B1M0123\u003cbr\u003e\nbeta=0.0025: B1M2123\u003cbr\u003e\nbeta=0.005: \u0026nbsp;B1M5123\u003cbr\u003e\nbeta=0.01: \u0026nbsp; B1M1128\u003cbr\u003e\nbeta=0.02: \u0026nbsp; B1M2126\u003cbr\u003e\nbeta=0.05: \u0026nbsp; B1M5129\u003c/p\u003e\n\n\u003cp\u003eThe SPH dump files are Fortran binary files written in big endian format and generated by the sphNG code (Benz 1990;\u0026nbsp;Bate 1995; Bate \u0026amp; Keto 2015). They can be read, visualised, and manipulated using the free, publicly available SPLASH visualisation code (which reads sphNG dump files), written by Daniel J. Price, that can be downloaded from:\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003ehttp://users.monash.edu.au/~dprice/splash/\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003eThe SPLASH configuration files used to produce Figs. 9,10,11,and\u0026nbsp;B1 in Bate (2022) are included with this dataset in a gzipped tar file.\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:6045394","title":"Dataset for Bate (2022): Dust coagulation during the early stages of star formation: molecular cloud collapse and first hydrostatic core evolution"},"highlight":{"summary":["<p>This <span class=\"highlight\">data</span> set contains 6 smoothed particle hydrodynamics (SPH) dump files that were used to produce"],"title.exact_value":["<span class=\"highlight\">Dataset for Bate (2022): Dust coagulation during the early stages of star formation: molecular cloud </span>"],"source":["<span class=\"highlight\">Zenodo</span>"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:6547079","_score":15.5387,"_source":{"citation":"Bate, Matthew R (2022): Dataset for Bate (2022): Dust coagulation during the early stages of star formation: molecular cloud collapse and first hydrostatic core evolution. Zenodo. Dataset. https://zenodo.org/record/6547079","content_type":["Dataset"],"contributors":[{"affiliation":["University of Exeter, UK"],"kind":"Creator","value":"Bate, Matthew R"}],"dates":[{"kind":"Publication date","value":"2022"},{"kind":"Issued","value":"2022-05-13"}],"format":"electronic resource","funding_information":[{"award_number":"339248","award_uri":"info:eu-repo/grantAgreement/EC/FP7/339248/","funder_identifier":"10.13039/100011102","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.6547079"},{"kind":"url","value":"https://zenodo.org/record/6547079"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.6045393"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/6547079","subjects":[{"kind":"Subject scheme not provided","value":["Astrophysics"]},{"kind":"Subject scheme not provided","value":["Dust"]},{"kind":"Subject scheme not provided","value":["Hydrodynamics"]},{"kind":"Subject scheme not provided","value":["Methods: Numerical"]},{"kind":"Subject scheme not provided","value":["Protoplanetary Discs"]},{"kind":"Subject scheme not provided","value":["Stars: Formation"]}],"summary":["\u003cp\u003eThis data set contains 12\u0026nbsp;smoothed particle hydrodynamics (SPH) dump files that were used to produce some of the figures in the journal paper:\u003c/p\u003e\n\n\u003cp\u003eBate, Matthew. R., 2022, Monthly Notices of the Royal Astronomical Society, accepted 13 May\u0026nbsp;2022\u003c/p\u003e\n\n\u003cp\u003eEach of the SPH dump files is from a different calculation of the early stages of star formation: the gravitational collapse of a molecular cloud core, including dust coagulation. \u0026nbsp;Each SPH dump file gives the state of the SPH calculation when the maximum temperature reached 1500 K, except for the beta=0.05 cases which give the state when the maximum hydrogen number density reaches 10^{14} cm^{-3}. \u0026nbsp;The calculations were each performed using 3 million SPH particles and differed by their initial rotation rate, which was parameterised by beta=0, 0.0025, 0.005, 0.01, 0.02, and 0.05 (the magnitude of the ratio of the rotational and gravitational potential energies). \u0026nbsp;Dump files from calculations that include and exclude envelope turbulence are provided (both are used for Figure B1). \u0026nbsp;The dump files associated with each calculation are:\u003c/p\u003e\n\n\u003cp\u003ebeta=0: \u0026nbsp; \u0026nbsp; \u0026nbsp;B1M0123\u0026nbsp;(does not include envelope turbulence)\u003cbr\u003e\nbeta=0.0025: B1M2123\u0026nbsp;(does not include envelope turbulence)\u003cbr\u003e\nbeta=0.005: \u0026nbsp;B1M5123\u0026nbsp;(does not include envelope turbulence)\u003cbr\u003e\nbeta=0.01: \u0026nbsp; B1M1128\u0026nbsp;(does not include envelope turbulence)\u003cbr\u003e\nbeta=0.02: \u0026nbsp; B1M2126\u0026nbsp;(does not include envelope turbulence)\u003cbr\u003e\nbeta=0.05: \u0026nbsp; B1M5109_b05_NoEnvTurb\u0026nbsp;(does not include envelope turbulence)\u003c/p\u003e\n\n\u003cp\u003ebeta=0.0: \u0026nbsp; \u0026nbsp;B1M0123_b0_EnvTurb\u003cbr\u003e\nbeta=0.0025: B1M2177_b0025_EnvTurb\u003cbr\u003e\nbeta=0.005: \u0026nbsp;B1M5209_b005_EnvTurb\u003cbr\u003e\nbeta=0.01: \u0026nbsp; B1M1219_b01_EnvTurb\u003cbr\u003e\nbeta=0.02: \u0026nbsp; B1M2221_b02_EnvTurb\u003cbr\u003e\nbeta=0.05: \u0026nbsp; B1M5321_b05_EnvTurb\u003c/p\u003e\n\n\u003cp\u003eThe SPH dump files are Fortran binary files written in big endian format and generated by the sphNG code (Benz 1990;\u0026nbsp;Bate 1995; Bate \u0026amp; Keto 2015). They can be read, visualised, and manipulated using the free, publicly available SPLASH visualisation code (which reads sphNG dump files), written by Daniel J. Price, that can be downloaded from:\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003ehttp://users.monash.edu.au/~dprice/splash/\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003eThe SPLASH configuration files used to produce Figs. 10,11,12,and\u0026nbsp;B1 in Bate (2022) are included with this dataset in a gzipped tar file.\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:6547079","title":"Dataset for Bate (2022): Dust coagulation during the early stages of star formation: molecular cloud collapse and first hydrostatic core evolution"},"highlight":{"summary":["<p>This <span class=\"highlight\">data</span> set contains 12&nbsp;smoothed particle hydrodynamics (SPH) dump files that were used to"],"title.exact_value":["<span class=\"highlight\">Dataset for Bate (2022): Dust coagulation during the early stages of star formation: molecular cloud </span>"],"source":["<span class=\"highlight\">Zenodo</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-44968","_score":10.432909,"_source":{"citation":"Stoker, Thomas M. (2000): Panel data analysis of U.S. coal productivity. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/44968","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Stoker, Thomas M."},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"2000"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/44968"},{"kind":"oclc","value":"52315985"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/44968"}],"numbering":"MIT-CEEPR (Series) ; 00-004WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/44968","summary":["We analyze labor productivity in coal mining in the United States using indices of productivity change associated with the concepts of panel data modeling. This approach is valuable when there is extensive heterogeneity in production units, as with coal mines. We find substantial returns to scale for coal mining in all geographical regions, and find that smooth technical progress is exhibited by estimates of the fixed effects for coal mining. We carry out a variety of diagnostic analyses of our basic model and primary modeling assumptions, using recently proposed methods for addressing 'errors-in-variable' and 'weak instrument bias' problems, as well a new method for studying errors-in-variables in nonlinear contexts."],"timdex_record_id":"dspace:1721.1-44968","title":"Panel data analysis of U.S. coal productivity"},"highlight":{"summary":["mining in the United States using indices of productivity change associated with the concepts of panel <span class=\"highlight\">data</span>"],"citation":["Stoker, Thomas M. (2000): Panel <span class=\"highlight\">data</span> analysis of U.S. coal productivity."],"source":["<span class=\"highlight\">DSpace@MIT</span>"],"title":["Panel <span class=\"highlight\">data</span> analysis of U.S. coal productivity"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-44986","_score":7.744748,"_source":{"citation":"Gupta, Shreekant (2002): Environmental benefits and cost savings through market-based instruments : an application using state-level data from India. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/44986","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Gupta, Shreekant"},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"2002"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/44986"},{"kind":"oclc","value":"52305223"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/44986"}],"numbering":"MIT-CEEPR (Series) ; 02-005WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/44986","summary":["This paper develops a methodology for estimating potential cost savings from the use of market-based instruments (MBIs) when local emissions and abatement cost data are not available. The paper provides estimates of the cost savings for a 50% reduction of particulate emissions in India's five main industrial states, as well as estimates of the benefits from doing so. The estimates are developed by applying World Bank particulate intensity and abatement cost factors to sectoral output data. The estimated costs savings range from 26% to 169% and the benefits are many times greater than the costs even without the use of MBIs. The paper concludes by commenting on the relative difficulty of implementing reductions by market-based instruments and conventional command-and-control regulations."],"timdex_record_id":"dspace:1721.1-44986","title":"Environmental benefits and cost savings through market-based instruments : an application using state-level data from India"},"highlight":{"summary":["cost savings from the use of market-based instruments (MBIs) when local emissions and abatement cost <span class=\"highlight\">data</span>","developed by applying World Bank particulate intensity and abatement cost factors to sectoral output <span class=\"highlight\">data</span>"],"citation":["Environmental benefits and cost savings through market-based instruments : an application using state-level <span class=\"highlight\">data</span>"],"source":["<span class=\"highlight\">DSpace@MIT</span>"],"title":["Environmental benefits and cost savings through market-based instruments : an application using state-level <span class=\"highlight\">data</span>"]}}]},"aggregations":{"languages":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"en","doc_count":83},{"key":"en_us","doc_count":14},{"key":"el","doc_count":1},{"key":"fr","doc_count":1}]},"content_type":{"doc_count_error_upper_bound":0,"sum_other_doc_count":1,"buckets":[{"key":"dataset","doc_count":119},{"key":"working paper","doc_count":70},{"key":"software","doc_count":58},{"key":"text","doc_count":36},{"key":"journalarticle","doc_count":9},{"key":"conferencepaper","doc_count":6},{"key":"other","doc_count":5},{"key":"image","doc_count":3},{"key":"preprint","doc_count":3},{"key":"report","doc_count":2}]},"collections":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[]},"subjects":{"doc_count":734,"subject_names":{"doc_count_error_upper_bound":4,"sum_other_doc_count":611,"buckets":[{"key":"astronomy","doc_count":46},{"key":"radio astronomy","doc_count":13},{"key":"astrophysics","doc_count":10},{"key":"idl","doc_count":10},{"key":"machine learning","doc_count":9},{"key":"python","doc_count":8},{"key":"wolf-rayet","doc_count":8},{"key":"data visualisation","doc_count":7},{"key":"hydrodynamics","doc_count":7},{"key":"ism","doc_count":7}]}},"content_format":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"electronic resource","doc_count":312}]},"literary_form":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[]},"source":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"zenodo","doc_count":242},{"key":"dspace@mit","doc_count":70}]},"contributors":{"doc_count":1322,"contributor_names":{"doc_count_error_upper_bound":4,"sum_other_doc_count":1207,"buckets":[{"key":"massachusetts institute of technology. center for energy and environmental policy research.","doc_count":46},{"key":"danehkar, ashkbiz","doc_count":17},{"key":"adelman, morris albert","doc_count":7},{"key":"angus comrie","doc_count":7},{"key":"ellerman, a. denny","doc_count":7},{"key":"pindyck, robert s.","doc_count":7},{"key":"adrianna pińska","doc_count":6},{"key":"anthony moraghan","doc_count":6},{"key":"cheng-chin chiang","doc_count":6},{"key":"hengtai jan","doc_count":6}]}}}} + recorded_at: Wed, 06 Jul 2022 15:35:56 GMT +recorded_with: VCR 6.1.0 diff --git a/test/vcr_cassettes/graphql_v2_filter_single_source.yml b/test/vcr_cassettes/graphql_v2_filter_single_source.yml new file mode 100644 index 0000000..62579fb --- /dev/null +++ b/test/vcr_cassettes/graphql_v2_filter_single_source.yml @@ -0,0 +1,108 @@ +--- +http_interactions: +- request: + method: get + uri: http://localhost:9200/ + body: + encoding: US-ASCII + string: '' + headers: + User-Agent: + - 'opensearch-ruby/2.0.0 (RUBY_VERSION: 2.7.6; darwin x86_64; Faraday v1.10.0)' + Content-Type: + - application/json + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=UTF-8 + Content-Length: + - '350' + body: + encoding: ASCII-8BIT + string: | + { + "name" : "aa481ae9e939", + "cluster_name" : "docker-cluster", + "cluster_uuid" : "ktiriADZSI2Vohg8EZdVfA", + "version" : { + "distribution" : "opensearch", + "number" : "1.3.0", + "build_type" : "tar", + "build_hash" : "e45991597c86ba1bbcc36ee1dfdc165197a913af", + "build_date" : "2022-03-15T19:07:30.455415Z", + "build_snapshot" : false, + "lucene_version" : "8.10.1", + "minimum_wire_compatibility_version" : "6.8.0", + "minimum_index_compatibility_version" : "6.0.0-beta1" + }, + "tagline" : "The OpenSearch Project: https://opensearch.org/" + } + recorded_at: Wed, 06 Jul 2022 15:49:13 GMT +- request: + method: post + uri: http://localhost:9200/timdex-prod/_search + body: + encoding: UTF-8 + string: '{"from":"0","size":20,"query":{"bool":{"should":[{"prefix":{"title.exact_value":{"value":"data","boost":15.0}}},{"term":{"title":{"value":"data","boost":1.0}}},{"nested":{"path":"contributors","query":{"term":{"contributors.value":{"value":"data","boost":0.1}}}}}],"must":[{"multi_match":{"query":"data"}}],"filter":[]}},"highlight":{"pre_tags":["\u003cspan + class=\"highlight\"\u003e"],"post_tags":["\u003c/span\u003e"],"fields":{"*":{}}},"aggregations":{"collections":{"terms":{"field":"collections.keyword"}},"contributors":{"nested":{"path":"contributors"},"aggs":{"contributor_names":{"terms":{"field":"contributors.value.keyword"}}}},"content_type":{"terms":{"field":"content_type"}},"content_format":{"terms":{"field":"format"}},"languages":{"terms":{"field":"languages.keyword"}},"literary_form":{"terms":{"field":"literary_form"}},"source":{"terms":{"field":"source"}},"subjects":{"nested":{"path":"subjects"},"aggs":{"subject_names":{"terms":{"field":"subjects.value.keyword"}}}}}}' + headers: + User-Agent: + - 'opensearch-ruby/2.0.0 (RUBY_VERSION: 2.7.6; darwin x86_64; Faraday v1.10.0)' + Content-Type: + - application/json + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=UTF-8 + Content-Length: + - '17634' + body: + encoding: ASCII-8BIT + string: !binary |- + {"took":56,"timed_out":false,"_shards":{"total":4,"successful":4,"skipped":0,"failed":0},"hits":{"total":{"value":557,"relation":"eq"},"max_score":20.448364,"hits":[{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5728409","_score":20.448364,"_source":{"citation":"Stevens, Abigail (2021): Data for time series tutorial. Zenodo. Dataset. https://zenodo.org/record/5728409","content_type":["Dataset"],"contributors":[{"affiliation":["Michigan State Univ. and Univ. of Michigan"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-5041-3079"],"value":"Stevens, Abigail"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-11-25"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5728409"},{"kind":"url","value":"https://zenodo.org/record/5728409"}],"languages":["en"],"notes":[{"kind":"Other","value":["{\"references\": [\"Wilson-Hodge, C. et al. (2018). \\\"NICER and Fermi GBM Observations of the First Galactic Ultraluminous X-Ray Pulsar Swift J0243.6+6124,\\\" ApJ, 863, 9.\", \"Stevens, A.L. et al. (2018). \\\" A NICER Discovery of a Low-frequency Quasi-periodic Oscillation in the Soft-intermediate State of MAXI J1535-571,\\\" ApJ, 865, L15.\"]}"]}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5728408"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5728409","subjects":[{"kind":"Subject scheme not provided","value":["astronomy"]}],"summary":["\u003cp\u003eThese are sample data files to be used in the time series tutorial found here: \u003ca href=\"https://github.com/abigailStev/timeseries-tutorial\"\u003ehttps://github.com/abigailStev/timeseries-tutorial \u003c/a\u003e\u003c/p\u003e\n\n\u003cp\u003eThey are public datasets from the NICER X-ray Timing Instrument of a black hole, MAXI J1535-571, and a neutron star, Swift J0243.6+6124. There are also Good Time Intervals I created for each of the photon event lists.\u003c/p\u003e"],"timdex_record_id":"zenodo:5728409","title":"Data for time series tutorial"},"highlight":{"summary":["<p>These are sample <span class=\"highlight\">data</span> files to be used in the time series tutorial found here: <a href=\"https://github.com"],"citation":["Stevens, Abigail (2021): <span class=\"highlight\">Data</span> for time series tutorial. Zenodo."],"title.exact_value":["<span class=\"highlight\">Data for time series tutorial</span>"],"title":["<span class=\"highlight\">Data</span> for time series tutorial"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:3242151","_score":19.489151,"_source":{"citation":"Deacon, Niall R, Henning, Thomas, Kossakowski, Diana E. (2019): Data-driven stellar parameters for southern TESS FGK targets. Zenodo. JournalArticle. https://zenodo.org/record/3242151","content_type":["JournalArticle"],"contributors":[{"affiliation":["MPIA"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-2440-7350"],"value":"Deacon, Niall R"},{"affiliation":["MPIA"],"kind":"Creator","value":"Henning, Thomas"},{"affiliation":["MPIA"],"kind":"Creator","value":"Kossakowski, Diana E."}],"dates":[{"kind":"Publication date","value":"2019"},{"kind":"Issued","value":"2019-06-09"}],"edition":"1.0","format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.3242151"},{"kind":"url","value":"https://zenodo.org/record/3242151"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.3242150"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/3242151","subjects":[{"kind":"Subject scheme not provided","value":["astronomy, exoplanet, tess, stellar parameters"]}],"summary":["\u003cp\u003ePresented here are the extended tables for Deacon et al. (2019)\u003c/p\u003e\n\n\u003cp\u003eTable3: This table presents stellar parameters for southern FGK stars that are likely high priority targets for the TESS mission. The parameters are presented in the same way as in the tables in the paper with the exception of several additional flags.\u003cbr\u003e\n\u003cbr\u003e\nfeh_flag - set if an object has an estimated Fe/H value of \u0026gt;0.55. This normally indicates the code is hitting the edge of the metallicity grid and likely means the object cannot be well described by our model rather than it being extremely high metallicity\u003cbr\u003e\n\u003cbr\u003e\nTable A1: A compilation of Gaia astrometry for TESS targets is presented as described in the paper\u003cbr\u003e\n\u003cbr\u003e\nfeh_not_measured_flag - set when we do not have Skymapper u or v data and thus cannot reliably estimate an objects metallicity. In these cases Fe/H is set to -1, the typical value in the solar neighbourhood\u003cbr\u003e\n\u003cbr\u003e\nav_lim_flag - set if we do not find a statistically significant constrain on the star\u0026#39;s extinction. In this case we quote an upper limit based on other studies (this is detailed further in the paper)\u003cbr\u003e\n\u003cbr\u003e\nteff_flag - indicates that the best-fitting effective temperature value fell outside our grid. Thus we quote either the lower limit (7000K) or the upper limit (4600K for dwarfs, 4000K for giants). For such objects all other parameters are set to null values (-99.9 for all parameters except extinction which is set to 99.9)\u003cbr\u003e\n\u003cbr\u003e\nteff_lower_lim_flag - set if the lower limit of our T_eff confidence bound falls outside the range of our training sample.\u003cbr\u003e\n\u003cbr\u003e\nteff_upper_lim_flag - set if the upper limit of our T_eff confidence bound falls outside the range of our training sample.\u003cbr\u003e\n\u003cbr\u003e\n\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:3242151","title":"Data-driven stellar parameters for southern TESS FGK targets"},"highlight":{"summary":["as described in the paper<br>\n<br>\nfeh_not_measured_flag - set when we do not have Skymapper u or v <span class=\"highlight\">data</span>"],"citation":["Deacon, Niall R, Henning, Thomas, Kossakowski, Diana E. (2019): <span class=\"highlight\">Data</span>-driven stellar parameters for southern"],"title.exact_value":["<span class=\"highlight\">Data-driven stellar parameters for southern TESS FGK targets</span>"],"title":["<span class=\"highlight\">Data</span>-driven stellar parameters for southern TESS FGK targets"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5727583","_score":19.343845,"_source":{"citation":"Taubenberger Stefan (2021): Data for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae\". Zenodo. Dataset. https://zenodo.org/record/5727583","content_type":["Dataset"],"contributors":[{"affiliation":["Max-Planck-Institut für Astrophysik"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-4265-1958"],"value":"Taubenberger Stefan"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-11-25"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5727583"},{"kind":"url","value":"https://zenodo.org/record/5727583"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsSupplementTo","uri":"https://doi.org/10.1007/978-3-319-21846-5_37"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5727582"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5727583","subjects":[{"kind":"Subject scheme not provided","value":["supernovae"]},{"kind":"Subject scheme not provided","value":["thermonuclear"]}],"summary":["\u003cp\u003eData needed to recreate Figure 1 of Taubenberger\u0026nbsp; S., \u003ca href=\"https://ui.adsabs.harvard.edu/abs/2017hsn..book..317T/abstract\"\u003e\u0026quot;The Extremes of Thermonuclear Supernovae\u0026quot;\u003c/a\u003e, in\u0026nbsp;A. W. Alsabti, P. Murdin, eds., \u0026ldquo;Handbook of Supernovae\u0026rdquo;, Springer, ISBN: 978-3-319-20794-0 (2017). A detailed README is included.\u003c/p\u003e"],"timdex_record_id":"zenodo:5727583","title":"Data for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae\""},"highlight":{"summary":["<p><span class=\"highlight\">Data</span> needed to recreate Figure 1 of Taubenberger&nbsp; S., <a href=\"https://ui.adsabs.harvard.edu/"],"citation":["Taubenberger Stefan (2021): <span class=\"highlight\">Data</span> for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae"],"title.exact_value":["<span class=\"highlight\">Data for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae\"</span>"],"title":["<span class=\"highlight\">Data</span> for Figure 1 of Taubenberger 2017, \"The Extremes of Thermonuclear Supernovae\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:3820679","_score":19.08733,"_source":{"citation":"Martínez-Palomera, Jorge, Bloom, Joshua S., Abrahams, Ellianna S. (2020): Data from: \"Deep Generative Modeling of Periodic Variable Stars Using Physical Parameters\". Zenodo. Dataset. https://zenodo.org/record/3820679","content_type":["Dataset"],"contributors":[{"affiliation":["University of California Berkeley"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-7395-4935"],"value":"Martínez-Palomera, Jorge"},{"affiliation":["University of California Berkeley"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-7777-216X"],"value":"Bloom, Joshua S."},{"affiliation":["University of California Berkeley"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-9879-1183"],"value":"Abrahams, Ellianna S."}],"dates":[{"kind":"Publication date","value":"2020"},{"kind":"Issued","value":"2020-05-20"}],"edition":"0.1","format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.3820679"},{"kind":"url","value":"https://zenodo.org/record/3820679"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsSupplementTo","uri":"arXiv:2005.07773"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.3820678"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/3820679","subjects":[{"kind":"Subject scheme not provided","value":["periodic variables"]},{"kind":"Subject scheme not provided","value":["light curves"]},{"kind":"Subject scheme not provided","value":["cross-matching validation"]},{"kind":"Subject scheme not provided","value":["ogle3"]},{"kind":"Subject scheme not provided","value":["gaia-dr2"]},{"kind":"Subject scheme not provided","value":["variational autoencoder"]},{"kind":"Subject scheme not provided","value":["generative models"]}],"summary":["\u003cp\u003eThis dataset was used for the training of a conditioned Variational Autoencoder that generates physically informed light curves of periodic variable stars. The light curves correspond to data obtained from The Optical Gravitational Lensing Experiment (\u003ca href=\"https://ui.adsabs.harvard.edu/abs/1992AcA....42..253U/abstract\"\u003eOGLE\u003c/a\u003e), while ancillary information was obtained from the Gaia Data Release 2 (\u003ca href=\"https://ui.adsabs.harvard.edu/link_gateway/2016A\u0026amp;A...595A...1G/doi:10.1051/0004-6361/201629272\"\u003eGAIA DR2\u003c/a\u003e). This repository contains the preprocessed OGLE light curves and the GAIA measurements corresponding to each cross-matched source. We also provided a subsample of cross-matched sources that were carefully validated following several steps described in the companion article (paper reference).\u003c/p\u003e\n\n\u003cp\u003eThis dataset is realized in tandem with the corresponding\u0026nbsp;\u003ca href=\"https://github.com/jorgemarpa/PELS-VAE\"\u003eGitHub\u003c/a\u003e\u0026nbsp;and\u0026nbsp;\u003ca href=\"https://arxiv.org/abs/2005.07773\"\u003earticle\u003c/a\u003e.\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:3820679","title":"Data from: \"Deep Generative Modeling of Periodic Variable Stars Using Physical Parameters\""},"highlight":{"summary":["The light curves correspond to <span class=\"highlight\">data</span> obtained from The Optical Gravitational Lensing Experiment (<a href","abs/1992AcA....42..253U/abstract\">OGLE</a>), while ancillary information was obtained from the Gaia <span class=\"highlight\">Data</span>"],"citation":["., Abrahams, Ellianna S. (2020): <span class=\"highlight\">Data</span> from: \"Deep Generative Modeling of Periodic Variable Stars Using"],"title.exact_value":["<span class=\"highlight\">Data from: \"Deep Generative Modeling of Periodic Variable Stars Using Physical Parameters\"</span>"],"title":["<span class=\"highlight\">Data</span> from: \"Deep Generative Modeling of Periodic Variable Stars Using Physical Parameters\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:3628656","_score":19.01915,"_source":{"citation":"Huang, Jane (2020): Data from  \"A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk\". Zenodo. Dataset. https://zenodo.org/record/3628656","content_type":["Dataset"],"contributors":[{"affiliation":["Center for Astrophysics | Harvard \u0026 Smithsonian"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-6947-6072"],"value":"Huang, Jane"}],"dates":[{"kind":"Publication date","value":"2020"},{"kind":"Issued","value":"2020-01-29"}],"edition":"1","format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.3628656"},{"kind":"url","value":"https://zenodo.org/record/3628656"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.3628655"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/3628656","subjects":[{"kind":"Subject scheme not provided","value":["GM Aur"]},{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["Protoplanetary disks"]}],"summary":["\u003cp\u003eImage cubes, self-calibrated visibilities, and self-calibration and imaging scripts for data associated with Huang et al., 2020, \u0026quot;A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk,\u0026quot; The Astrophysical Journal, 891, 48,\u0026nbsp;arXiv:2001.11040\u003c/p\u003e\n\n\u003cp\u003eThe raw data are available on the ALMA archive under program IDs\u0026nbsp;2017.1.01151.S and\u0026nbsp;2018.1.01230.S (PI: Jane Huang).\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eScripts:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003ereduction_utils.py: Set of helper functions for self-calibration scripts\u003c/p\u003e\n\n\u003cp\u003eB4continuumreduction.py: Self-calibration and imaging script for Band 4\u0026nbsp;(2.1 mm) continuum (GMAurB4continuumfinal.image.fits) from GMAurB4continuum.final.ms.tgz\u003c/p\u003e\n\n\u003cp\u003eB6continuumreduction.py: Self-calibration and imaging script for Band 6 (1.1 mm) continuum (GMAurB6continuumfinal.image.fits) from GMAurB6continuum.final.ms.tgz\u003c/p\u003e\n\n\u003cp\u003eHCOp_imaging.py: Script producing GMAur_HCOp_continuumsubtracted.image.fits and GMAur_HCOp_withcontinuum.image.fits from GMAurB6_HCOp.ms.contsub.cvel and GMAurB6_HCOp.ms.cvel, respectively\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eMeasurement sets:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eGMAurB4continuumfinal.ms.tgz: Self-calibrated 2.1 mm continuum visibilities for GM Aur\u003c/p\u003e\n\n\u003cp\u003eGMAurB6continuumfinal.ms.tgz: Self-calibrated 1.1 mm continuum visibilities for GM Aur\u003c/p\u003e\n\n\u003cp\u003eGMAurB6_HCOp.ms.cvel.tgz: Self-calibrated HCO\u003csup\u003e+\u0026nbsp;\u003c/sup\u003e3-2 visibilities\u0026nbsp;without continuum subtraction\u003c/p\u003e\n\n\u003cp\u003eGMAurB6_HCOp.ms.contsub.cvel.tgz: Self-calibrated HCO\u003csup\u003e+\u0026nbsp;\u003c/sup\u003e3-2 visibilities\u0026nbsp;with\u0026nbsp;continuum subtraction\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eImages:\u0026nbsp;\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eGMAurB6continuumfinal.image.fits: 1.1 mm continuum image of GM Aur\u003c/p\u003e\n\n\u003cp\u003eGMAurB4continuumfinal.image.fits: 2.1 mm continuum image of GM Aur\u003c/p\u003e\n\n\u003cp\u003eGMAur_HCOp_withcontinuum.image.fits: HCO\u003csup\u003e+\u0026nbsp;\u003c/sup\u003e3-2 image cube toward GM Aur without continuum subtraction\u003c/p\u003e\n\n\u003cp\u003eGMAur_HCOp_continuumsubtracted.image.fits:\u0026nbsp;HCO\u003csup\u003e+\u0026nbsp;\u003c/sup\u003e3-2 image cube toward GM Aur with\u0026nbsp;continuum subtraction\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:3628656","title":"Data from  \"A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk\""},"highlight":{"summary":["<p>Image cubes, self-calibrated visibilities, and self-calibration and imaging scripts for <span class=\"highlight\">data</span> associated","protoplanetary disk,&quot; The Astrophysical Journal, 891, 48,&nbsp;arXiv:2001.11040</p>\n\n<p>The raw <span class=\"highlight\">data</span>"],"citation":["Huang, Jane (2020): <span class=\"highlight\">Data</span> from  \"A multi-frequency ALMA characterization of substructures in the GM Aur"],"title.exact_value":["<span class=\"highlight\">Data from  \"A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk</span>"],"title":["<span class=\"highlight\">Data</span> from  \"A multi-frequency ALMA characterization of substructures in the GM Aur protoplanetary disk"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:4454165","_score":18.887436,"_source":{"citation":"Law, Charles John (2021): Data from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6-0.4\". Zenodo. Dataset. https://zenodo.org/record/4454165","content_type":["Dataset"],"contributors":[{"affiliation":["Center for Astrophysics | Harvard \u0026 Smithsonian"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-1413-1776"],"value":"Law, Charles John"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-01-21"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.4454165"},{"kind":"url","value":"https://zenodo.org/record/4454165"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.4454164"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/aas"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/4454165","subjects":[{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["Complex organic molecules"]},{"kind":"Subject scheme not provided","value":["Massive star formation"]}],"summary":["\u003cp\u003eNon-continuum-subtracted\u0026nbsp;spectral line image cubes associated with Law et al., 2021, \u0026quot;Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6-0.4,\u0026quot;\u0026nbsp;The Astrophysical Journal [arXiv:2101.07801].\u003c/p\u003e\n\n\u003cp\u003eThe raw data are available on the ALMA archive under program ID\u0026nbsp;2015.1.00106.S (PI: Qizhou\u0026nbsp;Zhang).\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eDatasets:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eG10_6_spw25.fits: Image cube from ~233-235 GHz\u003c/p\u003e\n\n\u003cp\u003eG10_6_spw27.fits: Image cube from ~231-233\u0026nbsp;GHz\u003c/p\u003e\n\n\u003cp\u003eG10_6_spw29.fits: Image cube from ~219-221\u0026nbsp;GHz\u003c/p\u003e\n\n\u003cp\u003eG10_6_spw31.fits: Image cube from ~217-219\u0026nbsp;GHz\u003c/p\u003e"],"timdex_record_id":"zenodo:4454165","title":"Data from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6-0.4\""},"highlight":{"summary":["</p>\n\n<p>The raw <span class=\"highlight\">data</span> are available on the ALMA archive under program ID&nbsp;2015.1.00106.S (PI: Qizhou"],"citation":["Law, Charles John (2021): <span class=\"highlight\">Data</span> from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive"],"title.exact_value":["<span class=\"highlight\">Data from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6</span>"],"title":["<span class=\"highlight\">Data</span> from \"Subarcsecond Imaging of the Complex Organic Chemistry in Massive Star-forming Region G10.6"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:6542596","_score":18.850346,"_source":{"citation":"Heimersheim, Stefan, Sartorio, Nina S., Fialkov, Anastasia, Lorimer, Duncan R. (2022): Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\". Zenodo. Software. https://zenodo.org/record/6542596","content_type":["Software"],"contributors":[{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-9631-4212"],"value":"Heimersheim, Stefan"},{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-2138-5192"],"value":"Sartorio, Nina S."},{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK; Kavli Institute for Cosmology, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-1369-633X"],"value":"Fialkov, Anastasia"},{"affiliation":["West Virginia University, Department of Physics and Astronomy, P. O. Box 6315, Morgantown, WV, USA; Center for Gravitational Waves and Cosmology, West Virginia University, Chestnut Ridge Research Building, Morgantown, WV, USA"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-1301-966X"],"value":"Lorimer, Duncan R."}],"dates":[{"kind":"Publication date","value":"2022"},{"kind":"Issued","value":"2022-05-14"}],"format":"electronic resource","funding_information":[{"award_number":"1430284","award_uri":"info:eu-repo/grantAgreement/NSF/Directorate+for+Mathematical+%26+Physical+Sciences/1430284/","funder_identifier":"10.13039/100000001","funder_identifier_type":"Crossref Funder ID","funder_name":"National Science Foundation"},{"award_number":"1458952","award_uri":"info:eu-repo/grantAgreement/NSF//1458952/","funder_identifier":"10.13039/100000001","funder_identifier_type":"Crossref Funder ID","funder_name":"National Science Foundation"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.6542596"},{"kind":"url","value":"https://zenodo.org/record/6542596"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsSupplementTo","uri":"https://arxiv.org/abs/2107.14242"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5504050"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/6542596","summary":["\u003cp\u003eThis upload contains the data and code used for our Fast Radio Burst forecast, constraining reionization and cosmological parameters (\u003ca href=\"https://arxiv.org/abs/2107.14242\"\u003earXiv:2107.14242\u003c/a\u003e). The data includes both, the generated synthetic observations, as well as the Nested Sampling chains used to produce the results and figures.\u003c/p\u003e\n\n\u003cp\u003eThe minimal set to run the analysis (FlexKnotFRB-small) takes up 6.5 GB (uncompressed) of disk space and can be used to reproduce everything except the high-resolution version of Figure 3. (That version can also be reproduce but would take ~24h.) The full set (FlexKnotFRB-full) takes 31 GB and contains pre-computed cache files allowing to regenerate all paper plots quickly (\u0026lt;\u0026lt;1h). Finally the extra chains which contain additional runs with different seeds and a run with different priors take 68 GB of disk space uncompressed.\u003c/p\u003e\n\n\u003cp\u003eThe most recent code (but not the Nested Sampling chains) is also available on \u003ca href=\"https://github.com/Stefan-Heimersheim/FlexKnotFRB\"\u003eGitHub\u003c/a\u003e.\u003c/p\u003e"],"timdex_record_id":"zenodo:6542596","title":"Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\""},"highlight":{"summary":["<p>This upload contains the <span class=\"highlight\">data</span> and code used for our Fast Radio Burst forecast, constraining reionization","The <span class=\"highlight\">data</span> includes both, the generated synthetic observations, as well as the Nested Sampling chains used"],"citation":["., Fialkov, Anastasia, Lorimer, Duncan R. (2022): <span class=\"highlight\">Data</span> and Code for \"What it Takes to Measure Reionization"],"title.exact_value":["<span class=\"highlight\">Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\"</span>"],"title":["<span class=\"highlight\">Data</span> and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5504051","_score":18.850346,"_source":{"citation":"Heimersheim, Stefan, Sartorio, Nina S., Fialkov, Anastasia, Lorimer, Duncan R. (2021): Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\". Zenodo. Software. https://zenodo.org/record/5504051","content_type":["Software"],"contributors":[{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-9631-4212"],"value":"Heimersheim, Stefan"},{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-2138-5192"],"value":"Sartorio, Nina S."},{"affiliation":["Institute of Astronomy, University of Cambridge, Madingley Road, Cambridge CB3 0HA, UK; Kavli Institute for Cosmology, Madingley Road, Cambridge CB3 0HA, UK"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-1369-633X"],"value":"Fialkov, Anastasia"},{"affiliation":["West Virginia University, Department of Physics and Astronomy, P. O. Box 6315, Morgantown, WV, USA; Center for Gravitational Waves and Cosmology, West Virginia University, Chestnut Ridge Research Building, Morgantown, WV, USA"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-1301-966X"],"value":"Lorimer, Duncan R."}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-09-14"}],"format":"electronic resource","funding_information":[{"award_number":"1430284","award_uri":"info:eu-repo/grantAgreement/NSF/Directorate+for+Mathematical+%26+Physical+Sciences/1430284/","funder_identifier":"10.13039/100000001","funder_identifier_type":"Crossref Funder ID","funder_name":"National Science Foundation"},{"award_number":"1458952","award_uri":"info:eu-repo/grantAgreement/NSF//1458952/","funder_identifier":"10.13039/100000001","funder_identifier_type":"Crossref Funder ID","funder_name":"National Science Foundation"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5504051"},{"kind":"url","value":"https://zenodo.org/record/5504051"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsSupplementTo","uri":"https://arxiv.org/abs/2107.14242"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5504050"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5504051","summary":["\u003cp\u003eThis upload contains the data and code used for our Fast Radio Burst forecast, constraining reionization and cosmological parameters (\u003ca href=\"https://arxiv.org/abs/2107.14242\"\u003earxiv/2107.14242\u003c/a\u003e). The data includes both, the generated synthetic observations, as well as the Nested Sampling chains used to produce the results and figures.\u003cbr\u003e\nThe most recent code (though not the Nested Sampling chains) is also available on \u003ca href=\"https://github.com/Stefan-Heimersheim/FlexKnotFRB\"\u003eGitHub\u003c/a\u003e.\u003c/p\u003e"],"timdex_record_id":"zenodo:5504051","title":"Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\""},"highlight":{"summary":["<p>This upload contains the <span class=\"highlight\">data</span> and code used for our Fast Radio Burst forecast, constraining reionization","The <span class=\"highlight\">data</span> includes both, the generated synthetic observations, as well as the Nested Sampling chains used"],"citation":["., Fialkov, Anastasia, Lorimer, Duncan R. (2021): <span class=\"highlight\">Data</span> and Code for \"What it Takes to Measure Reionization"],"title.exact_value":["<span class=\"highlight\">Data and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\"</span>"],"title":["<span class=\"highlight\">Data</span> and Code for \"What it Takes to Measure Reionization with Fast Radio Bursts\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:3928862","_score":18.831516,"_source":{"citation":"Jane Huang (2020): Data from \"Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup\". Zenodo. Dataset. https://zenodo.org/record/3928862","content_type":["Dataset"],"contributors":[{"affiliation":["Center for Astrophysics | Harvard \u0026 Smithsonian"],"kind":"Creator","value":"Jane Huang"}],"dates":[{"kind":"Publication date","value":"2020"},{"kind":"Issued","value":"2020-07-07"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.3928862"},{"kind":"url","value":"https://zenodo.org/record/3928862"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.3928861"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/3928862","subjects":[{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["protoplanetary disks"]},{"kind":"Subject scheme not provided","value":["RU Lup"]}],"summary":["\u003cp\u003eImage cubes, self-calibrated visibilities, and self-calibration and imaging scripts for data from Huang et al., 2020, \u0026quot;Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup,\u0026quot; accepted for publication by The Astrophysical Journal, arXiv:2007.02974\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003eThe raw ALMA data can be found at the ALMA archive under program ID 2018.1.01201.S (PI: Jane Huang).\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eScripts:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eselfcal_C43-5.py, selfcal_C43-2.py, selfcal_ACA.py: self-calibration scripts for observation of RU Lup in various ALMA configurations\u003c/p\u003e\n\n\u003cp\u003eimaging.py: imaging script used for all lines\u003c/p\u003e\n\n\u003cp\u003ereductionutils.py can be downloaded from\u0026nbsp;\u003ca href=\"https://zenodo.org/record/3628656\"\u003ehttps://zenodo.org/record/3628656\u003c/a\u003e\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eMeasurement sets:\u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eRULupcontinuum.ms.tgz: Continuum visibilities for \u0026quot;RULupallcontinuum.image.pbcor.fits\u0026quot; (the high-resolution ALMA continuum data can be found on the \u003ca href=\"https://bulk.cv.nrao.edu/almadata/lp/DSHARP/\"\u003eDSHARP\u003c/a\u003e page)\u003c/p\u003e\n\n\u003cp\u003eRULup_12CO.ms.contsub.tgz: Continuum-subtracted visibilities for the \u003csup\u003e12\u003c/sup\u003eCO J=2-1 line toward RU Lup\u003c/p\u003e\n\n\u003cp\u003eRULup_12CO_nocontsub.ms.tgz: Visibilities for the \u003csup\u003e12\u003c/sup\u003eCO J=2-1 line (no continuum subtraction) toward RU Lup, used to make the \u0026#39;RULup_12COpeakintensity.fits\u0026#39; file.\u003c/p\u003e\n\n\u003cp\u003eRULup_13CO.ms.contsub.tgz: Continuum-subtracted visibilities for the \u003csup\u003e13\u003c/sup\u003eCO J=2-1 line toward RU Lup\u003c/p\u003e\n\n\u003cp\u003eRULup_C18O.ms.contsub.tgz: Continuum-subtracted visibilities for the C\u003csup\u003e18\u003c/sup\u003eO J=2-1 line toward RU Lup\u003c/p\u003e\n\n\u003cp\u003eRULup_DCOp.ms.contsub.tgz: Continuum-subtracted visibilities for the\u0026nbsp; DCO\u003csup\u003e+\u003c/sup\u003e J=3-2 line toward RU Lup\u003c/p\u003e\n\n\u003cp\u003e\u003cstrong\u003eImages: \u003c/strong\u003e\u003c/p\u003e\n\n\u003cp\u003eRULup12CO.1sigcut.pbcor.mom0.fits: Integrated intensity map of \u003csup\u003e12\u003c/sup\u003eCO J=2-1 appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULup12CO.pbcor.mom1.fits: \u003csup\u003e12\u003c/sup\u003eCO J=2-1 intensity-weighted velocity map appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULup13CO.pbcor.mom0.fits: Integrated intensity map of \u003csup\u003e13\u003c/sup\u003eCO J=2-1 appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULup13CO.pbcor.mom1.fits: \u003csup\u003e13\u003c/sup\u003eCO J=2-1 intensity-weighted velocity map appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULupC18O.pbcor.mom0.fits: Integrated intensity map of C\u003csup\u003e18\u003c/sup\u003eO J=2-1 appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULupC18O.pbcor.mom1.fits: C\u003csup\u003e18\u003c/sup\u003eO J=2-1 intensity-weighted velocity map appearing in Fig. 1\u003c/p\u003e\n\n\u003cp\u003eRULup12CO.image.pbcor.fits: \u003csup\u003e12\u003c/sup\u003eCO J=2-1 image cube appearing in Fig. 2\u003c/p\u003e\n\n\u003cp\u003eRULupC18O.image.pbcor.fits: C\u003csup\u003e18\u003c/sup\u003eO J=2-1 image cube appearing in Fig. 2\u003c/p\u003e\n\n\u003cp\u003eRULup13CO.image.pbcor.fits: \u003csup\u003e12\u003c/sup\u003eCO J=2-1 image cube appearing in Fig. 3\u003c/p\u003e\n\n\u003cp\u003eRULup_12COpeakintensity.fits: Peak intensity image of \u003csup\u003e12\u003c/sup\u003eCO used to make Figure 4\u003c/p\u003e\n\n\u003cp\u003eRULupDCOp.pbcor.mom0.fits: Integrated intensity map of DCO\u003csup\u003e+\u003c/sup\u003e J=3-2 appearing in Fig. 10\u003c/p\u003e\n\n\u003cp\u003eRULupDCOp.image.pbcor.fits: DCO\u003csup\u003e+\u003c/sup\u003e J=3-2 image cube appearing in Fig. 11\u003c/p\u003e\n\n\u003cp\u003eRULupallcontinuum.image.pbcor.fits: Continuum image appearing in Fig. 12\u003c/p\u003e\n\n\u003cp\u003eRULup12COinitial.mask.image.fits: \u003csup\u003e12\u003c/sup\u003eCO CLEAN mask shown in Fig. 13\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:3928862","title":"Data from \"Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup\""},"highlight":{"summary":["<p>Image cubes, self-calibrated visibilities, and self-calibration and imaging scripts for <span class=\"highlight\">data</span> from","accepted for publication by The Astrophysical Journal, arXiv:2007.02974&nbsp;</p>\n\n<p>The raw ALMA <span class=\"highlight\">data</span>","visibilities for &quot;RULupallcontinuum.image.pbcor.fits&quot; (the high-resolution ALMA continuum <span class=\"highlight\">data</span>"],"citation":["Jane Huang (2020): <span class=\"highlight\">Data</span> from \"Large-scale CO spirals and complex kinematics associated with the T Tauri"],"title.exact_value":["<span class=\"highlight\">Data from \"Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup\"</span>"],"title":["<span class=\"highlight\">Data</span> from \"Large-scale CO spirals and complex kinematics associated with the T Tauri star RU Lup\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:2556767","_score":18.76409,"_source":{"citation":"Moldon, Javier, Ghirlanda, Giancarlo (2019): Data processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science. Zenodo. Dataset. https://zenodo.org/record/2556767","content_type":["Dataset"],"contributors":[{"affiliation":["The University of Manchester"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-8079-7608"],"value":"Moldon, Javier"},{"affiliation":["Instituto Nazionale di Astrofisica"],"kind":"Creator","value":"Ghirlanda, Giancarlo"},{"affiliation":["The University of Manchester"],"kind":"ContactPerson","identifier":["https://orcid.org/0000-0002-8079-7608"],"value":"Moldon, Javier"},{"affiliation":["Instituto Nazionale di Astrofisica"],"kind":"Researcher","value":"Ghirlanda, Giancarlo"}],"dates":[{"kind":"Publication date","value":"2019"},{"kind":"Issued","value":"2019-02-04"}],"edition":"1","format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.2556767"},{"kind":"url","value":"https://zenodo.org/record/2556767"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.2556766"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/2556767","subjects":[{"kind":"Subject scheme not provided","value":["interferometry"]},{"kind":"Subject scheme not provided","value":["radio"]},{"kind":"Subject scheme not provided","value":["e-MERLIN"]},{"kind":"Subject scheme not provided","value":["astronomy"]},{"kind":"Subject scheme not provided","value":["gravitational wave"]}],"summary":["\u003cp\u003eData processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science\u003c/p\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e\n\n\u003cul\u003e\n\t\u003cli\u003einfo.txt contains a general description of how the data was processed and the main results.\u003c/li\u003e\n\t\u003cli\u003epipeline.tar contains the data pipeline used to process the e-MERLIN observations\u003c/li\u003e\n\t\u003cli\u003eimaging.py is the script used to produce the final images\u003c/li\u003e\n\t\u003cli\u003eCY6213_images.tar contain the final images of the target source (not corrected by calibration factor, described in the imaging script).\u003c/li\u003e\n\u003c/ul\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:2556767","title":"Data processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science"},"highlight":{"summary":["<p><span class=\"highlight\">Data</span> processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science","</p>\n\n<p>&nbsp;</p>\n\n<ul>\n\t<li>info.txt contains a general description of how the <span class=\"highlight\">data</span> was processed","</li>\n\t<li>pipeline.tar contains the <span class=\"highlight\">data</span> pipeline used to process the e-MERLIN observations</li>\n\t<li"],"citation":["Moldon, Javier, Ghirlanda, Giancarlo (2019): <span class=\"highlight\">Data</span> processing scripts and images from e-MERLIN project"],"title.exact_value":["<span class=\"highlight\">Data processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science</span>"],"title":["<span class=\"highlight\">Data</span> processing scripts and images from e-MERLIN project CY6213 used in Ghirlanda et al. 2019, Science"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:6410045","_score":18.673622,"_source":{"citation":"Law, Charles John, Crystian, Sage, Teague, Richard, Öberg, Karin I., Rich, Evan A., Andrews, Sean M., Bae, Jaehan, Flaherty, Kevin, Guzmán, Viviana V., Huang, Jane, Ilee, John D., Kastner, Joel H., Loomis, Ryan A., Long, Feng, Pérez, Laura M., Pérez, Sebastián, Qi, Chunhua, Rosotti, Giovanni P., Ruíz-Rodríguez, Dary, Tsukagoshi, Takashi, Wilner, David J. (2022): Data from \"CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks\". Zenodo. Dataset. https://zenodo.org/record/6410045","content_type":["Dataset"],"contributors":[{"kind":"Creator","identifier":["https://orcid.org/0000-0003-1413-1776"],"value":"Law, Charles John"},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-1050-278X"],"value":"Crystian, Sage"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-1534-5186"],"value":"Teague, Richard"},{"kind":"Creator","identifier":["https://orcid.org/0000-0001-8798-1347"],"value":"Öberg, Karin I."},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-1779-8181"],"value":"Rich, Evan A."},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-2253-2270"],"value":"Andrews, Sean M."},{"kind":"Creator","identifier":["https://orcid.org/0000-0001-7258-770X"],"value":"Bae, Jaehan"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-2657-1314"],"value":"Flaherty, Kevin"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-4784-3040"],"value":"Guzmán, Viviana V."},{"kind":"Creator","identifier":["https://orcid.org/0000-0001-6947-6072"],"value":"Huang, Jane"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-1008-1142"],"value":"Ilee, John D."},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-3138-8250"],"value":"Kastner, Joel H."},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-8932-1219"],"value":"Loomis, Ryan A."},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-7607-719X"],"value":"Long, Feng"},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-1199-9564"],"value":"Pérez, Laura M."},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-2953-755X"],"value":"Pérez, Sebastián"},{"kind":"Creator","identifier":["https://orcid.org/0000-0001-8642-1786"],"value":"Qi, Chunhua"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-4853-5736"],"value":"Rosotti, Giovanni P."},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-3573-8163"],"value":"Ruíz-Rodríguez, Dary"},{"kind":"Creator","identifier":["https://orcid.org/0000-0002-6034-2892"],"value":"Tsukagoshi, Takashi"},{"kind":"Creator","identifier":["https://orcid.org/0000-0003-1526-7587"],"value":"Wilner, David J."}],"dates":[{"kind":"Publication date","value":"2022"},{"kind":"Issued","value":"2022-04-03"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.6410045"},{"kind":"url","value":"https://zenodo.org/record/6410045"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.6410044"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/aas"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/6410045","subjects":[{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["Protoplanetary Disks"]},{"kind":"Subject scheme not provided","value":["CO Line Emission"]}],"summary":["\u003cp\u003eCO line emission image cubes (\u0026quot;[DISK]_CO_cube.fits\u0026quot;), line+continuum\u0026nbsp;image cubes (\u0026quot;[DISK]_CO_cube_wcont.fits\u0026quot;), and zeroth moment maps (\u0026quot;[DISK]_CO_M0.fits\u0026quot;) associated with Law et al., 2022, \u0026quot;CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks,\u0026quot;\u0026nbsp;The Astrophysical Journal\u003c/p\u003e\n\n\u003cp\u003eCO line emission image cubes from the DSHARP ALMA Large Program (for HD 142666, MY Lup, GW Lup, WaOph 6, DoAr 25) can be found at:\u0026nbsp;https://bulk.cv.nrao.edu/almadata/lp/DSHARP/ and are not included here.\u003c/p\u003e\n\n\u003cp\u003eThe raw data are available on the ALMA archive (see Table 1 in the paper for a\u0026nbsp;listing of the relevant\u0026nbsp;ALMA project codes).\u003c/p\u003e"],"timdex_record_id":"zenodo:6410045","title":"Data from \"CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks\""},"highlight":{"summary":["</p>\n\n<p>The raw <span class=\"highlight\">data</span> are available on the ALMA archive (see Table 1 in the paper for a&nbsp;listing"],"citation":["., Ruíz-Rodríguez, Dary, Tsukagoshi, Takashi, Wilner, David J. (2022): <span class=\"highlight\">Data</span> from \"CO Line Emission Surfaces"],"title.exact_value":["<span class=\"highlight\">Data from \"CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks\"</span>"],"title":["<span class=\"highlight\">Data</span> from \"CO Line Emission Surfaces and Vertical Structure in Mid-Inclination Protoplanetary Disks\""]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:4756381","_score":18.66253,"_source":{"citation":"Tazzari, Marco (2021): Data from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications for grain growth and radial drift\". Zenodo. Dataset. https://zenodo.org/record/4756381","content_type":["Dataset"],"contributors":[{"affiliation":["University of Cambridge"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-3590-5814"],"value":"Tazzari, Marco"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-06-21"}],"format":"electronic resource","funding_information":[{"award_number":"291227","award_uri":"info:eu-repo/grantAgreement/EC/FP7/291227/","funder_identifier":"10.13039/100011102","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"},{"award_number":"823823","award_uri":"info:eu-repo/grantAgreement/EC/H2020/823823/","funder_identifier":"10.13039/100010661","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"},{"award_number":"ST/S000623/1","award_uri":"info:eu-repo/grantAgreement/RCUK/STFC/ST%2FS000623%2F1/","funder_identifier":"10.13039/501100000690","funder_identifier_type":"Crossref Funder ID","funder_name":"Research Councils UK"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.4756381"},{"kind":"url","value":"https://zenodo.org/record/4756381"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsCompiledBy","uri":"arXiv:2010.02249"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.4756380"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/4756381","summary":["\u003cp\u003eTable 1, Table 2, and Table 3 from Tazzari et al., 2021,\u0026nbsp;\u0026quot;Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications for grain growth and radial drift\u0026quot;, Monthly Notices of the Royal Astronomical Society, arXiv:2010.02249\u003c/p\u003e\n\n\u003cp\u003eBoth tables are available in IPAC format, which is in human- and machine-readable:\u003c/p\u003e\n\n\u003cpre\u003e\u003ccode class=\"language-python\"\u003efrom astropy.io import ascii\ntb = ascii.read('Table1.txt', format='ipac')\u003c/code\u003e\u003c/pre\u003e\n\n\u003cp\u003eTable comments (stored at the beginning of the ASCII file as lines starting with \u0026quot;/\u0026quot;) can be read as:\u003c/p\u003e\n\n\u003cpre\u003e\u003ccode class=\"language-python\"\u003etb.meta['comments']\n\u003c/code\u003e\u003c/pre\u003e"],"timdex_record_id":"zenodo:4756381","title":"Data from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications for grain growth and radial drift\""},"highlight":{"citation":["Tazzari, Marco (2021): <span class=\"highlight\">Data</span> from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations"],"title.exact_value":["<span class=\"highlight\">Data from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications</span>"],"title":["<span class=\"highlight\">Data</span> from \"Multi-wavelength continuum sizes of protoplanetary discs: scaling relations and implications"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:4756282","_score":18.584112,"_source":{"citation":"Marco Tazzari (2021): Data from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the Lupus region\". Zenodo. Dataset. https://zenodo.org/record/4756282","content_type":["Dataset"],"contributors":[{"affiliation":["University of Cambridge"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-3590-5814"],"value":"Marco Tazzari"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-05-13"}],"format":"electronic resource","funding_information":[{"award_number":"855130","award_uri":"info:eu-repo/grantAgreement/EC/Horizon 2020 Framework Programme - European Research Council - Synergy grant/855130/","funder_identifier":"10.13039/100010661","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"},{"award_number":"823823","award_uri":"info:eu-repo/grantAgreement/EC/H2020/823823/","funder_identifier":"10.13039/100010661","funder_identifier_type":"Crossref Funder ID","funder_name":"European Commission"},{"award_number":"ST/S000623/1","award_uri":"info:eu-repo/grantAgreement/RCUK/STFC/ST%2FS000623%2F1/","funder_identifier":"10.13039/501100000690","funder_identifier_type":"Crossref Funder ID","funder_name":"Research Councils UK"}],"identifiers":[{"kind":"DOI","value":"10.5281/zenodo.4756282"},{"kind":"url","value":"https://zenodo.org/record/4756282"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsCompiledBy","uri":"arXiv:2010.02248"},{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.4756281"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/4756282","subjects":[{"kind":"Subject scheme not provided","value":["protoplanetary discs"]},{"kind":"Subject scheme not provided","value":["protoplanetary disks"]},{"kind":"Subject scheme not provided","value":["planet formation"]},{"kind":"Subject scheme not provided","value":["grain growth"]},{"kind":"Subject scheme not provided","value":["sub-mm/mm observations"]},{"kind":"Subject scheme not provided","value":["ALMA"]},{"kind":"Subject scheme not provided","value":["Lupus"]}],"summary":["\u003cp\u003eTable 1 and Table 2 from Tazzari et al., 2021, \u0026quot;The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the Lupus region\u0026quot;, Monthly Notices of the Royal Astronomical Society, arXiv:2010.02248\u003c/p\u003e\n\n\u003cp\u003eBoth tables are available in IPAC format, which is in human- and machine-readable:\u003c/p\u003e\n\n\u003cpre\u003e\u003ccode class=\"language-python\"\u003efrom astropy.io import ascii\ntb = ascii.read('Table1.txt', format='ipac')\u003c/code\u003e\u003c/pre\u003e\n\n\u003cp\u003eTable comments (stored at the beginning of the ASCII file as lines starting with \u0026quot;/\u0026quot;) can be read as:\u003c/p\u003e\n\n\u003cpre\u003e\u003ccode class=\"language-python\"\u003etb.meta['comments']\n\u003c/code\u003e\u003c/pre\u003e\n\n\u003cp\u003e\u0026nbsp;\u003c/p\u003e"],"timdex_record_id":"zenodo:4756282","title":"Data from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the Lupus region\""},"highlight":{"citation":["Marco Tazzari (2021): <span class=\"highlight\">Data</span> from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics"],"title.exact_value":["<span class=\"highlight\">Data from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the</span>"],"title":["<span class=\"highlight\">Data</span> from \"The first ALMA survey of protoplanetary discs at 3 mm: demographics of grain growth in the"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:1241122","_score":18.209042,"_source":{"citation":"Archibald, Anne M., Gusinskaia, Nina V., Hessels, Jason W. T., Deller, Adam T., Kaplan, David L., Lorimer, Duncan R., Lynch, Ryan S., Ransom, Scott M., Stairs, Ingrid H. (2018): Data supporting \"Universality of Free Fall Shown by Orbital Motion of a Pulsar in a Stellar Triple System\". Zenodo. Dataset. https://zenodo.org/record/1241122","content_type":["Dataset"],"contributors":[{"affiliation":["Anton Pannekoek Institute"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-0638-3340"],"value":"Archibald, Anne M."},{"affiliation":["Anton Pannekoek Institute"],"kind":"Creator","value":"Gusinskaia, Nina V."},{"affiliation":["Anton Pannekoek Institute, ASTRON"],"kind":"Creator","value":"Hessels, Jason W. T."},{"affiliation":["Swinburne"],"kind":"Creator","value":"Deller, Adam T."},{"affiliation":["University of Wisconsin-Milwaukee"],"kind":"Creator","value":"Kaplan, David L."},{"affiliation":["West Virginia University, Center for Gravitational Waves and Cosmology"],"kind":"Creator","value":"Lorimer, Duncan R."},{"affiliation":["Green Bank Observatory, Center for Gravitational Waves and Cosmology"],"kind":"Creator","value":"Lynch, Ryan S."},{"affiliation":["National Radio Astronomy Observatory Charlottesville"],"kind":"Creator","value":"Ransom, Scott M."},{"affiliation":["University of British Columbia"],"kind":"Creator","value":"Stairs, Ingrid H."}],"dates":[{"kind":"Publication date","value":"2018"},{"kind":"Issued","value":"2018-07-01"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.1241122"},{"kind":"url","value":"https://zenodo.org/record/1241122"}],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.1241121"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by-sa/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/1241122","subjects":[{"kind":"Subject scheme not provided","value":["pulsar"]},{"kind":"Subject scheme not provided","value":["timing"]},{"kind":"Subject scheme not provided","value":["TOA"]},{"kind":"Subject scheme not provided","value":["gravity"]}],"summary":["\u003cp\u003eThis is a collection of data supporting the research paper \u0026quot;Orbital Motion of a Pulsar in a Stellar Triple System Shows Universality of Free Fall\u0026quot;.\u003c/p\u003e\n\n\u003cp\u003eThe main data content (the \u0026quot;.tim\u0026quot; file) is a set of pulse arrival times, the primary input to the fitting process, in tempo2 format. These times are annotated with post-fit residuals and derivatives with respect to fit parameters using the tempo2 format\u0026#39;s per-TOA flags.\u003c/p\u003e\n\n\u003cp\u003eAdditional files include the data that went into several figures, plus the above converted to CSV format - but note that the CSV format does not record the pulse arrival times with sufficient precision to permit fitting. Derivative and uncertainty information may permit reanalysis of the systematics.\u003c/p\u003e"],"timdex_record_id":"zenodo:1241122","title":"Data supporting \"Universality of Free Fall Shown by Orbital Motion of a Pulsar in a Stellar Triple System\""},"highlight":{"summary":["<p>This is a collection of <span class=\"highlight\">data</span> supporting the research paper &quot;Orbital Motion of a Pulsar in a Stellar","</p>\n\n<p>The main <span class=\"highlight\">data</span> content (the &quot;.tim&quot; file) is a set of pulse arrival times, the primary","</p>\n\n<p>Additional files include the <span class=\"highlight\">data</span> that went into several figures, plus the above converted to"],"citation":["., Stairs, Ingrid H. (2018): <span class=\"highlight\">Data</span> supporting \"Universality of Free Fall Shown by Orbital Motion of a"],"title.exact_value":["<span class=\"highlight\">Data supporting \"Universality of Free Fall Shown by Orbital Motion of a Pulsar in a Stellar Triple System</span>"],"title":["<span class=\"highlight\">Data</span> supporting \"Universality of Free Fall Shown by Orbital Motion of a Pulsar in a Stellar Triple System"]}},{"_index":"whoas-2022-07-06t15-32-41z","_type":"_doc","_id":"whoas:1912-24528","_score":18.074003,"_source":{"citation":"Donatelli, C., Ganju, N. K., Kalra, T. S., Fagherazzi, S., \u0026 Leonardi, N. (2019). Dataset of numerical modelling results of wave thrust on salt marsh boundaries with different seagrass coverages in a shallow back-barrier estuary. Data in Brief, 25, 104197.","content_type":["Article"],"contributors":[{"kind":"author","value":"Donatelli, Carmine"},{"kind":"author","value":"Ganju, Neil K."},{"kind":"author","value":"Kalra, Tarandeep S."},{"kind":"author","value":"Fagherazzi, Sergio"},{"kind":"author","value":"Leonardi, Nicoletta"}],"dates":[{"kind":"accessioned","value":"2019-09-10T14:28:06Z"},{"kind":"available","value":"2019-09-10T14:28:06Z"},{"kind":"Publication date","value":"2019-07-06"}],"format":"electronic resource","funding_information":[{"funder_name":"This study was supported by the Department of the Interior Hurricane Sandy Recovery program (ID G16AC00455, sub-award to University of Liverpool). S.F. was partly supported by NSF awards 1637630 (PIE LTER) and 1832221 (VCR LTER). We further acknowledge partial support from the Environmental Change Research group at University of Liverpool, and University of Liverpool library for publication fees."}],"identifiers":[{"kind":"uri","value":"https://hdl.handle.net/1912/24528"},{"kind":"doi","value":"10.1016/j.dib.2019.104197"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"https://hdl.handle.net/1912/24528"}],"notes":[{"value":["© The Author(s), 2019. This article is distributed under the terms of the Creative Commons Attribution License. The definitive version was published in Donatelli, C., Ganju, N. K., Kalra, T. S., Fagherazzi, S., \u0026 Leonardi, N. (2019). Dataset of numerical modelling results of wave thrust on salt marsh boundaries with different seagrass coverages in a shallow back-barrier estuary. Data in Brief, 25, 104197, doi:10.1016/j.dib.2019.104197."]}],"publication_information":["Elsevier"],"related_items":[{"uri":"https://doi.org/10.1016/j.dib.2019.104197"}],"rights":[{},{"uri":"http://creativecommons.org/licenses/by/4.0/"}],"source":"Woods Hole Open Access Server","source_link":"https://darchive.mblwhoilibrary.org/handle/1912/24528","subjects":[{"kind":"Subject scheme not provided","value":["Vegetation","COAWST","Wave thrust"]}],"summary":["This article contains data on the effects of seagrass decline on wave energy along the shoreline of Barnegat Bay (USA) previously evaluated in Donatelli et al., 2019. This study was carried out applying the Coupled-Ocean-Atmosphere-Wave-Sediment Transport (COAWST) numerical modelling framework to six historical maps of seagrass distribution. A new routine recently implemented in COAWST was used, which explicitly computes the wave thrust acting on salt marsh boundaries. The numerical modelling results are reported in terms of wind-wave heights for different seagrass coverages, wind speeds and directions. From a comparison with a numerical experiment without submerged aquatic vegetation, we show how the computed wave thrust on marsh boundaries can be reduced by seagrass beds."],"timdex_record_id":"whoas:1912-24528","title":"Dataset of numerical modelling results of wave thrust on salt marsh boundaries with different seagrass coverages in a shallow back-barrier estuary"},"highlight":{"summary":["This article contains <span class=\"highlight\">data</span> on the effects of seagrass decline on wave energy along the shoreline of Barnegat"],"citation":["<span class=\"highlight\">Data</span> in Brief, 25, 104197."],"title.exact_value":["<span class=\"highlight\">Dataset of numerical modelling results of wave thrust on salt marsh boundaries with different seagrass</span>"],"notes.value":["<span class=\"highlight\">Data</span> in Brief, 25, 104197, doi:10.1016/j.dib.2019.104197."]}},{"_index":"jpal-2022-07-06t15-32-27z","_type":"_doc","_id":"jpal:doi:10.7910-DVN-TDFJ7X","_score":17.446787,"_source":{"alternate_titles":[{"kind":"AlternativeTitle","value":"Education, HIV, and Early Fertility: Experimental Evidence from Kenya"}],"citation":"Duflo, Esther, Dupas, Pascaline, Kremer, Michael (2013): Data on Kenyan Youths. Harvard Dataverse. Dataset. https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/TDFJ7X","content_type":["Dataset"],"contributors":[{"affiliation":["Massachusetts Institute of Technology"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-6105-617X"],"value":"Duflo, Esther"},{"affiliation":["Stanford University"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-0140-9417"],"value":"Dupas, Pascaline"},{"affiliation":["Harvard University"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-7914-5269"],"value":"Kremer, Michael"},{"affiliation":["Massachusetts Institute of Technology"],"kind":"ContactPerson","value":"Duflo, Esther"},{"affiliation":["Stanford University"],"kind":"ContactPerson","value":"Dupas, Pascaline"},{"affiliation":["Harvard University"],"kind":"ContactPerson","value":"Kremer, Michael"},{"kind":"Distributor","value":"Jameel Poverty Action Lab"}],"dates":[{"kind":"Publication date","value":"2013"},{"kind":"Issued","value":"2012-12"},{"kind":"Submitted","value":"2013-09-17"},{"kind":"Updated","value":"2020-03-31"}],"edition":"4.4","file_formats":["text/plain; charset=US-ASCII","application/x-stata","application/msword"],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.7910/DVN/TDFJ7X"}],"publication_information":["Harvard Dataverse"],"related_items":[{"relationship":"IsCitedBy","uri":"https://doi.org/10.1257/aer.20121607"}],"rights":[{"uri":"info:eu-repo/semantics/openAccess"},{"uri":"http://creativecommons.org/publicdomain/zero/1.0"}],"source":"Abdul Latif Jameel Poverty Action Lab Dataverse","source_link":"https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/TDFJ7X","subjects":[{"kind":"Subject scheme not provided","value":["Social Sciences"]},{"kind":"Subject scheme not provided","value":["HIV, Kenya, uniforms, Herpes (HSV2), sexually transmitted infection(STI), students, drop-out, pregnancy, teacher training, AIDS/HIV curriculum, risky sexual behavior."]}],"summary":["A seven-year randomized evaluation suggests education subsidies reduce adolescent girls' dropout, pregnancy, and marriage but not sexually transmitted infection (STI). The government's HIV curriculum, which stresses abstinence until marriage, does not reduce pregnancy or STI. Both programs combined reduce STI more, but cut dropout and pregnancy less, than education subsidies alone. These results are inconsistent with a model of schooling and sexual behavior in which both pregnancy and STI are determined by one factor (unprotected sex), but consistent with a two-factor model in which choices between committed and casual relationships also affect these outcomes.\r\n\r\nThis data was collected as a part of the study \"Education, HIV, and Early Fertility: Experimental Evidence from Kenya.\"  Details on sample construction and data collection for this survey data can be found in the paper.  The 2012 version of the paper is available here: http://www.stanford.edu/~pdupas/DDK_EducFertHIV.pdf.  Note that all sections of data collected for the study are not currently available and will be released in the future."],"timdex_record_id":"jpal:doi:10.7910-DVN-TDFJ7X","title":"Data on Kenyan Youths"},"highlight":{"summary":["This <span class=\"highlight\">data</span> was collected as a part of the study \"Education, HIV, and Early Fertility: Experimental Evidence","Details on sample construction and <span class=\"highlight\">data</span> collection for this survey <span class=\"highlight\">data</span> can be found in the paper.","Note that all sections of <span class=\"highlight\">data</span> collected for the study are not currently available and will be released"],"citation":["Duflo, Esther, Dupas, Pascaline, Kremer, Michael (2013): <span class=\"highlight\">Data</span> on Kenyan Youths. Harvard Dataverse."],"title.exact_value":["<span class=\"highlight\">Data on Kenyan Youths</span>"],"title":["<span class=\"highlight\">Data</span> on Kenyan Youths"]}},{"_index":"jpal-2022-07-06t15-32-27z","_type":"_doc","_id":"jpal:doi:10.7910-DVN-DBX9YW","_score":17.358427,"_source":{"citation":"Abhijit Banerjee, Jennifer Bussell, Sarika Gupta, Rema Hanna, Ben Olken (2021): Data for Haqdarshak: Leveraging Technology and Entrepreneurship to Increase Access to Welfare Programs. Harvard Dataverse. Dataset. https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/DBX9YW","content_type":["Dataset"],"contributors":[{"affiliation":["Massachusetts Institute of Technology"],"kind":"Creator","value":"Abhijit Banerjee"},{"affiliation":["University of California, Berkeley"],"kind":"Creator","value":"Jennifer Bussell"},{"affiliation":["Harvard University"],"kind":"Creator","value":"Sarika Gupta"},{"affiliation":["Harvard University"],"kind":"Creator","value":"Rema Hanna"},{"affiliation":["Massachusetts Institute of Technology"],"kind":"Creator","value":"Ben Olken"},{"affiliation":["Harvard University"],"kind":"ContactPerson","value":"Weiss, Alexa"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Submitted","value":"2021-08-10"},{"kind":"Updated","value":"2021-08-10"}],"edition":"2.0","file_formats":["application/pdf","application/pdf","application/pdf","application/pdf","application/pdf","application/x-tex","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","text/tab-separated-values","application/x-tex","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-stata-syntax","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","text/tab-separated-values","text/tab-separated-values","application/x-tex","application/x-tex","application/x-tex","application/pdf","application/x-tex","application/x-tex","application/x-tex","application/x-tex","text/tab-separated-values","text/tab-separated-values","application/x-tex","application/x-tex","application/x-tex","application/x-tex","text/tab-separated-values","text/tab-separated-values","text/tab-separated-values","application/x-stata-syntax","application/x-tex","application/x-tex","application/x-tex","application/x-tex","text/tab-separated-values","application/x-tex","text/tab-separated-values","text/tab-separated-values","text/tab-separated-values","text/tab-separated-values","text/tab-separated-values","text/tab-separated-values","text/tab-separated-values","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/pdf","text/tab-separated-values","application/x-tex","text/tab-separated-values","text/tab-separated-values","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex","application/x-tex"],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.7910/DVN/DBX9YW"}],"publication_information":["Harvard Dataverse"],"rights":[{"uri":"info:eu-repo/semantics/openAccess"},{"uri":"https://creativecommons.org/publicdomain/zero/1.0/"}],"source":"Abdul Latif Jameel Poverty Action Lab Dataverse","source_link":"https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/DBX9YW","subjects":[{"kind":"Subject scheme not provided","value":["Social Sciences"]}],"summary":["This package contains replication data for the project \"Haqdarshak: Leveraging Technology and Entrepreneurship to Increase Access to Welfare Programs.” The package contains two main sets of data: i) de-identified raw data files for baseline, intervention and endline for the pilot sample (646 households), conducted in 10 Indian villages in Dausa district, Rajasthan, from December 2017 to April 2019; ii) the baseline data collected for the main experimental sample (4808 households), which was launched in July 2019 across 94 villages in the district of Sikar, Jhunjhunu and Bhilwara, and completed in February 2020. The main intervention and endline were put on pause because of COVID-19, so there is only baseline data for the main experiment. The code, produced in Stata, contains both cleaning and analysis code, which generate intermediate data and latex tables, respectively. For further details on the data or code, please see the readme file. Finally, the package also contains the survey instruments used in data collection as well as a narrative report from the project that provides analysis on the pilot and baseline data."],"timdex_record_id":"jpal:doi:10.7910-DVN-DBX9YW","title":"Data for Haqdarshak: Leveraging Technology and Entrepreneurship to Increase Access to Welfare Programs"},"highlight":{"summary":["This package contains replication <span class=\"highlight\">data</span> for the project \"Haqdarshak: Leveraging Technology and Entrepreneurship","The package contains two main sets of <span class=\"highlight\">data</span>: i) de-identified raw <span class=\"highlight\">data</span> files for baseline, intervention","10 Indian villages in Dausa district, Rajasthan, from December 2017 to April 2019; ii) the baseline <span class=\"highlight\">data</span>","For further details on the <span class=\"highlight\">data</span> or code, please see the readme file.","report from the project that provides analysis on the pilot and baseline <span class=\"highlight\">data</span>."],"citation":["Abhijit Banerjee, Jennifer Bussell, Sarika Gupta, Rema Hanna, Ben Olken (2021): <span class=\"highlight\">Data</span> for Haqdarshak:"],"title.exact_value":["<span class=\"highlight\">Data for Haqdarshak: Leveraging Technology and Entrepreneurship to Increase Access to Welfare Programs</span>"],"title":["<span class=\"highlight\">Data</span> for Haqdarshak: Leveraging Technology and Entrepreneurship to Increase Access to Welfare Programs"]}},{"_index":"jpal-2022-07-06t15-32-27z","_type":"_doc","_id":"jpal:doi:10.7910-DVN-VAFYV1","_score":17.274666,"_source":{"citation":"Karthik Muralidharan, Paul Niehaus, Sandip Sukhtankar, Jeffrey Weaver (2021): Data for the \"Targeted Unconditional Framed Cash Transfers for Early Childhood Health and Nutrition Outcomes\" project. Harvard Dataverse. Dataset. https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/VAFYV1","content_type":["Dataset"],"contributors":[{"affiliation":["University of California, San Diego"],"kind":"Creator","value":"Karthik Muralidharan"},{"affiliation":["University of California, San Diego"],"kind":"Creator","value":"Paul Niehaus"},{"affiliation":["University of Virginia"],"kind":"Creator","value":"Sandip Sukhtankar"},{"affiliation":["University of Southern California"],"kind":"Creator","value":"Jeffrey Weaver"},{"affiliation":["J-PAL"],"kind":"ContactPerson","value":"Akanksha Saletore"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Submitted","value":"2021-01-28"},{"kind":"Updated","value":"2021-06-30"}],"edition":"3.0","file_formats":["application/pdf","application/pdf","text/tab-separated-values","application/pdf","text/tab-separated-values","application/pdf","text/tab-separated-values","application/pdf","text/tab-separated-values","application/pdf","text/tab-separated-values","application/pdf","text/tab-separated-values","application/pdf","text/tab-separated-values"],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.7910/DVN/VAFYV1"}],"publication_information":["Harvard Dataverse"],"rights":[{"uri":"info:eu-repo/semantics/openAccess"},{"uri":"https://creativecommons.org/publicdomain/zero/1.0/"}],"source":"Abdul Latif Jameel Poverty Action Lab Dataverse","source_link":"https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi:10.7910/DVN/VAFYV1","subjects":[{"kind":"Subject scheme not provided","value":["Social Sciences"]}],"summary":["This package contains data for the RCT \"Targeted Unconditional Framed Cash Transfers for Early Childhood Health and Nutrition Outcomes.\" The package includes  data from the first two phases of the trial, conducted between September 2018 and December 2019 in 8 districts in a single Indian state. The datasets contain cleaned data from surveys given at the household level, and include anthropometric and reported data on mothers and children. Observations are at the child level. For further details on the data, please see the readme file."],"timdex_record_id":"jpal:doi:10.7910-DVN-VAFYV1","title":"Data for the \"Targeted Unconditional Framed Cash Transfers for Early Childhood Health and Nutrition Outcomes\" project"},"highlight":{"summary":["This package contains <span class=\"highlight\">data</span> for the RCT \"Targeted Unconditional Framed Cash Transfers for Early Childhood","The package includes  <span class=\"highlight\">data</span> from the first two phases of the trial, conducted between September 2018 and","The datasets contain cleaned <span class=\"highlight\">data</span> from surveys given at the household level, and include anthropometric","and reported <span class=\"highlight\">data</span> on mothers and children.","For further details on the <span class=\"highlight\">data</span>, please see the readme file."],"citation":["Karthik Muralidharan, Paul Niehaus, Sandip Sukhtankar, Jeffrey Weaver (2021): <span class=\"highlight\">Data</span> for the \"Targeted"],"title.exact_value":["<span class=\"highlight\">Data for the \"Targeted Unconditional Framed Cash Transfers for Early Childhood Health and Nutrition Outcomes</span>"],"title":["<span class=\"highlight\">Data</span> for the \"Targeted Unconditional Framed Cash Transfers for Early Childhood Health and Nutrition Outcomes"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5029530","_score":16.52032,"_source":{"citation":"Kshitij Aggarwal, Devansh Agarwal, Evan F Lewis, Reshma Anna-Thomas, Jacob Cardinal Tremblay, Sarah Burke-Spolaor, Maura McLaughlin, Duncan Lorimer (2021): Dataset corresponding to \"Comprehensive analysis of a dense sample of FRB 121102 bursts\". Zenodo. Dataset. https://zenodo.org/record/5029530","content_type":["Dataset"],"contributors":[{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-2059-0525"],"value":"Kshitij Aggarwal"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-0385-491X"],"value":"Devansh Agarwal"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-2972-522X"],"value":"Evan F Lewis"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-8057-0633"],"value":"Reshma Anna-Thomas"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-9852-6825"],"value":"Jacob Cardinal Tremblay"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-4052-7838"],"value":"Sarah Burke-Spolaor"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0001-7697-7422"],"value":"Maura McLaughlin"},{"affiliation":["West Virginia University"],"kind":"Creator","identifier":["https://orcid.org/0000-0003-1301-966X"],"value":"Duncan Lorimer"}],"dates":[{"kind":"Publication date","value":"2021"},{"kind":"Issued","value":"2021-06-24"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5029530"},{"kind":"url","value":"https://zenodo.org/record/5029530"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5029529"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5029530","subjects":[{"kind":"Subject scheme not provided","value":["Fast Radio Bursts"]},{"kind":"Subject scheme not provided","value":["Markov  Chain  Monte  Carlo"]},{"kind":"Subject scheme not provided","value":["Observational Astronomy"]},{"kind":"Subject scheme not provided","value":["Astronomy  data  analysis"]}],"summary":["\u003cp\u003eRaw dataset corresponding to publication: \u003ca href=\"https://ui.adsabs.harvard.edu/abs/2021arXiv210705658A/abstract\"\u003e\u0026quot;Comprehensive analysis of a dense sample of FRB 121102 bursts\u0026quot;\u003c/a\u003e. The dataset consists of raw filterbank format files from the two observations.\u003c/p\u003e"],"timdex_record_id":"zenodo:5029530","title":"Dataset corresponding to \"Comprehensive analysis of a dense sample of FRB 121102 bursts\""},"highlight":{"title.exact_value":["<span class=\"highlight\">Dataset corresponding to \"Comprehensive analysis of a dense sample of FRB 121102 bursts\"</span>"],"subjects.value":["Astronomy  <span class=\"highlight\">data</span>  analysis"]}},{"_index":"zenodo-2022-07-06t15-32-33z","_type":"_doc","_id":"zenodo:5902893","_score":15.819018,"_source":{"citation":"Fiorenzo Stoppa, Paul Vreeswijk (2022): Dataset for: AutoSourceID-Light. Zenodo. Dataset. https://zenodo.org/record/5902893","content_type":["Dataset"],"contributors":[{"affiliation":["Radboud University"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-3424-8528"],"value":"Fiorenzo Stoppa"},{"affiliation":["Radboud University"],"kind":"Creator","identifier":["https://orcid.org/0000-0002-7572-9088"],"value":"Paul Vreeswijk"}],"dates":[{"kind":"Publication date","value":"2022"},{"kind":"Issued","value":"2022-01-27"}],"format":"electronic resource","identifiers":[{"kind":"DOI","value":"10.5281/zenodo.5902893"},{"kind":"url","value":"https://zenodo.org/record/5902893"}],"languages":["en"],"publication_information":["Zenodo"],"related_items":[{"relationship":"IsVersionOf","uri":"https://doi.org/10.5281/zenodo.5902892"},{"relationship":"IsPartOf","uri":"https://zenodo.org/communities/astronomy-general"}],"rights":[{"uri":"https://creativecommons.org/licenses/by/4.0/legalcode"},{"uri":"info:eu-repo/semantics/openAccess"}],"source":"Zenodo","source_link":"https://zenodo.org/record/5902893","subjects":[{"kind":"Subject scheme not provided","value":["Machine learning"]},{"kind":"Subject scheme not provided","value":["Astronomy"]}],"summary":["\u003cp\u003eThis is the dataset used in the paper AutoSourceID-Light (\u003cstrong\u003e\u003ca href=\"https://arxiv.org/abs/2202.00489\"\u003eArXiv preperint\u003c/a\u003e\u003c/strong\u003e)\u0026nbsp;for Training, Test and Validation sets.\u0026nbsp;AutoSourceID-Light (ASID-L) is\u0026nbsp;an innovative framework that uses computer vision techniques that can naturally deal with large amounts of data and rapidly localize sources in optical images.\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003eThe dataset is made of\u0026nbsp;3 fields images taken with\u0026nbsp;the MeerLICHT telescope:\u0026nbsp;_20200601_191800_ (Omega Centauri globular cluster),\u0026nbsp;_20210401_173445_(Fornax galaxy cluster)\u0026nbsp;and\u0026nbsp;_20210910_022724_ (\u0026#39;empty\u0026#39; CDF-S).\u003c/p\u003e\n\n\u003cp\u003eFor each field, 2\u0026nbsp;files are provided: the optical image (_red_cosmics_nobkgsub.fits) and the catalog of EDR3 Gaia sources that match the location of the fields\u0026nbsp;(_GaiaEDR3_cat_SNR_redimage.fits).\u0026nbsp;\u003c/p\u003e\n\n\u003cp\u003eIf you use the dataset, please cite the appropriate DOIs.\u003c/p\u003e\n\n\u003cp\u003eCode available at\u0026nbsp;\u003ca href=\"https://github.com/FiorenSt/AutoSourceID-Light/tree/v0.0.2\"\u003e\u003cstrong\u003ehttps://github.com/FiorenSt/AutoSourceID-Light\u003c/strong\u003e\u003c/a\u003e\u0026nbsp; (\u003ca href=\"https://zenodo.org/record/6414546#.YkwoeihByUk\"\u003eZenodo repository\u003c/a\u003e)\u003c/p\u003e"],"timdex_record_id":"zenodo:5902893","title":"Dataset for: AutoSourceID-Light"},"highlight":{"summary":["innovative framework that uses computer vision techniques that can naturally deal with large amounts of <span class=\"highlight\">data</span>"],"title.exact_value":["<span class=\"highlight\">Dataset for: AutoSourceID-Light</span>"]}}]},"aggregations":{"languages":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"en_us","doc_count":122},{"key":"en","doc_count":87},{"key":"el","doc_count":1},{"key":"fr","doc_count":1}]},"content_type":{"doc_count_error_upper_bound":0,"sum_other_doc_count":3,"buckets":[{"key":"dataset","doc_count":218},{"key":"article","doc_count":132},{"key":"working paper","doc_count":70},{"key":"software","doc_count":58},{"key":"text","doc_count":36},{"key":"preprint","doc_count":17},{"key":"journalarticle","doc_count":9},{"key":"conferencepaper","doc_count":6},{"key":"other","doc_count":5},{"key":"image","doc_count":3}]},"collections":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[]},"subjects":{"doc_count":1143,"subject_names":{"doc_count_error_upper_bound":7,"sum_other_doc_count":1444,"buckets":[{"key":"social sciences","doc_count":99},{"key":"astronomy","doc_count":46},{"key":"gas hydrate","doc_count":13},{"key":"radio astronomy","doc_count":13},{"key":"medicine, health and life sciences","doc_count":11},{"key":"astrophysics","doc_count":10},{"key":"idl","doc_count":10},{"key":"sediment transport","doc_count":10},{"key":"machine learning","doc_count":9},{"key":"python","doc_count":8}]}},"content_format":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"electronic resource","doc_count":557}]},"literary_form":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[]},"source":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"zenodo","doc_count":242},{"key":"woods hole open access server","doc_count":146},{"key":"abdul latif jameel poverty action lab dataverse","doc_count":99},{"key":"dspace@mit","doc_count":70}]},"contributors":{"doc_count":2787,"contributor_names":{"doc_count_error_upper_bound":12,"sum_other_doc_count":2567,"buckets":[{"key":"duflo, esther","doc_count":47},{"key":"massachusetts institute of technology. center for energy and environmental policy research.","doc_count":46},{"key":"banerjee, abhijit","doc_count":22},{"key":"danehkar, ashkbiz","doc_count":17},{"key":"ganju, neil k.","doc_count":16},{"key":"glennerster, rachel","doc_count":16},{"key":"ten brink, uri s.","doc_count":16},{"key":"warner, john c.","doc_count":15},{"key":"greenstone, michael","doc_count":13},{"key":"ruppel, carolyn d.","doc_count":12}]}}}} + recorded_at: Wed, 06 Jul 2022 15:49:14 GMT +- request: + method: post + uri: http://localhost:9200/timdex-prod/_search + body: + encoding: UTF-8 + string: '{"from":"0","size":20,"query":{"bool":{"should":[{"prefix":{"title.exact_value":{"value":"data","boost":15.0}}},{"term":{"title":{"value":"data","boost":1.0}}},{"nested":{"path":"contributors","query":{"term":{"contributors.value":{"value":"data","boost":0.1}}}}}],"must":[{"multi_match":{"query":"data"}}],"filter":[{"bool":{"should":[{"term":{"source":"DSpace@MIT"}}]}}]}},"highlight":{"pre_tags":["\u003cspan + class=\"highlight\"\u003e"],"post_tags":["\u003c/span\u003e"],"fields":{"*":{}}},"aggregations":{"collections":{"terms":{"field":"collections.keyword"}},"contributors":{"nested":{"path":"contributors"},"aggs":{"contributor_names":{"terms":{"field":"contributors.value.keyword"}}}},"content_type":{"terms":{"field":"content_type"}},"content_format":{"terms":{"field":"format"}},"languages":{"terms":{"field":"languages.keyword"}},"literary_form":{"terms":{"field":"literary_form"}},"source":{"terms":{"field":"source"}},"subjects":{"nested":{"path":"subjects"},"aggs":{"subject_names":{"terms":{"field":"subjects.value.keyword"}}}}}}' + headers: + User-Agent: + - 'opensearch-ruby/2.0.0 (RUBY_VERSION: 2.7.6; darwin x86_64; Faraday v1.10.0)' + Content-Type: + - application/json + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=UTF-8 + Content-Length: + - '11087' + body: + encoding: ASCII-8BIT + string: !binary |- + {"took":31,"timed_out":false,"_shards":{"total":4,"successful":4,"skipped":0,"failed":0},"hits":{"total":{"value":70,"relation":"eq"},"max_score":10.432909,"hits":[{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-44968","_score":10.432909,"_source":{"citation":"Stoker, Thomas M. (2000): Panel data analysis of U.S. coal productivity. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/44968","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Stoker, Thomas M."},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"2000"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/44968"},{"kind":"oclc","value":"52315985"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/44968"}],"numbering":"MIT-CEEPR (Series) ; 00-004WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/44968","summary":["We analyze labor productivity in coal mining in the United States using indices of productivity change associated with the concepts of panel data modeling. This approach is valuable when there is extensive heterogeneity in production units, as with coal mines. We find substantial returns to scale for coal mining in all geographical regions, and find that smooth technical progress is exhibited by estimates of the fixed effects for coal mining. We carry out a variety of diagnostic analyses of our basic model and primary modeling assumptions, using recently proposed methods for addressing 'errors-in-variable' and 'weak instrument bias' problems, as well a new method for studying errors-in-variables in nonlinear contexts."],"timdex_record_id":"dspace:1721.1-44968","title":"Panel data analysis of U.S. coal productivity"},"highlight":{"summary":["mining in the United States using indices of productivity change associated with the concepts of panel <span class=\"highlight\">data</span>"],"citation":["Stoker, Thomas M. (2000): Panel <span class=\"highlight\">data</span> analysis of U.S. coal productivity."],"source":["<span class=\"highlight\">DSpace@MIT</span>"],"title":["Panel <span class=\"highlight\">data</span> analysis of U.S. coal productivity"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-44986","_score":7.744748,"_source":{"citation":"Gupta, Shreekant (2002): Environmental benefits and cost savings through market-based instruments : an application using state-level data from India. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/44986","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Gupta, Shreekant"},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"2002"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/44986"},{"kind":"oclc","value":"52305223"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/44986"}],"numbering":"MIT-CEEPR (Series) ; 02-005WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/44986","summary":["This paper develops a methodology for estimating potential cost savings from the use of market-based instruments (MBIs) when local emissions and abatement cost data are not available. The paper provides estimates of the cost savings for a 50% reduction of particulate emissions in India's five main industrial states, as well as estimates of the benefits from doing so. The estimates are developed by applying World Bank particulate intensity and abatement cost factors to sectoral output data. The estimated costs savings range from 26% to 169% and the benefits are many times greater than the costs even without the use of MBIs. The paper concludes by commenting on the relative difficulty of implementing reductions by market-based instruments and conventional command-and-control regulations."],"timdex_record_id":"dspace:1721.1-44986","title":"Environmental benefits and cost savings through market-based instruments : an application using state-level data from India"},"highlight":{"summary":["cost savings from the use of market-based instruments (MBIs) when local emissions and abatement cost <span class=\"highlight\">data</span>","developed by applying World Bank particulate intensity and abatement cost factors to sectoral output <span class=\"highlight\">data</span>"],"citation":["Environmental benefits and cost savings through market-based instruments : an application using state-level <span class=\"highlight\">data</span>"],"source":["<span class=\"highlight\">DSpace@MIT</span>"],"title":["Environmental benefits and cost savings through market-based instruments : an application using state-level <span class=\"highlight\">data</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-45062","_score":7.5873494,"_source":{"citation":"Ellerman, A. Denny, Buchner, Barbara (2006): Over-allocation or abatement? : a preliminary analysis of the EU ETS based on the 2005 emission data. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/45062","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Ellerman, A. Denny"},{"kind":"author","value":"Buchner, Barbara"},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"2006"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/45062"},{"kind":"oclc","value":"159935161"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/45062"}],"numbering":"MIT-CEEPR (Series) ; 06-016WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/45062","summary":["This paper provides an initial analysis of the EU ETS based on the installation-level data for verified emissions and allowance allocations in the first trading year. Those data, released on May 15, 2006, and subsequent updates revealed that CO2 emissions were about 4% lower than the allocated allowances. The main objective of the paper is to shed light on the extent to which over-allocation and abatement have taken place in 2005. We propose a measure by which over-allocation can be judged and provide estimates of abatement based on emissions data and indicators of economic activity as well as trends in energy and carbon intensity. Finally, we discuss the insights and implications that emerge from this tentative assessment."],"timdex_record_id":"dspace:1721.1-45062","title":"Over-allocation or abatement? : a preliminary analysis of the EU ETS based on the 2005 emission data"},"highlight":{"summary":["This paper provides an initial analysis of the EU ETS based on the installation-level <span class=\"highlight\">data</span> for verified","Those <span class=\"highlight\">data</span>, released on May 15, 2006, and subsequent updates revealed that CO2 emissions were about 4%","measure by which over-allocation can be judged and provide estimates of abatement based on emissions <span class=\"highlight\">data</span>"],"citation":[": a preliminary analysis of the EU ETS based on the 2005 emission <span class=\"highlight\">data</span>."],"source":["<span class=\"highlight\">DSpace@MIT</span>"],"title":[": a preliminary analysis of the EU ETS based on the 2005 emission <span class=\"highlight\">data</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-45656","_score":2.522811,"_source":{"citation":"Ellerman, A. Denny, Trotignon, Raphael (2008): Compliance Behavior in the EU-ETS: Cross Border Trading, Banking and Borrowing. Working Paper. https://dspace.mit.edu/handle/1721.1/45656","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Ellerman, A. Denny"},{"kind":"author","value":"Trotignon, Raphael"}],"dates":[{"kind":"Publication date","value":"2008"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"issn","value":"2008-012"},{"kind":"uri","value":"http://hdl.handle.net/1721.1/45656"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/45656"}],"numbering":"MIT-CEEPR;08-012WP","source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/45656","summary":["This paper exploits a little used data resource within the central registry of the European Union’s Emissions Trading System (EU ETS) to analyze cross border flows of allowances for compliance purposes during the first trading period (2005- 2007). The extent of cross border trading is small in the aggregate but remarkably frequent in matching allowance deficits and surpluses at the installation level throughout the EU. As such, these data provide evidence of the high and wide-spread market participation that is the precondition of efficient abatement in a cap-and-trade system. There is also remarkable little difference in the monetization of allowance surpluses between participants in the EU15 and those in the East European New Member States. Finally, comparison of these data with the more commonly reported data on allocations and verified emissions reveals considerable recourse to a novel feature of the EU ETS:  borrowing from the next year’s allocation to satisfy current compliance requirements."],"timdex_record_id":"dspace:1721.1-45656","title":"Compliance Behavior in the EU-ETS: Cross Border Trading, Banking and Borrowing"},"highlight":{"summary":["This paper exploits a little used <span class=\"highlight\">data</span> resource within the central registry of the European Union’s Emissions","As such, these <span class=\"highlight\">data</span> provide evidence of the high and wide-spread market participation that is the precondition","Finally, comparison of these <span class=\"highlight\">data</span> with the more commonly reported <span class=\"highlight\">data</span> on allocations and verified emissions"],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-45127","_score":2.4474545,"_source":{"citation":"McGuinness, Meghan, Trotingnon, Raphael (2007): Technical memorandum on analysis of the EU ETS using the community independent transaction log. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/45127","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"McGuinness, Meghan"},{"kind":"author","value":"Trotingnon, Raphael"},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"2007"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/45127"},{"kind":"oclc","value":"244571938"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/45127"}],"numbering":"MIT-CEEPR (Series) ; 07-012WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/45127","summary":["This memorandum provides an overview of three deficiencies within the current presentation of the Community Independent Transaction Log (CITL) data that have implications for researchers' ability to accurately analyze the impacts of the EU ETS. It evaluates the impact of these deficiencies on analyses of the UK, Spain, and France, three Member States with readily available installation-level data that can be compared against the CITL."],"timdex_record_id":"dspace:1721.1-45127","title":"Technical memorandum on analysis of the EU ETS using the community independent transaction log"},"highlight":{"summary":["three deficiencies within the current presentation of the Community Independent Transaction Log (CITL) <span class=\"highlight\">data</span>","analyses of the UK, Spain, and France, three Member States with readily available installation-level <span class=\"highlight\">data</span>"],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-45087","_score":2.3254812,"_source":{"citation":"Pindyck, Robert S. (1999): The long-run evolution of energy prices. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/45087","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Pindyck, Robert S."},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"1999"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/45087"},{"kind":"oclc","value":"42076988"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/45087"}],"numbering":"MIT-CEEPR (Series) ; 99-001WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/45087","summary":["I examine the long-run behavior of oil, coal, and natural gas prices, using up to 127 years of data, and address the following questions: What does over a century of data tell us about the stochastic dynamics of price evolution, and how it should be modeled? Can models of reversion to stochastically fluctuating trend lines help us forecast prices over horizons of 20 years or more? And what do the answers to these questions tell us about investment decisions that are dependent on prices and their stochastic evolution?"],"timdex_record_id":"dspace:1721.1-45087","title":"The long-run evolution of energy prices"},"highlight":{"summary":["I examine the long-run behavior of oil, coal, and natural gas prices, using up to 127 years of <span class=\"highlight\">data</span>,","and address the following questions: What does over a century of <span class=\"highlight\">data</span> tell us about the stochastic dynamics"],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-44985","_score":2.2874808,"_source":{"citation":"Montero, Juan-Pablo (2002): Testing the efficiency of a tradeable permits market. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/44985","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Montero, Juan-Pablo"},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"2002"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/44985"},{"kind":"oclc","value":"52304726"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/44985"}],"numbering":"MIT-CEEPR (Series) ; 02-004WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/44985","summary":["A tradeable permits market is said to be efficient when all affected firms trade permits until their marginal costs equal the market price. Detailed firm-level data are generally required to perform such an efficiency test, yet such information is rarely available. If firms face a declining target, however, and are allowed to bank permits, as has occured recently, aggregated data such as the evolution of the permits bank is sufficient to test for either less than optimal market participation or the exercise of market power. An application to the U.S. sulfur dioxide emission permits market is provided."],"timdex_record_id":"dspace:1721.1-44985","title":"Testing the efficiency of a tradeable permits market"},"highlight":{"summary":["Detailed firm-level <span class=\"highlight\">data</span> are generally required to perform such an efficiency test, yet such information","face a declining target, however, and are allowed to bank permits, as has occured recently, aggregated <span class=\"highlight\">data</span>"],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-50222","_score":2.2507024,"_source":{"citation":"Adelman, Morris Albert (1996): A review of Oil production capacity expansion costs for the Persian Gulf. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/50222","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Adelman, Morris Albert"},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"1996"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/50222"},{"kind":"oclc","value":"35721645"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/50222"}],"numbering":"MIT-CEEPR (Series) ; 96-006WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/50222","summary":["The U.S. Energy Information Agency has recently published a report prepared by Petroconsultants, Inc. that addresses the cost of expanding crude oil production capacity in the Persian Gulf. A study on this subject is much needed in view of the dwindling supply of data on such costs from this region; however, this report does not provide any data and does little more than present the consultants' assumptions. Where those assumptions can be checked against plausible extrapolations of costs elsewhere, the investment per well is too high and productivity per well is too low. The result is an overstatement of the needed investment per unit of output."],"timdex_record_id":"dspace:1721.1-50222","title":"A review of Oil production capacity expansion costs for the Persian Gulf"},"highlight":{"summary":["A study on this subject is much needed in view of the dwindling supply of <span class=\"highlight\">data</span> on such costs from this","region; however, this report does not provide any <span class=\"highlight\">data</span> and does little more than present the consultants"],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-50192","_score":2.2507024,"_source":{"citation":"Rodriguez, Diego, Stoker, Thomas M. (1993): Semiparametric measurement of environmental effects. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/50192","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Rodriguez, Diego"},{"kind":"author","value":"Stoker, Thomas M."},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"1993"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/50192"},{"kind":"oclc","value":"35719600"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/50192"}],"numbering":"MIT-CEEPR (Series) ; 93-008WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/50192","summary":["This paper gives the results of a semiparametric analysis of pollution effects on housing prices using the Boston Housing Data. The exposition introduces the basic ideas of modeling pollution impacts with hedonic price methods, discusses the standard log-linear model, and then introduces nonparametric estimation and semiparametric index models. We focus on the intuitive content and substantive results of the semiparametric analysis. We find that the impact of pollution is smaller than that previously estimated, and varies dramatically depending on the status level of the community. We give various interpretations of the findings, and contrast our methods with those used in previous analysis of the Boston Housing Data."],"timdex_record_id":"dspace:1721.1-50192","title":"Semiparametric measurement of environmental effects"},"highlight":{"summary":["results of a semiparametric analysis of pollution effects on housing prices using the Boston Housing <span class=\"highlight\">Data</span>","of the findings, and contrast our methods with those used in previous analysis of the Boston Housing <span class=\"highlight\">Data</span>"],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-45655","_score":2.1805835,"_source":{"citation":"Liski, Matti, Kauppi, Olli (2008): An Empirical Model of Imperfect Dynamic Competition and Application to Hydroelectricity Storage. Working Paper. https://dspace.mit.edu/handle/1721.1/45655","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Liski, Matti"},{"kind":"author","value":"Kauppi, Olli"}],"dates":[{"kind":"Publication date","value":"2008"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"issn","value":"2008-011"},{"kind":"uri","value":"http://hdl.handle.net/1721.1/45655"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/45655"}],"numbering":"MIT-CEEPR;08-011WP","source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/45655","summary":["The Nordic power market presents a unique opportunity for testing the nature and degree of market power in storage behavior due to preciseness of data on market fundamentals determining hydro resource use. We develop an explicit model of dynamic imperfect competition mapping the primitive distributions to market outcomes as a function of the market structure. We estimate the market structure that best explains the main behavioral patterns in pricing, storage, and production in years 2000-05. Exceptional events in the data allow us to identify a pattern for market power. We simulate the expected effiency loss from the pattern and limited scope for social losses. Market power however increases expected reservoir and price levels, and also implies an increase in price risk."],"timdex_record_id":"dspace:1721.1-45655","title":"An Empirical Model of Imperfect Dynamic Competition and Application to Hydroelectricity Storage"},"highlight":{"summary":["opportunity for testing the nature and degree of market power in storage behavior due to preciseness of <span class=\"highlight\">data</span>","Exceptional events in the <span class=\"highlight\">data</span> allow us to identify a pattern for market power."],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-45032","_score":2.0526834,"_source":{"citation":"Twomey, Paul (2005): A review of the monitoring of market power : the possible roles of TSOs in monitoring for market power issues in congested transmission systems. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/45032","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Twomey, Paul"},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"2005"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/45032"},{"kind":"oclc","value":"61193499"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/45032"}],"numbering":"MIT-CEEPR (Series) ; 05-002WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/45032","summary":["The paper surveys the literature and publicly available information on market power monitoring in electricity wholesale markets. After briefly reviewing definitions, strategies and methods of mitigating market power we examine the various methods of detecting market power that have been employed by academics and market monitors/regulators. These techniques include structural and behavioural indices and analysis as well as various simulation approaches. The applications of these tools range from spot market mitigation and congestion management through to long-term market design assessment and merger decisions. Various market-power monitoring units already track market behaviour and produce indices. Our survey shows that these units collect a large amount of data from various market participants and we identify the crucial role of the transmission system operators with their access to dispatch and system information. Easily accessible and comprehensive data supports effective market power monitoring and facilitates market design evaluation. The discretion required for effective market monitoring is facilitated by institutional independence."],"timdex_record_id":"dspace:1721.1-45032","title":"A review of the monitoring of market power : the possible roles of TSOs in monitoring for market power issues in congested transmission systems"},"highlight":{"summary":["Our survey shows that these units collect a large amount of <span class=\"highlight\">data</span> from various market participants and","Easily accessible and comprehensive <span class=\"highlight\">data</span> supports effective market power monitoring and facilitates market"],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-45031","_score":2.0526834,"_source":{"citation":"Labandeira Villot, Xavier, Labeaga, José María, Rodriguez, Miguel A. (2005): A residential energy demand system for Spain. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/45031","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Labandeira Villot, Xavier"},{"kind":"author","value":"Labeaga, José María"},{"kind":"author","value":"Rodriguez, Miguel A."},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"2005"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/45031"},{"kind":"oclc","value":"58725311"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/45031"}],"numbering":"MIT-CEEPR (Series) ; 05-001WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/45031","summary":["Sharp price fluctuations and increasing environmental and distributional concerns, among other issues, have led to a renewed academic interest in energy demand. In this paper we estimate, for the first time in Spain, an energy demand system with household microdata. In doing so, we tackle several econometric and data problems that are generally recognized to bias parameter estimates. This is obviously relevant, as obtaining correct price and income responses is essential if they may be used for assessing the economic consequences of hypothetical or real changes. With this objective, we combine data sources for a long time period and choose a demand system with flexible income and price responses. We also estimate the model in different sub-samples to capture varying responses to energy price changes by households living in rural, intermediate and urban areas. This constitutes a first attempt in the literature and it proved to be a very successful choice."],"timdex_record_id":"dspace:1721.1-45031","title":"A residential energy demand system for Spain"},"highlight":{"summary":["In doing so, we tackle several econometric and <span class=\"highlight\">data</span> problems that are generally recognized to bias parameter","With this objective, we combine <span class=\"highlight\">data</span> sources for a long time period and choose a demand system with flexible"],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-45027","_score":1.9941995,"_source":{"citation":"Kosobud, Richard F. (2004): The Chicago VOC trading system : the consequences of market design for performance. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/45027","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Kosobud, Richard F."},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"2004"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/45027"},{"kind":"oclc","value":"58724464"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/45027"}],"numbering":"MIT-CEEPR (Series) ; 04-019WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/45027","summary":["The Chicago cap-and-trade approach to regulating stationary source VOC emissions in the Chicago ozone non-attainment area is a pioneering program that could set a precedent for other urban areas troubled by high ozone concentrations. It holds out the promise of cost-effectiveness, innovation stimulation, and flexibility compared with traditional regulation. To appraise this program design and evaluate these objectives, this study analyzes four years of data since the inception of the program in 2000. The data reveal that while emissions are far below the cap, there are unexpectedly large banks, startling expirations, and low prices of tradable permits, all inconsistent with an effective market. We find that the market as designed has been constrained from reaching its objectives by the continuance and extension of an underlying layer of traditional regulation, and to a lesser extent by over-allotment of tradable permits. That is, traditional regulation and over-allotment, combined with a market design calling for a small reduction in emissions from baseline and a one-year limit on banking, explain the incongruous outcomes recorded in the market."],"timdex_record_id":"dspace:1721.1-45027","title":"The Chicago VOC trading system : the consequences of market design for performance"},"highlight":{"summary":["To appraise this program design and evaluate these objectives, this study analyzes four years of <span class=\"highlight\">data</span>","The <span class=\"highlight\">data</span> reveal that while emissions are far below the cap, there are unexpectedly large banks, startling"],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-70895","_score":1.9389558,"_source":{"citation":"WP-2012-004","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Eckaus, Richard S."}],"dates":[{"kind":"Publication date","value":"2012-05-21"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/70895"}],"languages":["en_US"],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/70895"}],"numbering":"CEEPR Working Papers;2012-004","publication_information":["MIT CEEPR"],"rights":[{"kind":"useAndReproduction"}],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/70895","summary":["Though the facts of global climate change are beyond doubt, there has been relatively limited information about its local consequences. Global climate models and their derivatives have provided often differing and unspecific indications. This paper demonstrates an effective approach for the determination of local and seasonal effects of global climate change using data for the United States. Examples are given for specific weather station sites and for sites across the U.S. in five longitudinal strips divided into four latitudinal strips. Mean temperature and precipitation data are subjected to thirty year moving averaging and linear time trend lines are estimated, for which, in almost all instances, the estimated coefficients are highly significant.\r\nWhile in some locations there have been significant weather effects of climate changes, in other locations the effects have been small and may even be perverse. Linear extrapolation into the future of the results for individual sites seems reliable, based on past experience.\r\nLocal weather patterns and local topographies modify the local effects of global climate change. An immediate implication of the results reported here is that there are significant local differences in the type and degree of adaptation to global climate change that should be considered."],"timdex_record_id":"dspace:1721.1-70895","title":"Local and Seasonal Effects in the U.S. of Global Climate Change"},"highlight":{"summary":["effective approach for the determination of local and seasonal effects of global climate change using <span class=\"highlight\">data</span>","Mean temperature and precipitation <span class=\"highlight\">data</span> are subjected to thirty year moving averaging and linear time"],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-50224","_score":1.9278227,"_source":{"citation":"Adelman, Morris Albert, Watkins, G. C. (1996): The value of United States oil and gas reserves. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/50224","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Adelman, Morris Albert"},{"kind":"author","value":"Watkins, G. C."},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"1996"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/50224"},{"kind":"oclc","value":"35721668"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/50224"}],"numbering":"MIT-CEEPR (Series) ; 96-004WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/50224","summary":["The object of this research is to estimate a time series, starting in 1979, for the value of in-ground oil reserves and natural gas reserves in the United States. Relatively good statistics exist for the physical quantities. (Regrettably, they will now be compiled only in alternate years.) Our task is to estimate the unit values. We focus mainly on data from the mid 1980s to the end of 1994."],"timdex_record_id":"dspace:1721.1-50224","title":"The value of United States oil and gas reserves"},"highlight":{"summary":["We focus mainly on <span class=\"highlight\">data</span> from the mid 1980s to the end of 1994."],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-45097","_score":1.8866903,"_source":{"citation":"Webster, Mort David, Nam, Junsang, Kimura, Yosuke, Jeffries, Harvey Edward, Vizuete, William Gustavo, Allen, David T. (2007): The effect of variability in industrial emissions on ozone formation in Houston, Texas. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/45097","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Webster, Mort David"},{"kind":"author","value":"Nam, Junsang"},{"kind":"author","value":"Kimura, Yosuke"},{"kind":"author","value":"Jeffries, Harvey Edward"},{"kind":"author","value":"Vizuete, William Gustavo"},{"kind":"author","value":"Allen, David T."},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"2007"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/45097"},{"kind":"oclc","value":"311866530"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/45097"}],"numbering":"MIT-CEEPR (Series) ; 07-008WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/45097","summary":["Ambient observations have indicated that high concentrations of ozone observed in the Houston/Galveston area are associated with plumes of highly reactive hydrocarbons, mixed with NOx, from industrial facilities. Ambient observations and industrial process data, such as mass flow rates for industrial flares, indicate that the VOCs associated with these industrial emissions can have significant temporal variability. To characterize the effect of this variability in emissions on ozone formation in Houston, data were collected on the temporal variability of industrial emissions or emission surrogates (e.g., mass flow rates to flares). The observed emissions variability was then used to construct region-wide emission inventories with variable industrial emissions, and the impacts of the variability on ozone formation were examined for two types of meteorological conditions, both of which lead to high ozone concentrations in Houston. The air quality simulations indicate that variability in industrial emissions has the potential to cause increases and decreases of 10-52 ppb (13-316%), or more, in ozone concentration. The largest of these differences are restricted to regions of 10-20 km2, but the variability also has the potential to increase region wide maxima in ozone concentrations by up to 12 ppb. Keywords: Photochemical Grid Model, highly reactive volatile organic compounds (HRVOC), ozone, uncertainty analysis, Monte Carlo simulation."],"timdex_record_id":"dspace:1721.1-45097","title":"The effect of variability in industrial emissions on ozone formation in Houston, Texas"},"highlight":{"summary":["Ambient observations and industrial process <span class=\"highlight\">data</span>, such as mass flow rates for industrial flares, indicate","To characterize the effect of this variability in emissions on ozone formation in Houston, <span class=\"highlight\">data</span> were"],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-45005","_score":1.8761477,"_source":{"citation":"Pindyck, Robert S. (2003): Volatility in natural gas and oil markets. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/45005","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Pindyck, Robert S."},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"2003"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/45005"},{"kind":"oclc","value":"53194037"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/45005"}],"numbering":"MIT-CEEPR (Series) ; 03-012WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/45005","summary":["Using daily futures price data, I examine the behavior of natural gas and crude oil price volatility since 1990. I test whether there has been a significant trend in volatility, whether there was a short-term increase in volatility during the time of the Enron collapse, and whether natural gas and crude oil price volatilities are interrelated. I also measure the persistence of shocks to volatility and discuss its implications for gas-and oil-related contingent claims."],"timdex_record_id":"dspace:1721.1-45005","title":"Volatility in natural gas and oil markets"},"highlight":{"summary":["Using daily futures price <span class=\"highlight\">data</span>, I examine the behavior of natural gas and crude oil price volatility"],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-51716","_score":1.8761477,"_source":{"citation":"Taschini, Luca, Grüll, Georg (2009-09): A Comparison of Reduced-Form Permit Price Models and their Empirical Performances. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/51716","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Taschini, Luca"},{"kind":"author","value":"Grüll, Georg"}],"dates":[{"kind":"Publication date","value":"2009-09"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"other","value":"2009-018"},{"kind":"uri","value":"http://hdl.handle.net/1721.1/51716"}],"languages":["en_US"],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/51716"}],"numbering":"MIT-CEEPR (Series);2009-018","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/51716","summary":["Equilibrium models have been proposed in literature with the aim of describing the evolution of the price of emission permits. This paper derives _rst estimation methods for the calibration of three competing equilibrium models. Second, it demonstrates how their reduced-form versions are inter-related. Third, by means of calibration to historical data, it is shown how these reduced-form models perform in the current price-evolution framework also with respect to standard continuous time stochastic models."],"timdex_record_id":"dspace:1721.1-51716","title":"A Comparison of Reduced-Form Permit Price Models and their Empirical Performances"},"highlight":{"summary":["Third, by means of calibration to historical <span class=\"highlight\">data</span>, it is shown how these reduced-form models perform"],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-50184","_score":1.8513354,"_source":{"citation":"Abel, Andrew B. (1995): Options, the value of capital, and investment. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/50184","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Abel, Andrew B."},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"1995"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/50184"},{"kind":"oclc","value":"35719430"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/50184"}],"numbering":"MIT-CEEPR (Series) ; 95-006WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/50184","summary":["Continuing rapid growth in U.S. gasoline consumption threatens to exacerbate environmental and congestion problems. We use flexible semiparametric and nonparametric methods to guide analysis of household gasoline consumption, and including this variable cuts the estimated income elasticity in half. Slower projected future growth in licensed drivers points to slower growth in gasoline consumption. A parsimonious representation of age, income, lifecycle and location effects is developed and tested. We show how flexible methods also helped reveal fundamental problems with the available price data."],"timdex_record_id":"dspace:1721.1-50184","title":"Options, the value of capital, and investment"},"highlight":{"summary":["We show how flexible methods also helped reveal fundamental problems with the available price <span class=\"highlight\">data</span>."],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}},{"_index":"dspace-2022-07-06t15-32-37z","_type":"_doc","_id":"dspace:1721.1-50215","_score":1.8513354,"_source":{"citation":"Schmalensee, Richard, Stoker, Thomas M. (1995): Household gasoline demand in the United States. MIT Center for Energy and Environmental Policy Research. Working Paper. https://dspace.mit.edu/handle/1721.1/50215","content_type":["Working Paper"],"contributors":[{"kind":"author","value":"Schmalensee, Richard"},{"kind":"author","value":"Stoker, Thomas M."},{"kind":"other","value":"Massachusetts Institute of Technology. Center for Energy and Environmental Policy Research."}],"dates":[{"kind":"Publication date","value":"1995"}],"file_formats":["application/pdf"],"format":"electronic resource","identifiers":[{"kind":"uri","value":"http://hdl.handle.net/1721.1/50215"},{"kind":"oclc","value":"35721241"}],"links":[{"kind":"Digital object URL","text":"Digital object URL","url":"http://hdl.handle.net/1721.1/50215"}],"numbering":"MIT-CEEPR (Series) ; 95-007WP.","publication_information":["MIT Center for Energy and Environmental Policy Research"],"source":"DSpace@MIT","source_link":"https://dspace.mit.edu/handle/1721.1/50215","summary":["Continuing rapid growth in U.S. gasoline consumption threatens to exacerbate environmental and congestion problems. We use flexible semiparametric and nonparametric methods to guide analysis of household gasoline consumption, and including this variable cuts the estimated income elasticity in half. Slower projected future growth in licensed drivers points to slower growth in gasoline consumption. A parsimonious representation of age, income, lifecycle and location effects is developed and tested. We show how flexible methods also helped reveal fundamental problems with the available price data."],"timdex_record_id":"dspace:1721.1-50215","title":"Household gasoline demand in the United States"},"highlight":{"summary":["We show how flexible methods also helped reveal fundamental problems with the available price <span class=\"highlight\">data</span>."],"source":["<span class=\"highlight\">DSpace@MIT</span>"]}}]},"aggregations":{"languages":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"en_us","doc_count":14}]},"content_type":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"working paper","doc_count":70}]},"collections":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[]},"subjects":{"doc_count":1,"subject_names":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"acid rain","doc_count":1},{"key":"emissions trading","doc_count":1},{"key":"sulphur dioxide","doc_count":1}]}},"content_format":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"electronic resource","doc_count":70}]},"literary_form":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[]},"source":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":"dspace@mit","doc_count":70}]},"contributors":{"doc_count":173,"contributor_names":{"doc_count_error_upper_bound":1,"sum_other_doc_count":84,"buckets":[{"key":"massachusetts institute of technology. center for energy and environmental policy research.","doc_count":46},{"key":"adelman, morris albert","doc_count":7},{"key":"ellerman, a. denny","doc_count":7},{"key":"pindyck, robert s.","doc_count":7},{"key":"stoker, thomas m.","doc_count":6},{"key":"watkins, g. c.","doc_count":4},{"key":"greenstone, michael","doc_count":3},{"key":"linn, joshua","doc_count":3},{"key":"liski, matti","doc_count":3},{"key":"montero, juan-pablo","doc_count":3}]}}}} + recorded_at: Wed, 06 Jul 2022 15:49:14 GMT +recorded_with: VCR 6.1.0