nucleardatapy 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

nucleardatapy/fig/nuc_setupRnpExp_fig.py

@@ -0,0 +1,120 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.ticker import AutoMinorLocator  # Import para minor ticks
+
+import nucleardatapy as nuda
+
+# Dictionary to map sources to LaTeX names
+SOURCE_LABELS_LATEX = {
+    "48Ca": r"$^{48}\mathrm{Ca}$",
+    "208Pb": r"$^{208}\mathrm{Pb}$"
+}
+
+def nuc_setupRnpExp_fig( pname ):
+    """
+    Generates neutron skin (R_skin) plots for each nucleus using data from the `SetupNeutronSkinExp` class.
+    """
+
+    print(f'Plot name: {pname}')
+    #
+    # Retrieve available sources (e.g., '48Ca', '208Pb')
+    sources, _ = nuda.nskin_exp()
+
+# Labels for the subplots
+    subplot_labels = ["(a)", "(b)"]  # Adjust this list based on the number of sources
+
+    # Iterate over each source to create individual plots
+    for idx, source in enumerate(sources):
+        # Lists to store data for the plot
+        labels = []  # Labels for references (e.g., 'Brissaud 1972')
+        rskin_values = []  # R_skin values
+        error_lower = []  # Lower errors
+        error_upper = []  # Upper errors
+        markers = []  # Marker types to customize the points
+
+        # Retrieve available calculations for the source
+        cals = nuda.nuc.rnp_exp_source(source)
+        
+        for cal in cals:
+            # Instantiate the object for the specific calculation
+            neutron_skin_calc = nuda.nuc.setupRnpExp(source=source, cal=cal)
+            
+            # Store data only if R_skin is available
+            if neutron_skin_calc.nskin is not None:
+                labels.append(neutron_skin_calc.label)  # Use `self.label` as label
+                rskin_values.append(neutron_skin_calc.nskin)
+                
+                # Replace `None` error values with 0.0
+                err_down = neutron_skin_calc.nskin_sig_do if neutron_skin_calc.nskin_sig_do is not None else 0.0
+                err_up = neutron_skin_calc.nskin_sig_up if neutron_skin_calc.nskin_sig_up is not None else 0.0
+                error_lower.append(err_down)
+                error_upper.append(err_up)
+                
+                # Ensure the marker is valid
+                marker = neutron_skin_calc.marker if neutron_skin_calc.marker else 'o'
+                markers.append(marker)
+
+        # Check if there is data to plot
+        if not rskin_values:
+            print(f"No data available for {source}.")
+            continue
+
+        # Plot configuration
+        fig, ax = plt.subplots(figsize=(10, 8))
+        x_positions = range(len(labels)+1)   # X-axis positions
+
+        # Add each point to the plot with vertical error bars
+        for i, (x, y, err_down, err_up, marker) in enumerate(zip(x_positions, rskin_values, error_lower, error_upper, markers)):
+            # Handle large errors (>= 1000) by limiting the bar to 0.1
+            adjusted_err_down = min(err_down, 0.2)
+            adjusted_err_up = min(err_up, 0.2)
+
+            # Add adjusted error bars
+            ax.errorbar(x, y, yerr=[[adjusted_err_down], [adjusted_err_up]], fmt=marker, markersize=8, capsize=0, label=labels[i])
+            
+            # Add arrow as cap for err_down >= 1000
+            if err_down >= 1000:
+                ax.plot([x], [y - adjusted_err_down], marker="v", color="grey", markersize=8)
+
+            # Add arrow as cap for err_up >= 1000
+            if err_up >= 1000:
+                ax.plot([x], [y + adjusted_err_up], marker="^", color="grey", markersize=8)
+
+        nsav = nuda.nuc.setupRnpAverage(source=source)
+        # print('label:', nsav.label)
+        if nsav.nskin_cen is not None:
+            ax.errorbar(len(labels), nsav.nskin_cen, yerr=nsav.sig_std, label=nsav.label, 
+                       color='red', marker='o', markersize=10, linestyle='solid', linewidth=3)        
+        labels.append(nsav.label)
+        # Fixed y-axis configuration
+        ax.set_ylim([0, 0.5])  # Fixed scale from 0 to 0.5 on the y-axis
+
+        # X-axis configuration
+        ax.set_xticks(x_positions)
+        ax.set_xticklabels(labels, rotation=45, ha="right", fontsize=15)
+
+        # Y-axis configuration and layout
+        # Increase font size for y-axis numbers
+        ax.tick_params(axis='y', labelsize=15)  # Adjust the font size as desired
+        ax.set_ylabel(rf"$R_{{\rm{{skin}}}}$ {SOURCE_LABELS_LATEX[source]} (fm)", fontsize=15)
+        # ax.set_xlabel(f"References for {SOURCE_LABELS_LATEX[source]}", fontsize=14)
+        # ax.grid(True, linestyle="--", alpha=0.5)
+
+        # Adjust the legend (only if there are valid labels)
+        # ax.legend(loc="upper left", bbox_to_anchor=(1, 1), fontsize=10)
+
+        # Add subplot label (e.g., "(a)", "(b)") in the top right corner
+        ax.text(0.95, 0.95, subplot_labels[idx], transform=ax.transAxes, fontsize=15,
+                verticalalignment='top', horizontalalignment='right')
+
+        # Add minor ticks on y-axis
+        ax.yaxis.set_minor_locator(AutoMinorLocator())
+        ax.tick_params(axis='y', which='minor', length=4, color='gray')  # Style for minor ticks
+
+        # Final adjustments and save the plot
+        #plt.tight_layout()
+        if pname is not None:
+        	plt.savefig(pname, dpi=200)
+        	plt.close()
+        
+        print(f"Plot saved: {pname}")

