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

nucleardatapy/nuc/setup_be_theo.py

@@ -5,22 +5,23 @@ import numpy as np  # 1.15.0
 
 import nucleardatapy as nuda
 
-def delta_emp( A, Z, formula ):
-   if formula == 'classic':
-      return 12.0 / A**0.5
-   elif formula == 'Vogel':
-      return ( 7.2 - 44.0 * ( 1.0 - 2.0 * Z / A )**2 ) / A**0.3333
-   else:
-      print('setup_be_theo: formula is badly defined ',formula)
-      print('setup_be_theo: exit')
-      exit()
+def delta_emp( N, Z, formula ):
+    A = N + Z
+    if formula == 'classic':
+       return 12.0 / A**0.5
+    elif formula == 'Vogel':
+       return ( 7.2 - 44.0 * ( 1.0 - 2.0 * Z / A )**2 ) / A**0.3333
+    else:
+       print('setup_be_theo: formula is badly defined ',formula)
+       print('setup_be_theo: exit')
+       exit()
 
 def be_theo_tables():
     """
     Return a list of the tables available in this toolkit for the masses 
     predicted by theoretical approaches and print them all on the prompt. 
     These tables are the following ones: \
-    [ '1988-MJ', '1995-DZ', '1995-ETFSI', '1995-FRDM', \
+    [ '1988-GK', '1988-MJ', '1995-DZ', '1995-ETFSI', '1995-FRDM', \
     '2005-KTUY', '2007-HFB14', '2010-WS*', '2010-HFB21', '2011-WS3', '2013-HFB22', \
     '2013-HFB23', '2013-HFB24', '2013-HFB25', '2013-HFB26', '2021-BSkG1', \
     '2022-BSkG2', '2023-BSkG3', '2025-BSkG4' ]
@@ -31,7 +32,7 @@ def be_theo_tables():
     #
     if nuda.env.verb: print("\nEnter be_theo_tables()")
     #
-    tables = [ '1988-MJ', '1995-DZ', '1995-ETFSI', '1995-FRDM', \
+    tables = [ '1988-GK', '1988-MJ', '1995-DZ', '1995-ETFSI', '1995-FRDM', \
        '2005-KTUY', '2007-HFB14', '2010-WS*', '2010-HFB21','2011-WS3', '2013-HFB22', \
     '2013-HFB23', '2013-HFB24', '2013-HFB25', '2013-HFB26', '2021-BSkG1', \
     '2022-BSkG2', '2023-BSkG3', '2025-BSkG4' ]
@@ -62,7 +63,7 @@ class setupBETheo():
     This choice is defined in the variable `table`.
 
     `table` can chosen among the following ones: \
-    [ '1988-MJ', '1995-DZ', '1995-ETFSI', '1995-FRDM', \
+    [ '1988-GK', '1988-MJ', '1995-DZ', '1995-ETFSI', '1995-FRDM', \
     '2005-KTUY', '2007-HFB14', '2010-WS*', '2010-HFB21','2011-WS3', '2013-HFB26', '2021-BSkG1', \
     '2022-BSkG2', '2023-BSkG3', '2025-BSkG4' ]
 
@@ -488,6 +489,7 @@ class setupBETheo():
             self.nucBE2A = self.nucBE / self.nucA
             self.Zmax = int( max( self.nucZ ) )
             #
+        self.nucI = ( self.nucN - self.nucZ ) / self.nucA
         #
         if nuda.env.verb: print("Exit setupBETheo()")
         #
@@ -511,117 +513,172 @@ class setupBETheo():
         #
         if nuda.env.verb: print("Exit print_outputs()")
         #
-    def S2n( self, Zmin = 1, Zmax = 95 ):
+    def isotopes(self, Zref = 50 ):
+        """
+        Method which find the first and last isotopes for Z=Zref.
+
+        :param Zref: Fix the charge for the search of isotopes.
+        :type Zref: int, optional. Default: 50.
+
+        **Attributes:**
+        """
+        #
+        if nuda.env.verb: print("Enter isotopes()")
+        #
+        if Zref < 0:
+            print('setup_be_exp.py: issue with the function isotopes.')
+            print('setup_be_exp.py: Bad definition for Zref')
+            print('setup_be_exp.py: It is expected that Zref>0')
+            print('setup_be_exp.py: Zref:',Zref)
+            print('setup_be_exp.py: exit')
+            exit()
+        #
+        Nstable, Zstable = nuda.nuc.stable_fit_Z( Zmin = Zref, Zmax = Zref )
+        #
+        nucNmin = Nstable[0]
+        nucNmax = Nstable[0]
+        #
+        for ind,A in enumerate(self.nucA):
+            if self.nucZ[ind] == Zref and self.nucN[ind] < nucNmin:
+                nucNmin = self.nucN[ind]
+            if self.nucZ[ind] == Zref and self.nucN[ind] > nucNmax:
+                nucNmax = self.nucN[ind]
+        self.itp_nucZ = Zref
+        self.itp_nucNmin = nucNmin
+        self.itp_nucNmax = nucNmax
+        #
+        if nuda.env.verb: print("Exit isotopes()")
+        #
+        return self
+        #
+    def isotones(self, Nref = 50 ):
+        """
+        Method which find the first and last isotones for N=Nref.
+
+        :param Nref: Fix the neutron number for the search of isotones.
+        :type Nref: int, optional. Default: 50.
+
+        **Attributes:**
+        """
+        #
+        if nuda.env.verb: print("Enter isotones()")
+        #
+        if Nref < 0:
+            print('setup_be_exp.py: issue with the function isotones.')
+            print('setup_be_exp.py: Bad definition for Nref')
+            print('setup_be_exp.py: It is expected that Nref>0')
+            print('setup_be_exp.py: Nref:',Nref)
+            print('setup_be_exp.py: exit')
+            exit()
+        #
+        Nstable, Zstable = nuda.nuc.stable_fit_N( Nmin = Nref, Nmax = Nref )
+        #
+        nucZmin = Zstable[0]
+        nucZmax = Zstable[0]
+        #
+        for ind,A in enumerate(self.nucA):
+            if self.nucN[ind] == Nref and self.nucZ[ind] < nucZmin:
+                nucZmin = self.nucZ[ind]
+            if self.nucN[ind] == Nref and self.nucZ[ind] > nucZmax:
+                nucZmax = self.nucZ[ind]
+        self.itn_nucN = Nref
+        self.itn_nucZmin = nucZmin
+        self.itn_nucZmax = nucZmax
+        #
+        if nuda.env.verb: print("Exit isotones()")
+        #
+        return self
+        #
+    def S2n( self, Zref = 50 ):
         """
         Compute the two-neutron separation energy (S2n)
