From 9c1f33a5e49e5708dd2e2e4eba7b32bdbf3901a2 Mon Sep 17 00:00:00 2001 From: zhoutz <519705198@qq.com> Date: Sat, 9 Nov 2024 04:53:21 +0800 Subject: [PATCH] Add download_compose module and demostration notebooks. --- .gitignore | 3 +- EOSgenerators/Compose_eos.py | 5 +- EOSgenerators/download_compose.py | 79 +++++ Test_Case/DownloadCompose.ipynb | 459 ++++++++++++++++++++++++++++++ docs/source/DownloadCompose.ipynb | 459 ++++++++++++++++++++++++++++++ 5 files changed, 1002 insertions(+), 3 deletions(-) create mode 100644 EOSgenerators/download_compose.py create mode 100644 Test_Case/DownloadCompose.ipynb create mode 100644 docs/source/DownloadCompose.ipynb diff --git a/.gitignore b/.gitignore index 46c9745..0a087f0 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ __pycache__/ -.DS_Store \ No newline at end of file +.DS_Store +downloads/ \ No newline at end of file diff --git a/EOSgenerators/Compose_eos.py b/EOSgenerators/Compose_eos.py index 887155e..055fe77 100644 --- a/EOSgenerators/Compose_eos.py +++ b/EOSgenerators/Compose_eos.py @@ -45,7 +45,7 @@ lalpconvert = 755397844024.145 # pressure laleconvert = 755407089027.154 # energy density -def read_compose(eosdir="./filesCompose/", eos_prefix="eos",nptsmin = 100): +def read_compose(eosdir="./filesCompose", eos_prefix="/eos",nptsmin = 100,eosname=None): """ Routine which reads the data from the original EoS model, Compose format is assumed @@ -122,7 +122,8 @@ def read_compose(eosdir="./filesCompose/", eos_prefix="eos",nptsmin = 100): p_compose[i]=float(tmp[3])*nB_compose[i] # pressure eps_compose[i]=(float(tmp[9])+ 1.0)*m_n*nB_compose[i] # energy density - eosname = read_README(eosdir) + if eosname is None: + eosname = read_README(eosdir) eps_gcm3 = eps_compose*MeVfm3_to_gcm3 p_dyncm2 = p_compose*MeVfm3_to_dyncm2 diff --git a/EOSgenerators/download_compose.py b/EOSgenerators/download_compose.py new file mode 100644 index 0000000..3da3b25 --- /dev/null +++ b/EOSgenerators/download_compose.py @@ -0,0 +1,79 @@ +import requests +import re +import shutil +from lxml import etree +from pathlib import Path + + +class DownloadCompose: + table_link = "https://compose.obspm.fr/table" + base_link = "https://compose.obspm.fr" + target_files = ("eos.t", "eos.nb", "eos.thermo") + + def __init__(self, download_dir=Path("./downloads/compose")): + self.download_dir = download_dir + self.title_and_link = DownloadCompose.get_title_and_link() + + def get_title_and_link(): + print(f"DownloadCompose: Fetching data from {DownloadCompose.table_link} \n...") + r = requests.get(DownloadCompose.table_link) + # print(f"{r.status_code=}") + # print(f"{r.encoding=}") + tree = etree.HTML(r.text) + odd_line = tree.xpath("//tr[@class='odd']") + even_line = tree.xpath("//tr[@class='even']") + all_line = odd_line + even_line + print( + f"DownloadCompose: Find {len(all_line)} EOS data on website {DownloadCompose.table_link}" + ) + ret = {} + for line in all_line: + title = line.xpath("td[2]/text()")[0].strip() + link = line.xpath(".//@href")[0] + id = int(re.search(r"\d+", link).group()) + if id in ret: + raise ValueError(f"Duplicate id={id}") + ret[id] = (title, link) + return dict(sorted(ret.items())) + + def print_eos_list(self): + for id, (title, _) in self.title_and_link.items(): + print(f"id = {id:3}, name = {title}") + + def eos_name(self, id: int): + return self.title_and_link[id][0] + + def eos_download_dir(self, id: int): + dir = self.download_dir / f"{id:03}" + dir.mkdir(parents=True, exist_ok=True) + return dir + + def requests_download(url: str, folder, force=False): + local_filename = Path(folder) / url.split("/")[-1] + if local_filename.exists() and not force: + print(f"{local_filename} already exists, skip download {url}") + return + + with requests.get(url, stream=True, allow_redirects=True) as r: + with open(local_filename, "wb") as f: + shutil.copyfileobj(r.raw, f) + print(f"Downloaded {url} to {local_filename}") + + def download_id(self, id: int, force=False): + _, tail_link = self.title_and_link[id] + eos_link = DownloadCompose.base_link + tail_link + r = requests.get(eos_link) + tree = etree.HTML(r.text) + hrefs = tree.xpath("//a/@href") + # print(f"{hrefs=}") + target_hrefs = [ + href for href in hrefs if href.endswith(DownloadCompose.target_files) + ] + # print(f"{target_hrefs=}") + for href in target_hrefs: + url = DownloadCompose.base_link + href + DownloadCompose.requests_download( + url, + self.eos_download_dir(id), + force=force, + ) diff --git a/Test_Case/DownloadCompose.ipynb b/Test_Case/DownloadCompose.ipynb new file mode 100644 index 0000000..39097d4 --- /dev/null +++ b/Test_Case/DownloadCompose.ipynb @@ -0,0 +1,459 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Usage of download_compose Module\n", + "Tianzhe Zhou 2024/11/9" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[CompOSE](https://compose.obspm.fr/table)(CompStar Online Supernovae Equations of State)\n", + "is a database that provides data tables for different state of the art equations of state (EoS) ready for further usage in astrophysical applications, nuclear physics and beyond.\n", + "\n", + "In this notebook, we will demonstrate how to use the `download_compose` module to download the data from the CompOSE database." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DownloadCompose: Fetching data from https://compose.obspm.fr/table \n", + "...\n", + "DownloadCompose: Find 308 EOS data on website https://compose.obspm.fr/table\n" + ] + } + ], + "source": [ + "# First, import the class that we need to use\n", + "from EOSgenerators.download_compose import DownloadCompose\n", + "\n", + "# Then, create an instance of the class\n", + "# This will automatically fetch the latest version of all available\n", + "# EOS names and their corresponding download links\n", + "dc = DownloadCompose()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "id = 1, name = HS(DD2) neutron matter (no electrons)\n", + "id = 2, name = HS(DD2) neutron matter (with electrons)\n", + "id = 3, name = HS(FSG) neutron matter (no electrons)\n", + "id = 4, name = HS(FSG) neutron matter (with electrons)\n", + "id = 5, name = HS(IUF) neutron matter (no electrons)\n", + "id = 6, name = HS(IUF) neutron matter (with electrons)\n", + "id = 7, name = HS(NL3) neutron matter (no electrons)\n", + "id = 8, name = HS(NL3) neutron matter (with electrons)\n", + "id = 9, name = HS(TM1) neutron matter (no electrons)\n", + "id = 10, name = HS(TM1) neutron matter (with electrons)\n", + "id = 11, name = HS(TMA) neutron matter (no electrons)\n", + "id = 12, name = HS(TMA) neutron matter (with electrons)\n", + "id = 13, name = SFH(SFHo) neutron matter (no electrons)\n", + "id = 14, name = SFH(SFHo) neutron matter (with electrons)\n", + "id = 15, name = SFH(SFHx) neutron matter (no electrons)\n", + "id = 16, name = SFH(SFHx) neutron matter (with electrons)\n", + "id = 17, name = HS(DD2) (no electrons)\n", + "id = 18, name = HS(DD2) (with electrons)\n", + "id = 19, name = HS(FSG) (no electrons)\n", + "id = 20, name = HS(FSG) (with electrons)\n", + "id = 21, name = HS(IUF) (no electrons)\n", + "id = 22, name = HS(IUF) (with electrons)\n", + "id = 23, name = HS(NL3) (no electrons)\n", + "id = 24, name = HS(NL3) (with electrons)\n", + "id = 25, name = HS(TM1) (no electrons)\n", + "id = 26, name = HS(TM1) (with electrons)\n", + "id = 27, name = HS(TMA) (no electrons)\n", + "id = 28, name = HS(TMA) (with electrons)\n", + "id = 29, name = GROM(LS220L) (with Lambdas, no low densities)\n", + "id = 30, name = GROM(LS220L) (with Lambdas, with low densities)\n", + "id = 31, name = LS(LS220) (no low densities)\n", + "id = 32, name = LS(LS220) (with low densities)\n", + "id = 33, name = SFH(SFHo) (no electrons)\n", + "id = 34, name = SFH(SFHo) (with electrons)\n", + "id = 35, name = SFH(SFHx) (no electrons)\n", + "id = 36, name = SFH(SFHx) (with electrons)\n", + "id = 37, name = SHO(FSU1) (no electrons)\n", + "id = 38, name = SHO(FSU1) (with electrons)\n", + "id = 39, name = SHO(FSU2) (with electrons)\n", + "id = 40, name = SHO(FSU2) (no electrons)\n", + "id = 41, name = SHT(NL3) (no electrons)\n", + "id = 42, name = SHT(NL3) (with electrons)\n", + "id = 43, name = BHB(DD2L) (no electrons)\n", + "id = 44, name = BHB(DD2L) (with electrons)\n", + "id = 45, name = BHB(DD2Lphi) (with electrons)\n", + "id = 46, name = BHB(DD2Lphi) (no electrons)\n", + "id = 47, name = SHO(FSU1) (no electrons)\n", + "id = 48, name = SHO(FSU1) (with electrons)\n", + "id = 49, name = SHO(FSU2) (no electrons)\n", + "id = 50, name = SHO(FSU2) (with electrons)\n", + "id = 51, name = SHT(NL3) (no electrons)\n", + "id = 52, name = SHT(NL3) (with electrons)\n", + "id = 53, name = GDTB(DDHdelta)\n", + "id = 54, name = GM(GM1)\n", + "id = 55, name = OPGR(GM1Y4) (with hyperons)\n", + "id = 56, name = STOS(TM1) neutron matter (original version)\n", + "id = 57, name = STOS(TM1) neutron matter (new version)\n", + "id = 58, name = STOS(TM1L) neutron and Lambda matter\n", + "id = 59, name = STOS(TM1) zero temperature (new version)\n", + "id = 60, name = STOS(TM1) zero temperature (original version)\n", + "id = 61, name = STOS(TM1) with Lambda zero temperature\n", + "id = 62, name = STOS(TM1L) with Lambda hyperons\n", + "id = 63, name = STOS(TM1) (new version)\n", + "id = 64, name = STOS(TM1) (original version)\n", + "id = 65, name = OPGR(GM1Y5) (with hyperons)\n", + "id = 66, name = OPGR(GM1Y6) (with hyperons)\n", + "id = 67, name = OPGR(DDHdeltaY4) (with hyperons)\n", + "id = 68, name = APR(APR)\n", + "id = 69, name = BBB(BHF-BBB2)\n", + "id = 70, name = SFHPST(TM1B145), with electrons\n", + "id = 71, name = STOS(TM1) (new version) with electrons\n", + "id = 72, name = STOS(TM1L) with Lambda hyperons and electrons\n", + "id = 73, name = SFHPST(TM1B139) with electrons\n", + "id = 74, name = SFHPST(TM1B155) with electrons\n", + "id = 75, name = SFHPST(TM1B165) with electrons (B165)\n", + "id = 76, name = IOTSY(TM1Y30) Sigma potential 30 MeV\n", + "id = 77, name = IOTSY(TM1Y30pi) with pions, Sigma potential 30 MeV\n", + "id = 78, name = IOTSY(TM1Y90pi) with pions, Sigma potential 90 MeV\n", + "id = 79, name = IOTSY(TM1Y0pi) with pions, Sigma potential 0 MeV\n", + "id = 80, name = IOTSY(TM1Y-30pi) with pions, Sigma potential -30 MeV\n", + "id = 81, name = IOTSY(TM1Y90) , Sigma potential 90 MeV)\n", + "id = 82, name = IOTSY(TM1Y0), Sigma potential 0 MeV\n", + "id = 83, name = IOTSY(TM1Y-30), Sigma potential -30 MeV\n", + "id = 84, name = RG(SLY230a)\n", + "id = 85, name = RG(SLY2)\n", + "id = 86, name = RG(SLY9)\n", + "id = 87, name = RG(SKI2)\n", + "id = 88, name = RG(SkI3)\n", + "id = 89, name = RG(SkI4)\n", + "id = 90, name = RG(SkI5)\n", + "id = 91, name = RG(SkI6)\n", + "id = 92, name = RG(KDE0v1)\n", + "id = 93, name = RG(KDE0v)\n", + "id = 94, name = RG(SK255)\n", + "id = 95, name = RG(SK272)\n", + "id = 96, name = RG(SKa)\n", + "id = 97, name = RG(SKb)\n", + "id = 98, name = RG(SkMp)\n", + "id = 99, name = RG(SkOp)\n", + "id = 100, name = RG(Rs)\n", + "id = 101, name = NL3\n", + "id = 104, name = OMHN(DD2Y)\n", + "id = 105, name = TNTYST(KOST2) variational EoS (with electrons)\n", + "id = 106, name = TNTYST(KOST2) variational EoS (without electrons)\n", + "id = 107, name = TNTYST(KOST2) variational EoS at zero temperature (with electrons)\n", + "id = 108, name = TNTYST(KOST2) variational EoS at zero temperature (no electrons)\n", + "id = 109, name = TNTYST(KOST2) neutron matter (zero temperature)\n", + "id = 110, name = TNTYST(KOST2) neutron matter\n", + "id = 111, name = FYSS(TM1) (no electrons)\n", + "id = 112, name = FTNS(KOST2) variational EoS (no electrons)\n", + "id = 113, name = FYSS(TM1) (with electrons)\n", + "id = 114, name = FTNS(KOST2) variational EoS (with electrons)\n", + "id = 115, name = DNS(CMF) Hadronic (with electrons)\n", + "id = 116, name = DNS(CMF) Hadronic (cold neutron stars)\n", + "id = 117, name = DNS(CMF) Hadronic (no electrons)\n", + "id = 118, name = FOP(SFHoY) (with electrons)\n", + "id = 119, name = FOP(SFHoY) (no electrons)\n", + "id = 120, name = BL(chiral)\n", + "id = 121, name = BL(chiral) with crust\n", + "id = 123, name = RG(SLY4)\n", + "id = 134, name = RG(SLY4)\n", + "id = 136, name = PT(GRDF1_DD2)\n", + "id = 137, name = PT(GRDF2_DD2) old version\n", + "id = 138, name = DNS(CMF) hadronic (cold neutron stars) with crust\n", + "id = 139, name = BHK(QHC18)\n", + "id = 140, name = BFH(QHC19-B)\n", + "id = 141, name = SRO(SLy4) SNA version\n", + "id = 142, name = OOS(DD2_FRG) (2+1 flavors)\n", + "id = 143, name = OOS(DD2_FRG) (2 flavors)\n", + "id = 144, name = SNSH(TM1e)\n", + "id = 145, name = SNSH(TM1e) zero temperature\n", + "id = 146, name = SNSH(TM1e) neutron matter\n", + "id = 147, name = RG(SLy4) with neutrino opacities\n", + "id = 148, name = RG(SLY4) with neutrino opacities, extended version\n", + "id = 149, name = SRO(APR) SNA version\n", + "id = 150, name = BFH(QHC19-A)\n", + "id = 151, name = BFH(QHC19-C)\n", + "id = 152, name = BFH(QHC19-D)\n", + "id = 154, name = MBB(DD2K ) (no electrons)\n", + "id = 155, name = BBKF(DD2F-SF) quark-hadron model RDF 1.1 without leptons\n", + "id = 156, name = BBKF(DD2F-SF) quark-hadron model RDF 1.2 without leptons\n", + "id = 157, name = BBKF(DD2F-SF) quark-hadron model RDF 1.3 without leptons\n", + "id = 158, name = BBKF(DD2F-SF) quark-hadron model RDF 1.4 without leptons\n", + "id = 159, name = BBKF(DD2F-SF) quark-hadron model RDF 1.5 without leptons\n", + "id = 160, name = BBKF(DD2F-SF) quark-hadron model RDF 1.6 without leptons\n", + "id = 161, name = BBKF(DD2F-SF) quark-hadron model RDF 1.7 without leptons\n", + "id = 162, name = BBKF(DD2-SF) quark-hadron model RDF 1.8 without leptons\n", + "id = 163, name = BBKF(DD2-SF) quark-hadron model RDF 1.9 without leptons\n", + "id = 164, name = BBKF(DD2F-SF) quark-hadron model RDF 1.1\n", + "id = 165, name = BBKF(DD2F-SF) quark-hadron model RDF 1.2\n", + "id = 166, name = BBKF(DD2F-SF) quark-hadron model RDF 1.3\n", + "id = 167, name = BBKF(DD2F-SF) quark-hadron model RDF 1.4\n", + "id = 168, name = BBKF(DD2F-SF) quark-hadron model RDF 1.5\n", + "id = 169, name = BBKF(DD2F-SF) quark-hadron model RDF 1.6\n", + "id = 170, name = BBKF(DD2F-SF) quark-hadron model RDF 1.7\n", + "id = 171, name = BBKF(DD2-SF) quark-hadron model RDF 1.8\n", + "id = 172, name = BBKF(DD2-SF) quark-hadron model RDF 1.9\n", + "id = 173, name = SRO(NRAPR) NSE version\n", + "id = 174, name = SRO(SkAPR) SNA version\n", + "id = 175, name = SRO(KDE0v1) SNA version\n", + "id = 176, name = SRO(LS220*) SNA version\n", + "id = 177, name = SRO(LNS) SNA version\n", + "id = 178, name = SRO(LS220) SNA version\n", + "id = 180, name = DS(CMF)-1\n", + "id = 181, name = DS(CMF)-2\n", + "id = 182, name = DS(CMF)-3\n", + "id = 183, name = DS(CMF)-4\n", + "id = 184, name = DS(CMF)-5\n", + "id = 185, name = DS(CMF)-6\n", + "id = 186, name = DS(CMF)-7\n", + "id = 187, name = DS(CMF)-8\n", + "id = 188, name = DS(CMF)-1 with crust\n", + "id = 189, name = DS(CMF)-2 with crust\n", + "id = 190, name = DS(CMF)-3 with crust\n", + "id = 191, name = DS(CMF)-4 with crust\n", + "id = 192, name = DS(CMF)-5 with crust\n", + "id = 193, name = DS(CMF)-6 with crust\n", + "id = 194, name = DS(CMF)-7 with crust\n", + "id = 195, name = DS(CMF)-8 with crust\n", + "id = 196, name = OOS(DD2-FRG) with vector interactions(2 flavors)\n", + "id = 197, name = OOS(DD2-FRG) with vector interactions(2+1 flavors)\n", + "id = 198, name = JJ(VQCD(APR)), intermediate\n", + "id = 199, name = JJ(VQCD(APR)), stiff\n", + "id = 200, name = JJ(VQCD(APR)), soft\n", + "id = 201, name = MBB(HSDD2K) with electrons\n", + "id = 202, name = MBB(BHBLphiK) with electrons\n", + "id = 203, name = GPPVA(FSU2R) NS crust\n", + "id = 204, name = GPPVA(NL3wrL55) NS crust\n", + "id = 205, name = SDGTT(QMC-A), no leptons\n", + "id = 206, name = SDGTT(QMC-A) with leptons\n", + "id = 207, name = GPPVA(TM1e) NS crust\n", + "id = 208, name = GPPVA(FSU2H) NS crust\n", + "id = 209, name = GPPVA(FSU2) NS crust\n", + "id = 210, name = GPPVA(DD2) NS crust\n", + "id = 211, name = GPPVA(DDME2) NS crust\n", + "id = 212, name = GPPVA(TW) NS crust\n", + "id = 213, name = GPPVA(FSU2H) NS unified inner crust-core\n", + "id = 214, name = GPPVA(FSU2R) NS unified inner crust-core\n", + "id = 215, name = GPPVA(FSU2) NS unified inner crust-core\n", + "id = 216, name = GMSR(SLy5)\n", + "id = 217, name = GPPVA(DD2) NS unified inner crust-core\n", + "id = 218, name = GPPVA(DDME2) NS unified inner crust-core\n", + "id = 219, name = GPPVA(TW) NS unified inner crust-core\n", + "id = 220, name = GPPVA(NL3wrL55) NS unified inner crust-core\n", + "id = 221, name = GPPVA(TM1e) NS unified inner crust-core\n", + "id = 222, name = GMSR(LNS5)\n", + "id = 223, name = GMSR(BSK16)\n", + "id = 224, name = GMSR(BSK14)\n", + "id = 225, name = GMSR(RATP)\n", + "id = 227, name = GMSR(F0)\n", + "id = 228, name = GMSR(H1)\n", + "id = 229, name = GMSR(H2)\n", + "id = 230, name = GMSR(H3)\n", + "id = 231, name = GMSR(H4)\n", + "id = 232, name = GMSR(H5)\n", + "id = 233, name = GMSR(H7)\n", + "id = 234, name = GMSR(DHSL59)\n", + "id = 235, name = GMSR(DHSL69)\n", + "id = 236, name = KBH(QHC21_AT)\n", + "id = 237, name = KBH(QHC21_BT)\n", + "id = 238, name = KBH(QHC21_CT)\n", + "id = 239, name = KBH(QHC21_DT)\n", + "id = 240, name = KBH(QHC21_A)\n", + "id = 241, name = KBH(QHC21_B)\n", + "id = 242, name = KBH(QHC21_C)\n", + "id = 243, name = KBH(QHC21_D)\n", + "id = 244, name = R(DD2YDelta) 1.1-1.1 (no electrons)\n", + "id = 245, name = R(DD2YDelta) 1.1-1.1 (with electrons)\n", + "id = 246, name = R(DD2YDelta) 1.2-1.1 (with electrons)\n", + "id = 247, name = R(DD2YDelta) 1.2-1.1 (no electrons)\n", + "id = 248, name = R(DD2YDelta) 1.2-1.3 (with electrons)\n", + "id = 249, name = R(DD2YDelta) 1.2-1.3 (no electrons)\n", + "id = 250, name = R(DD2YDelta) 1.1-1.1 (cold NS)\n", + "id = 251, name = R(DD2YDelta) 1.2-1.3 (cold NS)\n", + "id = 252, name = R(DD2YDelta) 1.2-1.1 (cold NS)\n", + "id = 253, name = PCP(BSK24)\n", + "id = 254, name = VGBCMR(D1MStar)\n", + "id = 255, name = VGBCMR(D1M)\n", + "id = 256, name = PCP(BSK22)\n", + "id = 257, name = PCP(BSK25)\n", + "id = 258, name = PCP(BSK26)\n", + "id = 259, name = DS(CMF)-1 Hybrid\n", + "id = 260, name = DS(CMF)-2 Hybrid\n", + "id = 261, name = DS(CMF)-3 Hybrid\n", + "id = 262, name = DS(CMF)-4 Hybrid\n", + "id = 263, name = DS(CMF)-5 Hybrid\n", + "id = 264, name = DS(CMF)-6 Hybrid\n", + "id = 265, name = DS(CMF)-7 Hybrid\n", + "id = 266, name = DS(CMF)-8 Hybrid\n", + "id = 267, name = DS(CMF)-1 Hybrid with crust\n", + "id = 268, name = DS(CMF)-2 Hybrid with crust\n", + "id = 269, name = DS (CMF)-3 Hybrid with crust\n", + "id = 270, name = DS (CMF)-4 Hybrid with crust\n", + "id = 271, name = DS (CMF)-5 Hybrid with crust\n", + "id = 272, name = DS (CMF)-6 Hybrid with crust\n", + "id = 273, name = DS (CMF)-7 Hybrid with crust\n", + "id = 274, name = DS(CMF)-8 Hybrid with crust\n", + "id = 275, name = ABHT(QMC-RMF1)\n", + "id = 276, name = ABHT(QMC-RMF2)\n", + "id = 277, name = ABHT(QMC-RMF3)\n", + "id = 278, name = ABHT(QMC-RMF4)\n", + "id = 279, name = XMLSLZ(DDME2)\n", + "id = 280, name = XMLSLZ(DD-LZ1)\n", + "id = 281, name = XMLSLZ(DDME-X)\n", + "id = 282, name = XMLSLZ(GM1)\n", + "id = 283, name = XMLSLZ(MTVTC)\n", + "id = 284, name = XMLSLZ(NL3)\n", + "id = 285, name = XMLSLZ(PK1)\n", + "id = 286, name = XMLSLZ(PKDD)\n", + "id = 287, name = XMLSLZ(TM1)\n", + "id = 288, name = XMLSLZ(TW99)\n", + "id = 289, name = DEJ(DD2-VQCD) intermediate\n", + "id = 290, name = DEJ(DD2-VQCD) soft\n", + "id = 291, name = DEJ(DD2-VQCD) stiff\n", + "id = 292, name = PCGS(PCSB0)\n", + "id = 293, name = LPB(chiral) with electrons\n", + "id = 294, name = LPB(chiral)\n", + "id = 295, name = PCGS(PCSB1)\n", + "id = 296, name = PCGS(PCSB2)\n", + "id = 297, name = ABHT(QMC-RMF1)\n", + "id = 298, name = ABHT(QMC-RMF2)\n", + "id = 299, name = ABHT(QMC-RMF3)\n", + "id = 300, name = ABHT(QMC-RMF4)\n", + "id = 301, name = PT(GRDF2-DD2) new version\n", + "id = 302, name = PT(GRDF2-DD2) cold NS\n", + "id = 303, name = HJJSTV(VQCD)-intermediate\n", + "id = 304, name = HJJSTV(VQCD) soft\n", + "id = 305, name = HJJSTV(VQCD) stiff\n", + "id = 306, name = BL(chiral) with unified crust\n", + "id = 307, name = CMGO(GDFM-I)\n", + "id = 308, name = CMGO (GDFM-II)\n", + "id = 309, name = KRT(FSU2H*)\n", + "id = 310, name = SPG(M1) unified NS EoS\n", + "id = 311, name = SPG(M1) Crust NS EoS\n", + "id = 312, name = SPG(M2) unified NS EoS\n", + "id = 313, name = SPG(M3) unified NS EoS\n", + "id = 314, name = SPG(M4) unified NS EoS\n", + "id = 315, name = SPG(M5) unified NS EoS\n", + "id = 316, name = SPG(M2) Crust NS EoS\n", + "id = 317, name = SPG(M3) Crust NS EoS\n", + "id = 318, name = SPG(M4) Crust NS EoS\n", + "id = 319, name = SPG(M5) Crust NS EoS\n", + "id = 320, name = TSO(DDLS(30)-Y)\n", + "id = 321, name = TSO(DDLS(70)-Y)\n", + "id = 322, name = TSO(DDLS(70)-N)\n", + "id = 323, name = TSO(DDLS(50)-Y)\n", + "id = 324, name = TSO(DDLS(50)-N)\n", + "id = 325, name = TSO(DDLS(30)-N)\n" + ] + } + ], + "source": [ + "# Now, we can print the list of available EOS names.\n", + "# Each EOS name is related to a specific identifier,\n", + "# which we can use later to actually download the EOS data file.\n", + "dc.print_eos_list()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "downloads\\compose\\316\\eos.t already exists, skip download https://compose.obspm.fr/download/1D/Crust/M2/eos.t\n", + "downloads\\compose\\316\\eos.nb already exists, skip download https://compose.obspm.fr/download/1D/Crust/M2/eos.nb\n", + "downloads\\compose\\316\\eos.thermo already exists, skip download https://compose.obspm.fr/download/1D/Crust/M2/eos.thermo\n" + ] + } + ], + "source": [ + "# Now we pick the EOS with identifier 316 and download it.\n", + "id = 316\n", + "eosdir = dc.download_id(id)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t Nucleon masses used within the CompOSE tables :\t m_n = 938.90000 MeV and m_p = 938.90000 MeV\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# We use Compose_eos function to extract the EOS data from the downloaded file\n", + "from EOSgenerators import Compose_eos\n", + "import matplotlib.pyplot as plt\n", + "\n", + "eosdir = dc.eos_download_dir(id).as_posix()\n", + "eps, p, name = Compose_eos.read_compose(eosdir=eosdir, eosname=dc.eos_name(id))\n", + "\n", + "# Finally, we can plot the EOS data using matplotlib,\n", + "# to ensure that all the previous steps were successful.\n", + "plt.figure(dpi=100)\n", + "plt.plot(eps, p)\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Energy density [$g/cm^3$]\")\n", + "plt.ylabel(\"Pressure [$dyn/cm^2$]\")\n", + "plt.title(name)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/DownloadCompose.ipynb b/docs/source/DownloadCompose.ipynb new file mode 100644 index 0000000..39097d4 --- /dev/null +++ b/docs/source/DownloadCompose.ipynb @@ -0,0 +1,459 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Usage of download_compose Module\n", + "Tianzhe Zhou 2024/11/9" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[CompOSE](https://compose.obspm.fr/table)(CompStar Online Supernovae Equations of State)\n", + "is a database that provides data tables for different state of the art equations of state (EoS) ready for further usage in astrophysical applications, nuclear physics and beyond.\n", + "\n", + "In this notebook, we will demonstrate how to use the `download_compose` module to download the data from the CompOSE database." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DownloadCompose: Fetching data from https://compose.obspm.fr/table \n", + "...\n", + "DownloadCompose: Find 308 EOS data on website https://compose.obspm.fr/table\n" + ] + } + ], + "source": [ + "# First, import the class that we need to use\n", + "from EOSgenerators.download_compose import DownloadCompose\n", + "\n", + "# Then, create an instance of the class\n", + "# This will automatically fetch the latest version of all available\n", + "# EOS names and their corresponding download links\n", + "dc = DownloadCompose()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "id = 1, name = HS(DD2) neutron matter (no electrons)\n", + "id = 2, name = HS(DD2) neutron matter (with electrons)\n", + "id = 3, name = HS(FSG) neutron matter (no electrons)\n", + "id = 4, name = HS(FSG) neutron matter (with electrons)\n", + "id = 5, name = HS(IUF) neutron matter (no electrons)\n", + "id = 6, name = HS(IUF) neutron matter (with electrons)\n", + "id = 7, name = HS(NL3) neutron matter (no electrons)\n", + "id = 8, name = HS(NL3) neutron matter (with electrons)\n", + "id = 9, name = HS(TM1) neutron matter (no electrons)\n", + "id = 10, name = HS(TM1) neutron matter (with electrons)\n", + "id = 11, name = HS(TMA) neutron matter (no electrons)\n", + "id = 12, name = HS(TMA) neutron matter (with electrons)\n", + "id = 13, name = SFH(SFHo) neutron matter (no electrons)\n", + "id = 14, name = SFH(SFHo) neutron matter (with electrons)\n", + "id = 15, name = SFH(SFHx) neutron matter (no electrons)\n", + "id = 16, name = SFH(SFHx) neutron matter (with electrons)\n", + "id = 17, name = HS(DD2) (no electrons)\n", + "id = 18, name = HS(DD2) (with electrons)\n", + "id = 19, name = HS(FSG) (no electrons)\n", + "id = 20, name = HS(FSG) (with electrons)\n", + "id = 21, name = HS(IUF) (no electrons)\n", + "id = 22, name = HS(IUF) (with electrons)\n", + "id = 23, name = HS(NL3) (no electrons)\n", + "id = 24, name = HS(NL3) (with electrons)\n", + "id = 25, name = HS(TM1) (no electrons)\n", + "id = 26, name = HS(TM1) (with electrons)\n", + "id = 27, name = HS(TMA) (no electrons)\n", + "id = 28, name = HS(TMA) (with electrons)\n", + "id = 29, name = GROM(LS220L) (with Lambdas, no low densities)\n", + "id = 30, name = GROM(LS220L) (with Lambdas, with low densities)\n", + "id = 31, name = LS(LS220) (no low densities)\n", + "id = 32, name = LS(LS220) (with low densities)\n", + "id = 33, name = SFH(SFHo) (no electrons)\n", + "id = 34, name = SFH(SFHo) (with electrons)\n", + "id = 35, name = SFH(SFHx) (no electrons)\n", + "id = 36, name = SFH(SFHx) (with electrons)\n", + "id = 37, name = SHO(FSU1) (no electrons)\n", + "id = 38, name = SHO(FSU1) (with electrons)\n", + "id = 39, name = SHO(FSU2) (with electrons)\n", + "id = 40, name = SHO(FSU2) (no electrons)\n", + "id = 41, name = SHT(NL3) (no electrons)\n", + "id = 42, name = SHT(NL3) (with electrons)\n", + "id = 43, name = BHB(DD2L) (no electrons)\n", + "id = 44, name = BHB(DD2L) (with electrons)\n", + "id = 45, name = BHB(DD2Lphi) (with electrons)\n", + "id = 46, name = BHB(DD2Lphi) (no electrons)\n", + "id = 47, name = SHO(FSU1) (no electrons)\n", + "id = 48, name = SHO(FSU1) (with electrons)\n", + "id = 49, name = SHO(FSU2) (no electrons)\n", + "id = 50, name = SHO(FSU2) (with electrons)\n", + "id = 51, name = SHT(NL3) (no electrons)\n", + "id = 52, name = SHT(NL3) (with electrons)\n", + "id = 53, name = GDTB(DDHdelta)\n", + "id = 54, name = GM(GM1)\n", + "id = 55, name = OPGR(GM1Y4) (with hyperons)\n", + "id = 56, name = STOS(TM1) neutron matter (original version)\n", + "id = 57, name = STOS(TM1) neutron matter (new version)\n", + "id = 58, name = STOS(TM1L) neutron and Lambda matter\n", + "id = 59, name = STOS(TM1) zero temperature (new version)\n", + "id = 60, name = STOS(TM1) zero temperature (original version)\n", + "id = 61, name = STOS(TM1) with Lambda zero temperature\n", + "id = 62, name = STOS(TM1L) with Lambda hyperons\n", + "id = 63, name = STOS(TM1) (new version)\n", + "id = 64, name = STOS(TM1) (original version)\n", + "id = 65, name = OPGR(GM1Y5) (with hyperons)\n", + "id = 66, name = OPGR(GM1Y6) (with hyperons)\n", + "id = 67, name = OPGR(DDHdeltaY4) (with hyperons)\n", + "id = 68, name = APR(APR)\n", + "id = 69, name = BBB(BHF-BBB2)\n", + "id = 70, name = SFHPST(TM1B145), with electrons\n", + "id = 71, name = STOS(TM1) (new version) with electrons\n", + "id = 72, name = STOS(TM1L) with Lambda hyperons and electrons\n", + "id = 73, name = SFHPST(TM1B139) with electrons\n", + "id = 74, name = SFHPST(TM1B155) with electrons\n", + "id = 75, name = SFHPST(TM1B165) with electrons (B165)\n", + "id = 76, name = IOTSY(TM1Y30) Sigma potential 30 MeV\n", + "id = 77, name = IOTSY(TM1Y30pi) with pions, Sigma potential 30 MeV\n", + "id = 78, name = IOTSY(TM1Y90pi) with pions, Sigma potential 90 MeV\n", + "id = 79, name = IOTSY(TM1Y0pi) with pions, Sigma potential 0 MeV\n", + "id = 80, name = IOTSY(TM1Y-30pi) with pions, Sigma potential -30 MeV\n", + "id = 81, name = IOTSY(TM1Y90) , Sigma potential 90 MeV)\n", + "id = 82, name = IOTSY(TM1Y0), Sigma potential 0 MeV\n", + "id = 83, name = IOTSY(TM1Y-30), Sigma potential -30 MeV\n", + "id = 84, name = RG(SLY230a)\n", + "id = 85, name = RG(SLY2)\n", + "id = 86, name = RG(SLY9)\n", + "id = 87, name = RG(SKI2)\n", + "id = 88, name = RG(SkI3)\n", + "id = 89, name = RG(SkI4)\n", + "id = 90, name = RG(SkI5)\n", + "id = 91, name = RG(SkI6)\n", + "id = 92, name = RG(KDE0v1)\n", + "id = 93, name = RG(KDE0v)\n", + "id = 94, name = RG(SK255)\n", + "id = 95, name = RG(SK272)\n", + "id = 96, name = RG(SKa)\n", + "id = 97, name = RG(SKb)\n", + "id = 98, name = RG(SkMp)\n", + "id = 99, name = RG(SkOp)\n", + "id = 100, name = RG(Rs)\n", + "id = 101, name = NL3\n", + "id = 104, name = OMHN(DD2Y)\n", + "id = 105, name = TNTYST(KOST2) variational EoS (with electrons)\n", + "id = 106, name = TNTYST(KOST2) variational EoS (without electrons)\n", + "id = 107, name = TNTYST(KOST2) variational EoS at zero temperature (with electrons)\n", + "id = 108, name = TNTYST(KOST2) variational EoS at zero temperature (no electrons)\n", + "id = 109, name = TNTYST(KOST2) neutron matter (zero temperature)\n", + "id = 110, name = TNTYST(KOST2) neutron matter\n", + "id = 111, name = FYSS(TM1) (no electrons)\n", + "id = 112, name = FTNS(KOST2) variational EoS (no electrons)\n", + "id = 113, name = FYSS(TM1) (with electrons)\n", + "id = 114, name = FTNS(KOST2) variational EoS (with electrons)\n", + "id = 115, name = DNS(CMF) Hadronic (with electrons)\n", + "id = 116, name = DNS(CMF) Hadronic (cold neutron stars)\n", + "id = 117, name = DNS(CMF) Hadronic (no electrons)\n", + "id = 118, name = FOP(SFHoY) (with electrons)\n", + "id = 119, name = FOP(SFHoY) (no electrons)\n", + "id = 120, name = BL(chiral)\n", + "id = 121, name = BL(chiral) with crust\n", + "id = 123, name = RG(SLY4)\n", + "id = 134, name = RG(SLY4)\n", + "id = 136, name = PT(GRDF1_DD2)\n", + "id = 137, name = PT(GRDF2_DD2) old version\n", + "id = 138, name = DNS(CMF) hadronic (cold neutron stars) with crust\n", + "id = 139, name = BHK(QHC18)\n", + "id = 140, name = BFH(QHC19-B)\n", + "id = 141, name = SRO(SLy4) SNA version\n", + "id = 142, name = OOS(DD2_FRG) (2+1 flavors)\n", + "id = 143, name = OOS(DD2_FRG) (2 flavors)\n", + "id = 144, name = SNSH(TM1e)\n", + "id = 145, name = SNSH(TM1e) zero temperature\n", + "id = 146, name = SNSH(TM1e) neutron matter\n", + "id = 147, name = RG(SLy4) with neutrino opacities\n", + "id = 148, name = RG(SLY4) with neutrino opacities, extended version\n", + "id = 149, name = SRO(APR) SNA version\n", + "id = 150, name = BFH(QHC19-A)\n", + "id = 151, name = BFH(QHC19-C)\n", + "id = 152, name = BFH(QHC19-D)\n", + "id = 154, name = MBB(DD2K ) (no electrons)\n", + "id = 155, name = BBKF(DD2F-SF) quark-hadron model RDF 1.1 without leptons\n", + "id = 156, name = BBKF(DD2F-SF) quark-hadron model RDF 1.2 without leptons\n", + "id = 157, name = BBKF(DD2F-SF) quark-hadron model RDF 1.3 without leptons\n", + "id = 158, name = BBKF(DD2F-SF) quark-hadron model RDF 1.4 without leptons\n", + "id = 159, name = BBKF(DD2F-SF) quark-hadron model RDF 1.5 without leptons\n", + "id = 160, name = BBKF(DD2F-SF) quark-hadron model RDF 1.6 without leptons\n", + "id = 161, name = BBKF(DD2F-SF) quark-hadron model RDF 1.7 without leptons\n", + "id = 162, name = BBKF(DD2-SF) quark-hadron model RDF 1.8 without leptons\n", + "id = 163, name = BBKF(DD2-SF) quark-hadron model RDF 1.9 without leptons\n", + "id = 164, name = BBKF(DD2F-SF) quark-hadron model RDF 1.1\n", + "id = 165, name = BBKF(DD2F-SF) quark-hadron model RDF 1.2\n", + "id = 166, name = BBKF(DD2F-SF) quark-hadron model RDF 1.3\n", + "id = 167, name = BBKF(DD2F-SF) quark-hadron model RDF 1.4\n", + "id = 168, name = BBKF(DD2F-SF) quark-hadron model RDF 1.5\n", + "id = 169, name = BBKF(DD2F-SF) quark-hadron model RDF 1.6\n", + "id = 170, name = BBKF(DD2F-SF) quark-hadron model RDF 1.7\n", + "id = 171, name = BBKF(DD2-SF) quark-hadron model RDF 1.8\n", + "id = 172, name = BBKF(DD2-SF) quark-hadron model RDF 1.9\n", + "id = 173, name = SRO(NRAPR) NSE version\n", + "id = 174, name = SRO(SkAPR) SNA version\n", + "id = 175, name = SRO(KDE0v1) SNA version\n", + "id = 176, name = SRO(LS220*) SNA version\n", + "id = 177, name = SRO(LNS) SNA version\n", + "id = 178, name = SRO(LS220) SNA version\n", + "id = 180, name = DS(CMF)-1\n", + "id = 181, name = DS(CMF)-2\n", + "id = 182, name = DS(CMF)-3\n", + "id = 183, name = DS(CMF)-4\n", + "id = 184, name = DS(CMF)-5\n", + "id = 185, name = DS(CMF)-6\n", + "id = 186, name = DS(CMF)-7\n", + "id = 187, name = DS(CMF)-8\n", + "id = 188, name = DS(CMF)-1 with crust\n", + "id = 189, name = DS(CMF)-2 with crust\n", + "id = 190, name = DS(CMF)-3 with crust\n", + "id = 191, name = DS(CMF)-4 with crust\n", + "id = 192, name = DS(CMF)-5 with crust\n", + "id = 193, name = DS(CMF)-6 with crust\n", + "id = 194, name = DS(CMF)-7 with crust\n", + "id = 195, name = DS(CMF)-8 with crust\n", + "id = 196, name = OOS(DD2-FRG) with vector interactions(2 flavors)\n", + "id = 197, name = OOS(DD2-FRG) with vector interactions(2+1 flavors)\n", + "id = 198, name = JJ(VQCD(APR)), intermediate\n", + "id = 199, name = JJ(VQCD(APR)), stiff\n", + "id = 200, name = JJ(VQCD(APR)), soft\n", + "id = 201, name = MBB(HSDD2K) with electrons\n", + "id = 202, name = MBB(BHBLphiK) with electrons\n", + "id = 203, name = GPPVA(FSU2R) NS crust\n", + "id = 204, name = GPPVA(NL3wrL55) NS crust\n", + "id = 205, name = SDGTT(QMC-A), no leptons\n", + "id = 206, name = SDGTT(QMC-A) with leptons\n", + "id = 207, name = GPPVA(TM1e) NS crust\n", + "id = 208, name = GPPVA(FSU2H) NS crust\n", + "id = 209, name = GPPVA(FSU2) NS crust\n", + "id = 210, name = GPPVA(DD2) NS crust\n", + "id = 211, name = GPPVA(DDME2) NS crust\n", + "id = 212, name = GPPVA(TW) NS crust\n", + "id = 213, name = GPPVA(FSU2H) NS unified inner crust-core\n", + "id = 214, name = GPPVA(FSU2R) NS unified inner crust-core\n", + "id = 215, name = GPPVA(FSU2) NS unified inner crust-core\n", + "id = 216, name = GMSR(SLy5)\n", + "id = 217, name = GPPVA(DD2) NS unified inner crust-core\n", + "id = 218, name = GPPVA(DDME2) NS unified inner crust-core\n", + "id = 219, name = GPPVA(TW) NS unified inner crust-core\n", + "id = 220, name = GPPVA(NL3wrL55) NS unified inner crust-core\n", + "id = 221, name = GPPVA(TM1e) NS unified inner crust-core\n", + "id = 222, name = GMSR(LNS5)\n", + "id = 223, name = GMSR(BSK16)\n", + "id = 224, name = GMSR(BSK14)\n", + "id = 225, name = GMSR(RATP)\n", + "id = 227, name = GMSR(F0)\n", + "id = 228, name = GMSR(H1)\n", + "id = 229, name = GMSR(H2)\n", + "id = 230, name = GMSR(H3)\n", + "id = 231, name = GMSR(H4)\n", + "id = 232, name = GMSR(H5)\n", + "id = 233, name = GMSR(H7)\n", + "id = 234, name = GMSR(DHSL59)\n", + "id = 235, name = GMSR(DHSL69)\n", + "id = 236, name = KBH(QHC21_AT)\n", + "id = 237, name = KBH(QHC21_BT)\n", + "id = 238, name = KBH(QHC21_CT)\n", + "id = 239, name = KBH(QHC21_DT)\n", + "id = 240, name = KBH(QHC21_A)\n", + "id = 241, name = KBH(QHC21_B)\n", + "id = 242, name = KBH(QHC21_C)\n", + "id = 243, name = KBH(QHC21_D)\n", + "id = 244, name = R(DD2YDelta) 1.1-1.1 (no electrons)\n", + "id = 245, name = R(DD2YDelta) 1.1-1.1 (with electrons)\n", + "id = 246, name = R(DD2YDelta) 1.2-1.1 (with electrons)\n", + "id = 247, name = R(DD2YDelta) 1.2-1.1 (no electrons)\n", + "id = 248, name = R(DD2YDelta) 1.2-1.3 (with electrons)\n", + "id = 249, name = R(DD2YDelta) 1.2-1.3 (no electrons)\n", + "id = 250, name = R(DD2YDelta) 1.1-1.1 (cold NS)\n", + "id = 251, name = R(DD2YDelta) 1.2-1.3 (cold NS)\n", + "id = 252, name = R(DD2YDelta) 1.2-1.1 (cold NS)\n", + "id = 253, name = PCP(BSK24)\n", + "id = 254, name = VGBCMR(D1MStar)\n", + "id = 255, name = VGBCMR(D1M)\n", + "id = 256, name = PCP(BSK22)\n", + "id = 257, name = PCP(BSK25)\n", + "id = 258, name = PCP(BSK26)\n", + "id = 259, name = DS(CMF)-1 Hybrid\n", + "id = 260, name = DS(CMF)-2 Hybrid\n", + "id = 261, name = DS(CMF)-3 Hybrid\n", + "id = 262, name = DS(CMF)-4 Hybrid\n", + "id = 263, name = DS(CMF)-5 Hybrid\n", + "id = 264, name = DS(CMF)-6 Hybrid\n", + "id = 265, name = DS(CMF)-7 Hybrid\n", + "id = 266, name = DS(CMF)-8 Hybrid\n", + "id = 267, name = DS(CMF)-1 Hybrid with crust\n", + "id = 268, name = DS(CMF)-2 Hybrid with crust\n", + "id = 269, name = DS (CMF)-3 Hybrid with crust\n", + "id = 270, name = DS (CMF)-4 Hybrid with crust\n", + "id = 271, name = DS (CMF)-5 Hybrid with crust\n", + "id = 272, name = DS (CMF)-6 Hybrid with crust\n", + "id = 273, name = DS (CMF)-7 Hybrid with crust\n", + "id = 274, name = DS(CMF)-8 Hybrid with crust\n", + "id = 275, name = ABHT(QMC-RMF1)\n", + "id = 276, name = ABHT(QMC-RMF2)\n", + "id = 277, name = ABHT(QMC-RMF3)\n", + "id = 278, name = ABHT(QMC-RMF4)\n", + "id = 279, name = XMLSLZ(DDME2)\n", + "id = 280, name = XMLSLZ(DD-LZ1)\n", + "id = 281, name = XMLSLZ(DDME-X)\n", + "id = 282, name = XMLSLZ(GM1)\n", + "id = 283, name = XMLSLZ(MTVTC)\n", + "id = 284, name = XMLSLZ(NL3)\n", + "id = 285, name = XMLSLZ(PK1)\n", + "id = 286, name = XMLSLZ(PKDD)\n", + "id = 287, name = XMLSLZ(TM1)\n", + "id = 288, name = XMLSLZ(TW99)\n", + "id = 289, name = DEJ(DD2-VQCD) intermediate\n", + "id = 290, name = DEJ(DD2-VQCD) soft\n", + "id = 291, name = DEJ(DD2-VQCD) stiff\n", + "id = 292, name = PCGS(PCSB0)\n", + "id = 293, name = LPB(chiral) with electrons\n", + "id = 294, name = LPB(chiral)\n", + "id = 295, name = PCGS(PCSB1)\n", + "id = 296, name = PCGS(PCSB2)\n", + "id = 297, name = ABHT(QMC-RMF1)\n", + "id = 298, name = ABHT(QMC-RMF2)\n", + "id = 299, name = ABHT(QMC-RMF3)\n", + "id = 300, name = ABHT(QMC-RMF4)\n", + "id = 301, name = PT(GRDF2-DD2) new version\n", + "id = 302, name = PT(GRDF2-DD2) cold NS\n", + "id = 303, name = HJJSTV(VQCD)-intermediate\n", + "id = 304, name = HJJSTV(VQCD) soft\n", + "id = 305, name = HJJSTV(VQCD) stiff\n", + "id = 306, name = BL(chiral) with unified crust\n", + "id = 307, name = CMGO(GDFM-I)\n", + "id = 308, name = CMGO (GDFM-II)\n", + "id = 309, name = KRT(FSU2H*)\n", + "id = 310, name = SPG(M1) unified NS EoS\n", + "id = 311, name = SPG(M1) Crust NS EoS\n", + "id = 312, name = SPG(M2) unified NS EoS\n", + "id = 313, name = SPG(M3) unified NS EoS\n", + "id = 314, name = SPG(M4) unified NS EoS\n", + "id = 315, name = SPG(M5) unified NS EoS\n", + "id = 316, name = SPG(M2) Crust NS EoS\n", + "id = 317, name = SPG(M3) Crust NS EoS\n", + "id = 318, name = SPG(M4) Crust NS EoS\n", + "id = 319, name = SPG(M5) Crust NS EoS\n", + "id = 320, name = TSO(DDLS(30)-Y)\n", + "id = 321, name = TSO(DDLS(70)-Y)\n", + "id = 322, name = TSO(DDLS(70)-N)\n", + "id = 323, name = TSO(DDLS(50)-Y)\n", + "id = 324, name = TSO(DDLS(50)-N)\n", + "id = 325, name = TSO(DDLS(30)-N)\n" + ] + } + ], + "source": [ + "# Now, we can print the list of available EOS names.\n", + "# Each EOS name is related to a specific identifier,\n", + "# which we can use later to actually download the EOS data file.\n", + "dc.print_eos_list()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "downloads\\compose\\316\\eos.t already exists, skip download https://compose.obspm.fr/download/1D/Crust/M2/eos.t\n", + "downloads\\compose\\316\\eos.nb already exists, skip download https://compose.obspm.fr/download/1D/Crust/M2/eos.nb\n", + "downloads\\compose\\316\\eos.thermo already exists, skip download https://compose.obspm.fr/download/1D/Crust/M2/eos.thermo\n" + ] + } + ], + "source": [ + "# Now we pick the EOS with identifier 316 and download it.\n", + "id = 316\n", + "eosdir = dc.download_id(id)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t Nucleon masses used within the CompOSE tables :\t m_n = 938.90000 MeV and m_p = 938.90000 MeV\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# We use Compose_eos function to extract the EOS data from the downloaded file\n", + "from EOSgenerators import Compose_eos\n", + "import matplotlib.pyplot as plt\n", + "\n", + "eosdir = dc.eos_download_dir(id).as_posix()\n", + "eps, p, name = Compose_eos.read_compose(eosdir=eosdir, eosname=dc.eos_name(id))\n", + "\n", + "# Finally, we can plot the EOS data using matplotlib,\n", + "# to ensure that all the previous steps were successful.\n", + "plt.figure(dpi=100)\n", + "plt.plot(eps, p)\n", + "plt.xscale(\"log\")\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Energy density [$g/cm^3$]\")\n", + "plt.ylabel(\"Pressure [$dyn/cm^2$]\")\n", + "plt.title(name)\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}