nucleardatapy/fig/nuc_setupRnpTheo_fig.py

@@ -0,0 +1,134 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.ticker import AutoMinorLocator  # Import para minor ticks
+
+import nucleardatapy as nuda
+
+# Dictionary to map sources to LaTeX names
+SOURCE_LABELS_LATEX = {
+    "48Ca": r"$^{48}\mathrm{Ca}$",
+    "208Pb": r"$^{208}\mathrm{Pb}$"
+}
+
+# Directory containing the model data tables
+MODEL_TABLES_DIR = nuda.param.path_data + '/NeutronSkin/'
+
+# Define markers and colors for each model
+MODEL_STYLES = {
+    "skyrme": {"color": "blue", "marker": "s", "label": "Skyrme"},
+    "nlrh": {"color": "red", "marker": "^", "label": "NLRH"},
+    "ddrh": {"color": "green", "marker": "D", "label": "DDRH"}
+}
+
+def read_model_data(directory, source):
+    model_data = {}
+    for filename in os.listdir(directory):
+        if filename.endswith(".dat") and source in filename:
+            model_name = filename.split("Nskin")[0].lower()
+            filepath = os.path.join(directory, filename)
+            data = []
+            with open(filepath, 'r') as file:
+                for line in file:
+                    if line.startswith("#") or not line.strip():
+                        continue
+                    parts = line.split()
+                    param = parts[0]
+                    rn, rp, rskin = map(float, parts[1:4])
+                    data.append((param, rn, rp, rskin))
+            model_data[model_name] = np.array(data, dtype=object)
+            if nuda.env.verb:
+                print(f"Loaded model data for {model_name}: {model_data[model_name]}")
+    return model_data
+
+def nuc_setupRnpExp_fig( pname ):
+
+    print(f'Plot name: {pname}')
+
+    sources, _ = nuda.nuc.rnp_exp()
+    subplot_labels = ["(a)", "(b)"]
+
+    for idx, source in enumerate(sources):
+        labels = []
+        rskin_values = []
+        error_lower = []
+        error_upper = []
+        xexp = []
+
+        cals = nuda.nuc.rnp_exp_source(source)
+        for i, cal in enumerate(cals):
+            neutron_skin_calc = nuda.nuc.setupRnpExp(source=source, cal=cal)
+            if neutron_skin_calc.nskin is not None:
+                labels.append(neutron_skin_calc.label)
+                rskin_values.append(neutron_skin_calc.nskin)
+                xexp.append(i)
+                err_down = neutron_skin_calc.nskin_sig_do if neutron_skin_calc.nskin_sig_do is not None else 0.0
+                err_up = neutron_skin_calc.nskin_sig_up if neutron_skin_calc.nskin_sig_up is not None else 0.0
+                error_lower.append(err_down)
+                error_upper.append(err_up)
+
+        model_data = read_model_data(MODEL_TABLES_DIR, source)
+        combined_rskin = []
+        combined_errors = []
+        combined_markers = []
+        combined_colors = []
+        xtheo = []
+
+        for model_name, data in model_data.items():
+            for j, (_, _, _, rskin) in enumerate(data):
+                x_position = xexp[j % len(xexp)] + 0.5  # Cycle through xexp and offset by 0.5
+                xtheo.append(x_position)
+                combined_rskin.append(rskin)
+                combined_errors.append((0.0, 0.0))
+                combined_markers.append(MODEL_STYLES[model_name]["marker"])
+                combined_colors.append(MODEL_STYLES[model_name]["color"])
+
+        if nuda.env.verb:
+            print(f"Experimental positions for {source}: {xexp}")
+            print(f"Theoretical positions for {source}: {xtheo}")
+
+        fig, ax = plt.subplots(figsize=(10, 8))
+        for i, (x, y, err_down, err_up) in enumerate(zip(xexp, rskin_values, error_lower, error_upper)):
+            adjusted_err_down = min(err_down, 0.2)
+            adjusted_err_up = min(err_up, 0.2)
+            ax.errorbar(x, y, yerr=[[adjusted_err_down], [adjusted_err_up]], fmt='o', markersize=8, capsize=0, color='black', markerfacecolor='none')
+            if err_down >= 1000:
+                ax.plot([x], [y - adjusted_err_down], marker="v", color="black", markersize=8)
+            if err_up >= 1000:
+                ax.plot([x], [y + adjusted_err_up], marker="^", color="black", markersize=8)
+
+        nsav = nuda.nuc.setupRnpAverage(source=source)
+        if nsav.nskin_cen is not None:
+            ax.errorbar(len(labels), nsav.nskin_cen, yerr=nsav.sig_std, label=nsav.label, 
+                       color='k', marker='o', markersize=10, linestyle='solid', linewidth=3)           
+        # labels.append(nsav.label)
+
+        for i, (x, y, marker, color) in enumerate(zip(xtheo, combined_rskin, combined_markers, combined_colors)):
+            ax.plot(x, y, marker=marker, markersize=8, color=color)
+
+        # Add legend for experimental points
+        ax.scatter([], [], color='black', marker='o', facecolors='none', label='Experimental/Analysis')
+
+        # Add legend for theoretical models
+        for model_name, style in MODEL_STYLES.items():
+            ax.scatter([], [], color=style["color"], marker=style["marker"], label=style["label"])
+
+        ax.set_ylim([0, 0.5])
+        ax.set_xticks(xexp)
+        ax.set_xticklabels(labels, rotation=45, ha="right", fontsize=15)
+        ax.set_ylabel(rf"$R_{{\rm{{skin}}}}$ {SOURCE_LABELS_LATEX[source]} (fm)", fontsize=15)
+        ax.text(0.95, 0.95, subplot_labels[idx], transform=ax.transAxes, fontsize=15, verticalalignment='top', horizontalalignment='right')
+        
+        # Add minor ticks on y-axis
+        ax.yaxis.set_minor_locator(AutoMinorLocator())
+        ax.tick_params(axis='y', which='minor', length=4, color='gray')  # Style for minor ticks
+
+        ax.legend(loc="upper right", bbox_to_anchor=(0.5, 1), fontsize=12)
+
+        output_dir = "figs/"
+        os.makedirs(output_dir, exist_ok=True)
+        fig_name = f"{output_dir}plot_nuc_setup_nskin_theo-{source.replace(' ', '_')}.png"
+        plt.tight_layout()
+        plt.savefig(fig_name, dpi=200)
+        plt.close()
+
+        print(f"Plot saved: {fig_name}")