-        S2n = E(Z,N)-E(Z,N+2)
+        S2n = E(Z,N)-E(Z,N-2)
         """
         #
         if nuda.env.verb: print("Enter S2n()")
         #
-        if Zmin > Zmax:
+        if Zref < 0:
             print('setup_be_theo: In S2n attribute function of setup_be_theo.py:')
-            print('setup_be_theo: Bad definition of Zmin and Zmax')
-            print('setup_be_theo: It is expected that Zmin<=Zmax')
-            print('setup_be_theo: Zmin,Zmax:',Zmin,Zmax)
+            print('setup_be_theo: Bad definition of Zref')
+            print('setup_be_theo: It is expected that Zref>=0')
+            print('setup_be_theo: Zref:',Zref)
             print('setup_be_theo: exit')
             exit()
         #
-        S2n_Z = []
         S2n_N = []
-        S2n = []
-        #
-        for ind,Z in enumerate(self.nucZ):
-            #
-            if Z > Zmax :
-                break
-            if Z < Zmin :
-                continue
-            #
-            N = self.nucN[ind]
-            #
-            #print('For Z,N:',Z,N)
-            #
-            # search index for Z,N+2
-            #
-            flag_find = 0
-            for ind2,Z2 in enumerate(self.nucZ):
-                if Z == Z2 and self.nucN[ind2] == N-2:
-                    flag_find = 1
-                    break
-            if flag_find == 1: 
-                N2 = self.nucN[ind2]
-                #print('N,N2:',N,N2,'ind,ind2:',ind,ind2)
-                S2n_Z.append( self.nucZ[ind] )
-                S2n_N.append( self.nucN[ind] )
-                S2n.append( self.nucBE[ind2] - self.nucBE[ind] )
+        S2n_E = []
+        #
+        Nmin=self.itp_nucNmin
+        Nmax=self.itp_nucNmax
+        #
+        for N in range(Nmin+2,Nmax+1):
+            #
+            flagN = False; flagNm2 = False;
+            #
+            for ind,Z in enumerate(self.nucZ):
+                #
+                if Z == Zref and self.nucN[ind] == N:
+                    indN = ind
+                    flagN = True
+                if Z == Zref and self.nucN[ind] == N-2:
+                    indNm2 = ind
+                    flagNm2 = True
+                    #
+            if flagN and flagNm2:
+                S2n_N.append( N )
+                S2n_E.append( self.nucBE[indN] - self.nucBE[indNm2] )
         self.S2n_N = np.array( S2n_N, dtype = int )
-        self.S2n_Z = np.array( S2n_Z, dtype = int )
-        self.S2n = np.array( S2n, dtype = float )
-        #print('Z:',self.S2n_Z)
-        #print('N:',self.S2n_N)
-        #print('S2n:',self.S2n)
+        self.S2n_E = np.array( S2n_E, dtype = float )
         #
         if nuda.env.verb: print("Exit S2n()")
         #
         return self
-    #
-    def S2p( self, Nmin = 1, Nmax = 95 ):
+        #
+    def S2p( self, Nref = 50 ):
         """