nucleardatapy/hnuc/__init__.py

@@ -2,7 +2,7 @@
 This module provides microscopic, phenomenological and experimental data constraints.
 """
 #
-from nucleardatapy.hnuc.setup_be1L_exp     import *
-from nucleardatapy.hnuc.setup_be2L_exp     import *
-from nucleardatapy.hnuc.setup_be1Xi_exp    import *
+from nucleardatapy.hnuc.setup_re1L_exp     import *
+from nucleardatapy.hnuc.setup_re2L_exp     import *
+from nucleardatapy.hnuc.setup_re1Xi_exp    import *
 #

nucleardatapy/matter/__init__.py

@@ -15,3 +15,4 @@ from nucleardatapy.matter.setup_hic            import *
 from nucleardatapy.matter.setup_nep            import *
 from nucleardatapy.matter.setup_nep_dist       import *
 from nucleardatapy.matter.setup_nep_model_dist import *
+from nucleardatapy.matter.setup_check          import *

nucleardatapy/matter/setup_check.py

@@ -0,0 +1,97 @@
+
+import numpy as np  # 1.15.0
+from scipy.interpolate import CubicSpline
+
+import nucleardatapy as nuda
+
+class setupCheck():
+    """
+    Instantiate a flag reflecting if e2a from `eos` passes through the reference `band` or not.
+
+    :param eos: object containing the eos to check.
+    :type eos: object. 
+    :param band: object containing the band employed to check the eos.
+    :type band: object. 
+    
+    **Attributes:**
+    
+    """
+    #
+    def __init__( self, eos, band ):
+        """
+        Parameters
+        ----------
+        eos : object.
+        Object containing the eos to check.
+        band: object.
+        Object containing the band employed to check the eos.
+        matter: string which can be: 'nm' (default), 'sm', or 'esym'.
+        """
+        #
+        if nuda.env.verb: print("Enter setupCheck()")
+        #
+        #: Attribute the object `eos`.
+        self.eos = eos
+        #: Attribute the object `band`.
+        self.band = band
+        #: Attribute the value for the variable `matter`.
+        self.matter = band.matter
+        #
+        if 'fit' in eos.model:
+            if self.matter.lower() == 'nm' or self.matter.lower() == 'sm':
+                self.x = np.insert( eos.den, 0, 0.0 )
+                self.y = np.insert( eos.e2a, 0, 0.0 )
+            elif self.matter.lower() == 'esym':
+                self.x = np.insert( eos.den, 0, 0.0 )
+                self.y = np.insert( eos.esym, 0, 0.0 )
+        else:
+            if self.matter.lower() == 'nm':
+                self.x = np.insert( eos.nm_den, 0, 0.0 )
+                self.y = np.insert( eos.nm_e2a, 0, 0.0 )
+            elif self.matter.lower() == 'sm':
+                self.x = np.insert( eos.sm_den, 0, 0.0 )
+                self.y = np.insert( eos.sm_e2a, 0, 0.0 )
+            elif self.matter.lower() == 'esym':
+                self.x = np.insert( eos.den, 0, 0.0 )
+                self.y = np.insert( eos.esym, 0, 0.0 )
+            else:
+                print('setup_check: issue with matter:',self.matter)
+                exit()
+        cs_e2a = CubicSpline( self.x, self.y )
+        self.eos_e2a = cs_e2a(band.den)
+        flag = True
+        for ind,den in enumerate(band.den):
+            #if abs(cs_e2a(den)-band.e2a[ind]) > band.e2a_std[ind]:
+            if abs(self.eos_e2a[ind]-band.e2a[ind]) > band.e2a_std[ind]:
+                flag = False
+        #: Attribute is eos is inside the band.
+        self.isInside = flag
+        #: Attribute is eos is outside the band.
+        self.isOutside = not flag
+        #
+        self.den_unit = 'fm$^{-3}$'
+        self.e2a_unit = 'MeV'
+        #
+        if nuda.env.verb: print("Exit setupCheck()")
+    #
+    def print_outputs( self ):
+        """
+        Method which print outputs on terminal's screen.
+        """
+        print("")
+        #
+        if nuda.env.verb: print("Enter print_outputs()")
+        #
+        print("- Print output:")
+        print('For matter:',self.matter)
+        print('EOS:')
+        if self.x is not None: print(f"   den: {np.round(self.x,2)} in {self.den_unit}")
+        if self.y is not None: print(f"   e2a: {np.round(self.y,2)} in {self.e2a_unit}")
+        print('BAND:')
+        if self.band.den is not None: print(f"   den: {np.round(self.band.den,2)} in {self.den_unit}")
+        if self.band.e2a is not None: print(f"   e2a: {np.round(self.band.e2a,2)} in {self.e2a_unit}")
+        if self.band.e2a_std is not None: print(f"   e2a_std: {np.round(self.band.e2a_std,2)} in {self.e2a_unit}")
+        #
+        if nuda.env.verb: print("Exit print_outputs()")
+        #
+

nucleardatapy/matter/setup_ffg.py

@@ -358,19 +358,26 @@ class setupFFGLep():
         #: Attribute muon Fermi energy (degeneracy = 2)
         self.eF_mu = np.sqrt( nuda.cst.mmuc2**2 + (nuda.cst.hbc*self.kf_mu)**2 )
         #: Attribute FFG energy per particle (degeneracy = 2)
-        self.e2v_el, self.e2a_el = feden( 2.0, self.kf_el, nuda.cst.mec2 )
-        self.e2v_mu, self.e2a_mu = feden( 2.0, self.kf_mu, nuda.cst.mmuc2 )
+        # energy
+        self.e2v_el, self.e2n_el = feden( 2.0, self.kf_el, nuda.cst.mec2 )
+        self.e2v_mu, self.e2n_mu = feden( 2.0, self.kf_mu, nuda.cst.mmuc2 )
         self.e2v_lep = self.e2v_el + self.e2v_mu
+        self.e2n_lep = self.e2v_lep / self.den_lep
         #self.e2a_el = self.e2v_el / self.den_e
-        self.e2a_el_int = self.e2a_el - nuda.cst.mec2*self.den_el / ( self.den_lep )
-        #self.e2a_mu = self.e2v_mu / self.den_mu
-        self.e2a_mu_int = self.e2a_mu - nuda.cst.mmuc2*self.den_mu / ( self.den_lep )
-        self.e2a_lep = self.e2a_el + self.e2a_mu
-        self.e2a_int_lep = self.e2a_el_int + self.e2a_mu_int
+        # internal energy
+        self.e2v_el_int = self.e2v_el - nuda.cst.mec2*self.den_el
+        self.e2n_el_int = self.e2v_el_int / self.den_el
+        self.e2v_mu_int = self.e2v_mu - nuda.cst.mmuc2*self.den_mu
+        self.e2n_mu_int = np.zeros( np.size(self.den_mu) )
+        for k,n_mu in enumerate(self.den_mu):
+            if n_mu > 0.0:
+                self.e2n_mu_int[k] = self.e2v_mu_int[k] / self.den_mu[k]
+        self.e2v_lep_int = self.e2v_el_int + self.e2v_mu_int
+        self.e2n_lep_int = self.e2v_lep_int / self.den_lep
         #: Attribute FFG pressure (degeneracy = 2)
         self.pre_el = fpres( 2.0, self.kf_el, nuda.cst.mec2)
         self.pre_mu = fpres( 2.0, self.kf_mu, nuda.cst.mmuc2)
-        self.pre_lep = self.pre_el + self.pre_mu
+        self.pre_lep = self.x_el * self.pre_el + self.x_mu * self.pre_mu
         #: Attribute enthalpy
         self.h2v_el = self.e2v_el + self.pre_el
         self.h2v_mu = self.e2v_mu + self.pre_mu