-        Compute the two-proton separation energy (S2n)
-        S2p = E(Z,N)-E(Z-2,N)
+        Compute the two-proton separation energy (S2p)
+        S2p(Z,Nref) = E(Z,Nref)-E(Z-2,Nref)
         """
         #
         if nuda.env.verb: print("Enter S2p()")
         #
-        if Nmin > Nmax:
-            print('setup_be_theo: In S2p attribute function of setup_be_exp.py:')
-            print('setup_be_theo: Bad definition of Nmin and Nmax')
-            print('setup_be_theo: It is expected that Nmin<=Nmax')
-            print('setup_be_theo: Nmin,Nmax:',Nmin,Nmax)
-            print('setup_be_theo: exit')
+        if Nref < 0:
+            print('setup_be_exp.py: In S2p attribute function of setup_be_exp.py:')
+            print('setup_be_exp.py: Bad definition of Nref')
+            print('setup_be_exp.py: It is expected that Nref>=0')
+            print('setup_be_exp.py: Nref:',Nref)
+            print('setup_be_exp.py: exit')
             exit()
         #
         S2p_Z = []
-        S2p_N = []
-        S2p = []
-        #
-        for ind,N in enumerate(self.nucN):
-            #
-            if N > Nmax :
-                continue
-            if N < Nmin :
-                continue
-            #
-            Z = self.nucZ[ind]
-            #
-            #print('For Z,N:',Z,N)
-            #
-            # search index for Z-2,N
-            #
-            flag_find = 0
-            for ind2,N2 in enumerate(self.nucN):
-                if N == N2 and self.nucZ[ind2] == Z-2:
-                    flag_find = 1
-                    break
-            if flag_find == 1: 
-                Z2 = self.nucZ[ind2]
-                #print('N,N2:',N,N2,'ind,ind2:',ind,ind2)
-                S2p_Z.append( self.nucZ[ind] )
-                S2p_N.append( self.nucN[ind] )
-                S2p.append( self.nucBE[ind2] - self.nucBE[ind] )
-        self.S2p_N = np.array( S2p_N, dtype = int )
+        S2p_E = []
+        #
+        Zmin=self.itn_nucZmin
+        Zmax=self.itn_nucZmax
+        #
+        for Z in range(Zmin+2,Zmax+1):
+            #
+            flagZ = False; flagZm2 = False;
+            #
+            for ind,N in enumerate(self.nucN):
+                #
+                if N == Nref and self.nucZ[ind] == Z:
+                    indZ = ind
+                    flagZ = True
+                if N == Nref and self.nucZ[ind] == Z-2:
+                    indZm2 = ind
+                    flagZm2 = True
+                    #
+            if flagZ and flagZm2:
+                S2p_Z.append( Z )
+                S2p_E.append( self.nucBE[indZ] - self.nucBE[indZm2] )
         self.S2p_Z = np.array( S2p_Z, dtype = int )
-        self.S2p = np.array( S2p, dtype = float )
-        #print('Z:',self.S2n_Z)
-        #print('N:',self.S2n_N)
-        #print('S2n:',self.S2n)
-        #print('Z:',self.S2n_Z)
+        self.S2p_E = np.array( S2p_E, dtype = float )
         #
         if nuda.env.verb: print("Exit S2p()")
         #
         return self
-    #
+        #
     def drip_S2n(self, Zmin = 1, Zmax = 95 ):
         """
         Method which find the drip-line nuclei from S2n (neutron side).
@@ -726,8 +783,127 @@ class setupBETheo():
         #
         return self
         #
-    #
-    def D3n( self, Zmin = 1, Zmax = 95 ):
+    def D3n( self, Zref = 50 ):
+        """
+        Compute the three-points odd-even mass staggering (D3n)
+        D3n = (-)**N * ( 2*E(Z,N)-E(Z,N+1)-E(Z,N-1) ) / 2
+        """
+        #
+        if nuda.env.verb: print("Enter D3n()")
+        #
+        if Zref < 0:
+            print('setup_be_theo: In D3n attribute function of setup_be_theo.py:')
+            print('setup_be_theo: Bad definition of Zref')
+            print('setup_be_theo: It is expected that Zref>=0')
+            print('setup_be_theo: Zref:',Zref)
+            print('setup_be_theo: exit')
+            exit()
+        #
+        D3n_N_even = []
+        D3n_E_even = []
+        D3n_N_odd = []
+        D3n_E_odd = []
+        #
+        Nmin=self.itp_nucNmin
+        Nmax=self.itp_nucNmax
+        #
+        for N in range(Nmin+1,Nmax+1):
+            #
+            flagN = False; flagNm1 = False; flagNp1 = False;
+            #
+            for ind,Z in enumerate(self.nucZ):
+                #
+                if Z == Zref and self.nucN[ind] == N:
+                    indN = ind
+                    flagN = True
+                    if N % 2:
+                        sign = -1.0 # odd
+                    else:
+                        sign = 1.0 # even
+                if Z == Zref and self.nucN[ind] == N-1:
+                    indNm1 = ind
+                    flagNm1 = True
+                if Z == Zref and self.nucN[ind] == N+1:
+                    indNp1 = ind
+                    flagNp1 = True
+                    #
+            if flagN and flagNm1 and flagNp1:
+                if sign > 0.0: #even
+                    D3n_N_even.append( N )
+                    D3n_E_even.append( sign/2.0*( -2*self.nucBE[indN] + self.nucBE[indNm1] + self.nucBE[indNp1] ) )
+                else:
+                    D3n_N_odd.append( N )
+                    D3n_E_odd.append( sign/2.0*( -2*self.nucBE[indN] + self.nucBE[indNm1] + self.nucBE[indNp1] ) )
+        self.D3n_N_even = np.array( D3n_N_even, dtype = int )
+        self.D3n_E_even = np.array( D3n_E_even, dtype = float )
+        self.D3n_N_odd = np.array( D3n_N_odd, dtype = int )
+        self.D3n_E_odd = np.array( D3n_E_odd, dtype = float )
+        #
+        if nuda.env.verb: print("Exit D3n()")
+        #
+        return self
+        #
+    def D3p( self, Nref = 50 ):
+        """
+        Compute the three-points odd-even mass staggering (D3n)
+        D3p = (-)**Z * ( 2*E(Z,N)-E(Z+1,N)-E(Z-1,N) ) / 2
+        """
+        #
+        if nuda.env.verb: print("Enter D3p()")
+        #
+        if Nref < 0:
+            print('setup_be_theo: In D3p attribute function of setup_be_theo.py:')
+            print('setup_be_theo: Bad definition of Nref')
+            print('setup_be_theo: It is expected that Nref>=0')
+            print('setup_be_theo: Nref:',Nref)
+            print('setup_be_theo: exit')
+            exit()
+        #
+        D3p_Z_even = []
+        D3p_E_even = []
+        D3p_Z_odd = []
+        D3p_E_odd = []
+        #
+        Zmin=self.itn_nucZmin
+        Zmax=self.itn_nucZmax
+        #
+        for Z in range(Zmin+1,Zmax+1):
+            #
+            flagZ = False; flagZm1 = False; flagZp1 = False;
+            #
+            for ind,N in enumerate(self.nucN):
+                #
+                if N == Nref and self.nucZ[ind] == Z:
+                    indZ = ind
+                    flagZ = True
+                    if Z % 2:
+                        sign = -1.0 # odd
+                    else:
+                        sign = 1.0 # even
+                if N == Nref and self.nucZ[ind] == Z-1:
+                    indZm1 = ind
+                    flagZm1 = True
+                if N == Nref and self.nucZ[ind] == Z+1:
+                    indZp1 = ind
+                    flagZp1 = True
+                    #
+            if flagZ and flagZm1 and flagZp1:
+                if sign > 0.0: #even
+                    D3p_Z_even.append( Z )
+                    D3p_E_even.append( sign/2.0*( -2*self.nucBE[indZ] + self.nucBE[indZm1] + self.nucBE[indZp1] ) )
+                else:
+                    D3p_Z_odd.append( Z )
+                    D3p_E_odd.append( sign/2.0*( -2*self.nucBE[indZ] + self.nucBE[indZm1] + self.nucBE[indZp1] ) )
+        self.D3p_Z_even = np.array( D3p_Z_even, dtype = int )
+        self.D3p_E_even = np.array( D3p_E_even, dtype = float )
+        self.D3p_Z_odd = np.array( D3p_Z_odd, dtype = int )
+        self.D3p_E_odd = np.array( D3p_E_odd, dtype = float )
+        #
+        if nuda.env.verb: print("Exit D3p()")
+        #
+        return self
+        #
+    def D3n_old( self, Zmin = 1, Zmax = 95 ):
         """
         Compute the three-points odd-even mass staggering (D3n)
         D3N = (-)**N * ( 2*E(Z,N)-E(Z,N+1)-E(Z,N-1) ) / 2
@@ -798,7 +974,7 @@ class setupBETheo():
         #
         return self
     #
-    def D3p( self, Nmin = 1, Nmax = 95 ):
+    def D3p_old( self, Nmin = 1, Nmax = 95 ):
         """
         Compute the three-points odd-even mass staggering (D3p)
         D3Z = (-)**Z * ( 2*E(Z,N)-E(Z+1,N)-E(Z-1,N) ) / 2

nucleardatapy/nuc/setup_isgmr_exp.py

@@ -20,7 +20,7 @@ def isgmr_exp_tables():
     #
     if nuda.env.verb: print("\nEnter isgmr_exp_tables()")
     #
-    tables = [ '2010-ISGMR-LI', '2018-ISGMR-GARG', '2018-ISGMR-GARG-LATEX', '2022-ISGMR-average' ]
+    tables = [ '2010-ISGMR-LI', '2018-ISGMR-GARG', '2018-ISGMR-GARG-few', '2022-ISGMR-average' ]
     #print('tables available in the toolkit:',tables)
     tables_lower = [ item.lower() for item in tables ]
     #print('tables available in the toolkit:',tables_lower)
@@ -100,12 +100,12 @@ class setupISGMRExp():
             nucM32M1.append( None ); nucM32M1_errp.append( None ); nucM32M1_errm.append( None )
          nuc = len( nucZ ); nbk = nuc
          #
-      elif table.lower() == '2018-isgmr-garg':
+      elif table.lower() == '2018-isgmr-garg-few':
          #
          file_in = os.path.join(nuda.param.path_data,'nuclei/isgmr/2018-ISGMR-Garg.dat')
          if nuda.env.verb: print('Reads file:',file_in)
          self.ref = 'U. Garg and G. Colo, Prog. Part. Nucl. Phys. 101, 55 (2018)'
-         self.label = 'Garg-Colo-2018'
+         self.label = 'Garg-Colo-2018-few'
          self.note = "write here notes about this table."
          nucZ, nucA, nucM12Mm1, nucM12Mm1_errp, nucM12Mm1_errm = \
             np.loadtxt( file_in, usecols=(0,1,2,3,4), comments='#', unpack = True )
@@ -122,7 +122,7 @@ class setupISGMRExp():
             nucM32M1.append( None ); nucM32M1_errp.append( None ); nucM32M1_errm.append( None )
          nuc = len( nucZ ); nbk = nuc
          #
-      elif table.lower() == '2018-isgmr-garg-latex':
+      elif table.lower() == '2018-isgmr-garg':
          #
          file_in = os.path.join(nuda.param.path_data,'nuclei/isgmr/2018-ISGMR-Garg.tex')
          if nuda.env.verb: print('Reads file:',file_in)

nucleardatapy/nuc/setup_rnp_exp.py

@@ -1,3 +1,4 @@
+import numpy as np
 import math
 #import numpy as np  # 1.15.0
 

nucleardatapy/nuc/setup_rnp_theo.py

@@ -1,4 +1,5 @@
 import numpy as np  # 1.15.0
+import os
 from scipy.interpolate import CubicSpline
 
 import nucleardatapy as nuda
@@ -149,7 +150,7 @@ class setupRnpTheo():
         # #            
         if model.lower() == 'skyrme':
             #
-             file_in1 = os.path.join(nuda.param.path_data,'Neutrornp/skyrmernp-'+nucleus+'.dat')
+             file_in1 = os.path.join(nuda.param.path_data,'rnp/skyrmernp-'+nucleus+'.dat')
              if nuda.env.verb: print('Reads file1:',file_in1)
              name = np.loadtxt( file_in1, usecols=(0), comments='#', unpack = True, dtype=str )
              Rn, Rp, Rnp = np.loadtxt( file_in1, usecols=(1,2,3), comments='#', unpack = True )

{nucleardatapy-0.2.1.dist-info → nucleardatapy-1.0.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: nucleardatapy
-Version: 0.2.1
-Summary: A toolkit for nuclear data processing and analysis.
+Version: 1.0.0
+Summary: A toolkit for nuclear data processing and meta-analyses.
 Author: Jerome Margueron, Sudhanva Lalit, Mariana Dutra, Guilherme Grams, Rohit Kumar
 License: Attribution-NonCommercial-NoDerivatives 4.0 International
         
@@ -423,22 +423,36 @@ Dynamic: license-file
 
 ## Purpose:
 
-The purpose of this toolkit is to simply the access to data, that can be theoretical data or experimental ones. All data are provided with their reference, so when using these data in a scientific paper, reference to data should be provided explicitely. The reference to this toolkit could be given, but it should not mask the reference to data.
+<img align="right" width="250" src="book/logo.png">
 
-This python toolkit is designed to provide: 
-1) microscopic calculations in nuclear matter, 
-2) phenomenological predictions in nuclear matter,
-3) experimental data for finite nuclei.
+The purpose of this toolkit is to provide an easy access to theoretical or experimental or observational data and allows meta-analyses in a straightforward way.
+
+This python toolkit is designed to provide:
+
+1. microscopic calculations in nuclear matter,
+2. phenomenological predictions in nuclear matter,
+3. experimental data for finite nuclei,
+4. astrophysical observations and theoretical predictions.
+
+All data are provided with their reference, so when using these data in a scientific paper, reference to data should be provided explicitly. The reference to this toolkit could be given, but it should not mask the reference to the original source of data.
 
 ## Installation of the toolkit:
 
 To install the toolkit, launch:
+
 ```
 $ pip install nucleardatapy
 ```
-This installs the lattest version of the toolkit.
 
-Now everything is done about the installation. 
+This installs the latest version of the toolkit.
+
+If the github repository is downloaded, one can also install the toolkit using
+
+```
+$ pip install -e .
+```
+
+from within the root folder of the nucleardatapy directory.
 
 ## Test the python toolkit
 
@@ -453,37 +467,58 @@ $ bash run_tests.sh
 ## Short introduction to the toolkit:
 
 The call of the toolkit in python code is performed in the usual way:
+
 ```Python
 import nucleardatapy as nuda
 ```
 
 The list of functions and global variables available in the toolkit can be printed from the following instruction:
+
 ```Python
 print(dir(nuda))
 ```
 
 A detailed view of the function can be obtained in the following way
+
 ```Python
 print(help(nuda))
 ```
 
-The principle of the toolkit is that it instantiates objects that contain all the information available. For instance, the following command
+The toolkit classes instantiate objects that contain all the information available. For instance, the following command
+
 ```Python
 mass = nuda.astro.setupMasses()
 ```
-instantiate the object `mass` with the default mass of pulsars. In this case, it is the mass of PSR J1614-2230. All the properties that this object provide can be listed in the following way:
+
+instantiates the object `mass` with the mass of PSR J1614-2230 which is the default case. All the properties of this object can be listed in the following way:
+
 ```Python
 mass.__dict__
 ```
 
+## Documentation
+
+The documentation for the toolkit can be found here: [https://nucleardatapy.readthedocs.io/en/latest/index.html](https://nucleardatapy.readthedocs.io/en/latest/index.html). The documentation is also available in the docs/ folder and can be built using the following command:
+
+```
+sphinx-build -b html docs docs/build_html
+```
+
+The pdf version of the documentation can be found by clicking this [link](https://github.com/jeromemargueron/nucleardatapy/blob/main/docs/nucleardatapy.pdf).
+
+## Tutorials
+
+The tutorials to get started with nucleardatapy toolkit can be found here: [https://jeromemargueron.github.io/nucleardatapy/landing.html](https://jeromemargueron.github.io/nucleardatapy/landing.html). The tutorials are written using `jupyter notebook` and can be tried on your computer by downloading them or by using `google-colab`. In the github repository, the tutorials are available in the book/notebooks folder.
+
 ## Use nucleardatapy python toolkit
 
 The GitHub folder `nucleardatapy/nucleardatapy_samples/` contains a lot of examples on how to use the function and to draw figures. They are all python scripts that can be launched with `python3`. For instance, you can grab these samples anywhere in your computer and try:
+
 ```
 $ python3 matter_setupMicro_script.py
 ```
 
-There are also tutorials that can be employed to learn how to use the different functions in the toolkit. The tutorials are written for `jupyter notebook`.
+There are also tutorials that can be employed to learn how to use the different functions in the toolkit.
 
 ## Get started
 
@@ -501,7 +536,6 @@ micro.print_outputs( )
 
 More examples are shown in the associated paper[Give reference here], as well as in the sample folder or tutorials as previously written.
 
-
 ## Contributing
 
 The file `how_to_contribute.md` details how contributors could join our team or share their results.
@@ -512,10 +546,8 @@ CC BY-NC-ND 4.0
 
 ## Report issues
 
-Issues can be reported using GitHub.
+Issues can be reported using [GitHub Issues](https://github.com/jeromemargueron/nucleardatapy/issues).
 
 ## Thanks
 
 A special thanks to all contributors who accepted to share their results in this toolkit.
-
-