pyphyschemtools 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

pyphyschemtools/survey.py

@@ -597,452 +597,3 @@ class SurveyApp:
             f"<code>{os.path.abspath(self.summary_dir)}</code>"
         ))
 
-############################################################
-#                       Absorption spectra
-############################################################
-
-import numpy as np
-import matplotlib.pyplot as plt
-import scipy.constants as sc
-
-class SpectrumSimulator:
-
-    def __init__(self, sigma_ev=0.3, plotWH=(12,8), \
-                 fontSize_axisText=14, fontSize_axisLabels=14, fontSize_legends=12,
-                 fontsize_peaks=12,
-                 colorS='#3e89be',colorVT='#469cd6'
-                ):
-        """
-        Initializes the spectrum simulator
-
-        Args:
-            - sigma_ev (float): Gaussian half-width at half-maximum in electron-volts (eV).
-                                Default is 0.3 eV (GaussView default is 0.4 eV).
-            - plotWH (tuple(int,int)): Width and Height of the matplotlib figures in inches. Default is (12,8).
-            - colorS: color of the simulated spectrum (default ='#3e89be')
-            - colorVT: color of the vertical transition line (default = '#469cd6')
-
-        Returns:
-            None: This method initializes the instance attributes.
-        Calculates:
-            - sigmanm = half-width of the Gaussian band, in nm
-        """
-        self.sigma_ev = sigma_ev
-        # Conversion constante eV -> nm sigma
-        self.ev2nm_const = (sc.h * sc.c) * 1e9 / sc.e
-        self.sigmanm = self.ev2nm_const / self.sigma_ev
-        self.plotW = plotWH[0]
-        self.plotH = plotWH[1]
-        self.colorS = colorS
-        self.colorVT = colorVT
-        self.fig = None
-        self.graph = None
-        self.fontSize_axisText = fontSize_axisText
-        self.fontSize_axisLabels = fontSize_axisLabels
-        self.fontSize_legends = fontSize_legends
-        self.fontsize_peaks = fontsize_peaks
-
-        print(f"sigma = {sigma_ev} eV -> sigmanm = {self.sigmanm:.1f} nm")
-    
-    def _initializePlot(self):
-        fig, graph = plt.subplots(figsize=(self.plotW,self.plotH))
-        plt.subplots_adjust(wspace=0)
-        plt.xticks(fontsize=self.fontSize_axisText,fontweight='bold')
-        plt.yticks(fontsize=self.fontSize_axisText,fontweight='bold')
-        return fig, graph
-    
-    def _calc_epsiG(self,lambdaX,lambdai,fi):
-        '''
-        calculates a Gaussian band shape around a vertical transition
-        input:
-            - lambdaX = wavelength variable, in nm
-            - lambdai = vertical excitation wavelength for i_th state, in nm
-            - fi = oscillator strength for state i (dimensionless)
-        output :
-            molar absorption coefficient, in L mol-1 cm-1
-        '''
-        import scipy.constants as sc
-        import numpy as np
-        c = sc.c*1e2 #cm-1
-        NA = sc.N_A #mol-1
-        me = sc.m_e*1000 #g
-        e = sc.e*sc.c*10 #elementary charge in esu 
-        pf = np.sqrt(np.pi)*e**2*NA/(1000*np.log(10)*c**2*me)
-        nubarX = 1e7 / lambdaX # nm to cm-1
-        nubari = 1e7 / lambdai
-        sigmabar = 1e7 / self.sigmanm
-        epsi = pf * (fi / sigmabar) * np.exp(-((nubarX - nubari)/sigmabar)**2)
-        return epsi
-    
-    def _Absorbance(self,eps,opl,cc):
-        '''
-        Calculates the Absorbance with the Beer-Lambert law
-        input:
-            - eps = molar absorption coefficient, in L mol-1 cm-1
-            - opl = optical path length, in cm
-            - cc = concentration of the attenuating species, in mol.L-1
-        output :
-            Absorbance, A (dimensionless)
-        '''
-        return eps*opl*cc
-    
-    def _sumStatesWithGf(self,wavel,wavelTAB,feTAB):
-        '''
-        '''
-        import numpy as np
-        sumInt = np.zeros(len(wavel))
-        for l in wavel:
-            for i in range(len(wavelTAB)):
-                sumInt[np.argwhere(l==wavel)[0][0]] += self._calc_epsiG(l,wavelTAB[i],feTAB[i])
-        return sumInt
-    
-    def _FindPeaks(self,sumInt,height,prom=1):
-        '''
-        Finds local maxima within the spectrum based on height and prominence.
-        
-        Prominence is crucial when switching between linear and logarithmic scales:
-        - In Linear mode: A large prominence (e.g., 1 to 1000) filters out noise.
-        - In Log mode: Data is compressed into a range of ~0 to 5. A large 
-          prominence will 'hide' real peaks. A smaller value (0.01 to 0.1) 
-          is required to detect shoulders and overlapping bands.
-
-        Input:
-            - sumInt: Array of intensities (Epsilon or Absorbance).
-            - height: Minimum height a peak must reach to be considered.
-            - prom: Required vertical distance between the peak and its lowest contour line.
-        
-        Returns:
-            - PeakIndex: Indices of the detected peaks in the wavelength array.
-            - PeakHeight: The intensity values at these peak positions.
-        '''
-        from scipy.signal import find_peaks
-        peaks = find_peaks(sumInt, height = height, threshold = None, distance = 1, prominence=prom)
-        PeakIndex = peaks[0]
-        # Check if 'peak_heights' exists in the properties dictionary
-        if 'peak_heights' in peaks[1]:
-            PeakHeight = peaks[1]['peak_heights']
-        else:
-            # If height=None, we extract values manually from the input data
-            PeakHeight = sumInt[PeakIndex]
-        return PeakIndex,PeakHeight
-
-    def _FindShoulders(self, data, tP):
-        '''
-        ###not working
-        Detects shoulders using the second derivative.
-        A shoulder appears as a peak in the negative second derivative.
-        
-        Note on scales:
-        - If ylog is True: data should be log10(sumInt) and tP should be log10(tP).
-          The second derivative on log data is much more sensitive to subtle 
-          inflection points in weak transitions (like n -> pi*).
-        - If ylog is False: data is linear sumInt and tP is linear.
-        
-        Returns:
-            - shoulder_idx (ndarray): Array of indices where shoulders were found.
-            - shoulder_heights (ndarray): The intensity values at these positions 
-              extracted from the input data.
-        '''
-        import numpy as np
-        # Calculate the second derivative (rate of change of the slope)
-        d2 = np.gradient(np.gradient(data))
-        
-        # We search for peaks in the opposite of the second derivative (-d2).
-        # A local maximum in -d2 corresponds to a point of maximum curvature 
-        # (inflection), which identifies a shoulder.
-        # We use a very low prominence threshold to capture subtle inflections.
-        shoulder_idx, _ = self._FindPeaks(-d2, height=None, prom=0.0001)
-        shoulder_heights = data[shoulder_idx]
-        print(shoulder_idx, shoulder_heights )
-        
-        return shoulder_idx, shoulder_heights 
-    
-    def _pickPeak(self,wavel,peaksIndex,peaksH,color,\
-                  shift=500,height=500,posAnnotation=200, ylog=False):
-        '''
-        Annotates peaks with a small vertical tick and the wavelength value.
-        Adjusts offsets based on whether the plot is in log10 scale or linear.
-        In log mode, peaksH must already be log10 values.
-        '''
-        s=shift
-        h=height
-        a=posAnnotation
-        
-
-        for i in range(len(peaksIndex)):
-            x = wavel[peaksIndex[i]]
-            y = peaksH[i]
-            if ylog:
-                # In log scale, we use multipliers to keep the same visual distance
-                # 1.1 means "10% above the peak"
-                # Adjust these factors based on your preference
-                y_s = y * 1.1
-                y_h = y * 1.3
-                y_a = y * 1.5
-                self.graph.vlines(x, y_s, y_h, colors=color, linestyles='solid')
-                self.graph.annotate(f"{x:.1f}",xy=(x,y),xytext=(x,y_a),rotation=90,size=self.fontsize_peaks,ha='center',va='bottom', color=color)
-            else:
-                # Classic linear offsets
-                self.graph.vlines(x, y+s, y+s+h, colors=color, linestyles='solid')
-                self.graph.annotate(f"{x:.1f}",xy=(x,y),xytext=(x,y+s+h+a),rotation=90,size=self.fontsize_peaks,ha='center',va='bottom',color=color)
-        return
-
-    def _setup_axes(self, lambdamin, lambdamax, ymax, ylabel="Absorbance"):
-            self.graph.set_xlabel('wavelength / nm', size=self.fontSize_axisLabels, fontweight='bold', color='#2f6b91')
-            self.graph.set_ylabel(ylabel, size=self.fontSize_axisLabels, fontweight='bold', color='#2f6b91')
-            self.graph.set_xlim(lambdamin, lambdamax)
-            self.graph.set_ylim(0, ymax)
-            self.graph.tick_params(axis='both', labelsize=self.fontSize_axisText,labelcolor='black')
-            for tick in self.graph.xaxis.get_majorticklabels(): tick.set_fontweight('bold') #it is both powerful
-                                                # (you can specify the type of a specific tick) and annoying
-            for tick in self.graph.yaxis.get_majorticklabels(): tick.set_fontweight('bold')
-    
-    def plotTDDFTSpectrum(self,wavel,sumInt,wavelTAB,feTAB,tP,ylog,labelSpectrum,colorS='#0000ff',colorT='#0000cf'):
-        
-        '''
-        Called by plotEps_lambda_TDDFT. Plots a single simulated UV-Vis spectrum, i.e. after
-        gaussian broadening, together with the TDDFT vertical transitions (i.e. plotted as lines)
-        
-        input:
-            - wavel = array of gaussian-broadened wavelengths, in nm
-            - sumInt = corresponding molar absorptiopn coefficients, in L. mol-1 cm-1
-            - wavelTAB = wavelength of TDDFT, e.g. discretized, transitions
-            - ylog = log plot of epsilon
-            - tP: threshold for finding the peaks
-            - feTAB = TDDFT oscillator strength for each transition of wavelTAB
-            - labelSpectrum = title for the spectrum
-        '''
-
-        # # --- DEBUG START ---
-        # if ylog:
-        #     print(f"\n--- DEBUG LOG MODE ---")
-        #     print(f"Max sumInt (linear): {np.max(sumInt):.2f}")
-        #     print(f"Max sumInt (log10):  {np.log10(max(np.max(sumInt), 1e-5)):.2f}")
-        # # --- DEBUG END ---
-        if ylog:
-            # Apply safety floor to the entire array
-            self.graph.set_yscale('log')
-            ymin_val = 1.0 # Epsilon = 1
-        else:
-            self.graph.set_yscale('linear')
-            ymin_val = 0
-            
-        # vertical lines
-        for i in range(len(wavelTAB)):
-            val_eps = self._calc_epsiG(wavelTAB[i],wavelTAB[i],feTAB[i])
-            self.graph.vlines(x=wavelTAB[i], ymin=ymin_val, ymax=max(val_eps, ymin_val), colors=colorT)
-
-        self.graph.plot(wavel,sumInt,linewidth=3,linestyle='-',color=colorS,label=labelSpectrum)
-
-        self.graph.legend(fontsize=self.fontSize_legends)
-        if ylog:
-            # Use log-transformed data and log-transformed threshold
-            # Clipping tP to 1e-5 ensures we don't take log of 0 or negative
-            tPlog = np.log10(max(tP, 1e-5))
-            # prom=0.05 allows detection of peaks that are close in log-magnitude
-            peaks, peaksH_log = self._FindPeaks(np.log10(np.clip(sumInt, 1e-5, None)), tPlog, prom=0.05)
-            peaksH = 10**peaksH_log
-            # shoulders, shouldersH_log = self._FindShoulders(np.log10(np.clip(sumInt, 1e-5, None)), tPlog)
-            # all_idx = np.concatenate((peaks, shoulders))
-            # allH_log = np.concatenate((peaksH_log, shouldersH_log))
-            # allH = 10**allH_log
-        else:
-            peaks, peaksH = self._FindPeaks(sumInt,tP)
-            # shoulders, shouldersH = self._FindShoulders(wavel, sumInt, tP)
-            # all_idx = np.concatenate((peaks, shoulders))
-            # allH = np.concatenate((peaksH, shouldersH))
-        self._pickPeak(wavel,peaks,peaksH,colorS,500,500,200,ylog)
-        
-    
-    def plotEps_lambda_TDDFT(self,datFile,lambdamin=200,lambdamax=800,\
-                             epsMax=None, titles=None, tP = 10, \
-                             ylog=False,\
-                             filename=None):
-        '''
-        Plots a TDDFT VUV simulated spectrum (vertical transitions and transitions summed with gaussian functions)
-        between lambdamin and lambdamax (sum of states done in the range [lambdamin-50, lambdamlax+50] nm)
-        input:
-            - datFile: list of pathway/names to "XXX_ExcStab.dat" files generated by 'GParser Gaussian.log -S'
-            - lambdamin, lambdamax: plot range
-            - epsMax: y axis graph limit
-            - titles: list of titles (1 per spectrum plot)
-            - tP: threshold for finding the peaks (default = 10 L. mol-1 cm-1)
-            - ylog: y logarithmic axis (default: False).
-            - save: saves in a png file (300 dpi) if True (default = False)
-            - filename: saves figure in a 300 dpi png file if not None (default), with filename=full pathway
-        '''
-        if self.fig is not None:
-            graph = self.graph
-            fig = self.fig
-            lambdamin = self.lambdamin
-            lambdamax = self.lambdamax
-            epsMax = self.epsMax
-        else:
-            fig, graph = self._initializePlot()
-
-        graph.set_prop_cycle(None)
-
-        if self.fig is None:
-            self.fig = fig
-            self.graph = graph
-            self.lambdamin = lambdamin
-            self.lambdamax = lambdamax
-            self.epsMax = epsMax
-            
-            graph.set_xlabel('wavelength / nm',size=self.fontSize_axisLabels,fontweight='bold',color='#2f6b91')
-
-            graph.set_xlim(lambdamin,lambdamax)
-
-            import matplotlib.ticker as ticker
-            graph.xaxis.set_major_locator(ticker.MultipleLocator(50)) # sets a tick for every integer multiple of the base (here 250) within the view interval
-        
-        istate,state,wavel,fe,SSq = np.genfromtxt(datFile,skip_header=1,dtype="<U20,<U20,float,float,<U20",unpack=True)
-        wavel = np.array(wavel)
-        fe = np.array(fe)
-        if wavel.size == 1:
-            wavel = np.array([wavel])
-            fe = np.array([fe])
-        wvl = np.arange(lambdamin-50,lambdamax+50,1)
-        sumInt = self._sumStatesWithGf(wvl,wavel,fe)
-        self.plotTDDFTSpectrum(wvl,sumInt,wavel,fe,tP,ylog,titles,self.colorS,self.colorVT)
-        if ylog:
-            graph.set_ylabel('log(molar absorption coefficient / L mol$^{-1}$ cm$^{-1})$',size=self.fontSize_axisLabels,fontweight='bold',color='#2f6b91')
-            graph.set_ylim(1, epsMax * 5 if epsMax else None)
-        else:
-            graph.set_yscale('linear')
-            graph.set_ylabel('molar absorption coefficient / L mol$^{-1}$ cm$^{-1}$',size=self.fontSize_axisLabels,fontweight='bold',color='#2f6b91')
-            graph.set_ylim(0, epsMax if epsMax else np.max(sumInt)*1.18)
-        if filename is not None: self.fig.savefig(filename, dpi=300, bbox_inches='tight')
-        plt.show()
-
-        peaksI, peaksH = self._FindPeaks(sumInt,tP)
-        print(f"{bg.LIGHTREDB}{titles}{bg.OFF}")
-        for i in range(len(peaksI)):
-            print(f"peak {i:3}. {wvl[peaksI[i]]:4} nm. epsilon_max = {peaksH[i]:.1f} L mol-1 cm-1")
-        if ylog:
-            print()
-            # prom=0.05 allows detection of peaks that are close in log-magnitude
-            peaksI, peaksH = self._FindPeaks(np.log10(np.clip(sumInt, 1e-5, None)), np.log10(max(tP, 1e-5)), prom=0.05)
-            for i in range(len(peaksI)):
-                print(f"peak {i:3}. {wvl[peaksI[i]]:4} nm. log10(epsilon_max) = {peaksH[i]:.1f}")
-
-    def plotAbs_lambda_TDDFT(self, datFiles=None, C0=1e-5, lambdamin=200, lambdamax=800, Amax=2.0,\
-                             titles=None, linestyles=[], annotateP=[], tP = 0.1,\
-                             resetColors=False,\
-                             filename=None):
-        '''
-        Plots a simulated TDDFT VUV absorbance spectrum (transitions summed with gaussian functions)
-        between lambdamin and lambdamax (sum of states done in the range [lambdamin-50, lambdamlax+50] nm)
-        input:
-            - datFiles: list of pathway/name to files generated by 'GParser Gaussian.log -S'
-            - C0: list of concentrations needed to calculate A = epsilon x l x c (in mol.L-1)
-            - lambdamin, lambdamax: plot range (x axis)
-            - Amax: y axis graph limit
-            - titles: list of titles (1 per spectrum plot)
-            - linestyles: list of line styles(default = "-", i.e. a continuous line)
-            - annotateP: list of Boolean (annotate lambda max True or False. Default = True)
-            - tP: threshold for finding the peaks (default = 0.1)
-            - resetColors (bool): If True, resets the matplotlib color cycle 
-                                 to the first color. This allows different series 
-                                 (e.g., gas phase vs. solvent) to share the same 
-                                 color coding for each molecule across multiple calls. Default: False
-            - save: saves in a png file (300 dpi) if True (default = False)
-            - filename: saves figure in a 300 dpi png file if not None (default), with filename=full pathway
-        '''
-
-        if self.fig is None:
-            fig, graph = self._initializePlot()
-            self.fig = fig
-            self.graph = graph
-            self.lambdamin = lambdamin
-            self.lambdamax = lambdamax
-            self.Amax = Amax
-        else:
-            graph = self.graph
-            fig = self.fig
-            lambdamin = self.lambdamin
-            lambdamax = self.lambdamax
-            Amax = self.Amax
-            if resetColors: graph.set_prop_cycle(None)
-            
-        if linestyles == []: linestyles = len(datFiles)*['-']
-        if annotateP == []: annotateP = len(datFiles)*[True]
-
-        self._setup_axes(lambdamin, lambdamax, self.Amax, ylabel="Absorbance")
-        
-        wvl = np.arange(lambdamin-50,lambdamax+50,1)
-        for f in range(len(datFiles)):
-            istate,state,wavel,fe,SSq = np.genfromtxt(datFiles[f],skip_header=1,dtype="<U20,<U20,float,float,<U20",unpack=True)
-            sumInt = self._sumStatesWithGf(wvl,wavel,fe)
-            Abs = self._Absorbance(sumInt,1,C0[f])
-            plot=self.graph.plot(wvl,Abs,linewidth=3,linestyle=linestyles[f],label=f"{titles[f]}. TDDFT ($C_0$={C0[f]} mol/L)")
-            peaksI, peaksH = self._FindPeaks(Abs,tP,0.01)
-            if (annotateP[f]): self._pickPeak(wvl,peaksI,peaksH,plot[0].get_color(),0.01,0.04,0.02)
-            print(f"{bg.LIGHTREDB}TDDFT. {titles[f]}{bg.OFF}")
-            for i in range(len(peaksI)):
-                print(f"peak {i:3}. {wvl[peaksI[i]]:4} nm. A = {peaksH[i]:.2f}")
-                
-        self.graph.legend(fontsize=self.fontSize_legends)
-
-        if filename is not None: self.fig.savefig(filename, dpi=300, bbox_inches='tight')
-
-        return
-    
-    def plotAbs_lambda_exp(self, csvFiles, C0, lambdamin=200, lambdamax=800,\
-                             Amax=2.0, titles=None, linestyles=[], annotateP=[], tP = 0.1,\
-                             filename=None):
-        '''
-        Plots an experimental VUV absorbance spectrum read from a csv file between lambdamin and lambdamax
-        input:
-            - superpose: False = plots a new graph, otherwise the plot is superposed to a previously created one
-                         (probably with plotAbs_lambda_TDDFT())
-            - csvfiles: list of pathway/name to experimental csvFiles (see examples for the format)
-            - C0: list of experimental concentrations, i.e. for each sample
-            - lambdamin, lambdamax: plot range (x axis)
-            - Amax: graph limit (y axis)
-            - titles: list of titles (1 per spectrum plot)
-            - linestyles: list of line styles(default = "--", i.e. a dashed line)
-            - annotateP: list of Boolean (annotate lambda max True or False. Default = True)
-            - tP: threshold for finding the peaks (default = 0.1)
-            - save: saves in a png file (300 dpi) if True (default = False)
-            - filename: saves figure in a 300 dpi png file if not None (default), with filename=full pathway
-        '''
-        if linestyles == []: linestyles = len(csvFiles)*['--']
-        if annotateP == []: annotateP = len(csvFiles)*[True]
-
-        if self.fig is not None:
-            graph = self.graph
-            fig = self.fig
-            lambdamin = self.lambdamin
-            lambdamax = self.lambdamax
-            Amax = self.Amax
-        else:
-            fig, graph = self._initializePlot()
-            
-        graph.set_prop_cycle(None)
-        
-        if self.fig is None:
-            self.graph = graph
-            self.fig = fig
-            self.lambdamin = lambdamin
-            self.lambdamax = lambdamax
-            self.Amax = Amax
-            
-        self._setup_axes(lambdamin, lambdamax, self.Amax, ylabel="Absorbance")
-                
-        for f in range(len(csvFiles)):
-            wavel,Abs = np.genfromtxt(csvFiles[f],skip_header=1,unpack=True,delimiter=";")
-            wavel *= 1e9
-            plot=graph.plot(wavel,Abs,linewidth=3,linestyle=linestyles[f],label=f"{titles[f]}. exp ($C_0$={C0[f]} mol/L)")
-            peaksI, peaksH = self._FindPeaks(Abs,tP,0.01)
-            if (annotateP[f]): self._pickPeak(wavel,peaksI,peaksH,plot[0].get_color(),0.01,0.04,0.02)
-            print(f"{bg.LIGHTREDB}exp. {titles[f]}{bg.OFF}")
-            for i in range(len(peaksI)):
-                print(f"peak {i:3}. {wavel[peaksI[i]]:4} nm. A = {peaksH[i]:.2f}")
-
-        graph.legend(fontsize=self.fontSize_legends)
-
-        if filename is not None: self.fig.savefig(filename, dpi=300, bbox_inches='tight')
-    
-        return
-        

pyphyschemtools/sympyUtilities.py

@@ -8,11 +8,9 @@ def PrintLatexStyleSymPyEquation(spe):
     """
     Function that displays a SymPy expression (spe) in a jupyter notebbok after its conversion into a LaTeX / Math output
 
-    Input:
-    spe: SymPy expression
+    Input: spe= SymPy expression
 
-    Output:
-    Pretty printing of spe
+    Output: Pretty printing of spe
 
     """
     from IPython.display import display,Math
@@ -23,12 +21,14 @@ def PrintLatexStyleSymPyEquation(spe):
 def e2Lists(eigenvectors, sort=False):
     '''
     returns two separate lists from the list of tuples returned by the eigenvects() function of SymPy
-    input
-        - the list of tuples returned by eigenvects
-        - sort (default: False): returns sorted eigenvalues and corresponding eigenvectors if True
+    
+    input:
+    - the list of tuples returned by eigenvects
+    - sort (default: False): returns sorted eigenvalues and corresponding eigenvectors if True
+    
     output
-        - list of eigenvalues, sorted or not
-        - list of corresponding eigenvectors
+    - list of eigenvalues, sorted or not
+    - list of corresponding eigenvectors
     '''
     import numpy as np
     eps = list()

pyphyschemtools/tools4AS.py

@@ -30,22 +30,24 @@ import seaborn as sns
 
 def verifNotes(dfCC,labelNoteCC,nomCC,NI,absents='aabs'):
     """
-    entrée :
+    Args:
         - dfCC = dataframe dont 1 colonne contient les notes de CC
         - labelNoteCC = label de la colonne qui contient les notes
         - nomCC = label de l'épreuve de CC (ex CC1), utilisé pour l'affichage
         - NI = nombre d'inscrits dans le module
-        - absents = 'aabs' : analyser s'il y a des étudiants qui n'ont pas été pointés au CC (défaut)
-                  = 'noabs' : ne pas analyser s'il y a des étudiants qui n'ont pas été pointés au CC
-                              (ça n'a plus de sens une fois les fichiers concaténés)
+        - absents:
+            * 'aabs' : analyser s'il y a des étudiants qui n'ont pas été pointés au CC (défaut)
+            * 'noabs' : ne pas analyser s'il y a des étudiants qui n'ont pas été pointés au CC
+                        (ça n'a plus de sens une fois les fichiers concaténés)
         
-    sortie :
+    Returns:
         - la moyenne et la déviation standard de liste de notes contenues dans le dataframe dfCC
         - le nombre d'étudiants qui n'ont pas composé au CC
     
-    affichages :
-        - nombre d'étudiants avec label 'ABS'|'Abs'|'abs'
-        - nombre d'étudiants sans note ni label ABS. En général c'est problématique. Vérifier le PV 
+    Note:
+        Affiche le nombre d'étudiants avec le label 'ABS' et signale les 
+        étudiants sans note ni label, ce qui nécessite une vérification du PV.
+        
     """
     print()
     #pd.set_option("display.max_rows", len(dfCC))
@@ -81,9 +83,11 @@ def RenameDfHeader(dfCC,dfCCname,labelNoteCC,nomCC):
         - dfCCname = nom (string) du dataframe. Il est recommandé d'utiliser f'{dfCC=}'.split('=')[0]
         - labelNoteCC = label de la colonne qui contient les notes
         - nomCC = label de l'épreuve de CC (ex CC1), utilisé pour l'affichage
+        
     sortie : aucune
 
     la fonction change le nom 'labelNoteCC' en 'nomCC'
+    
     """
     print(f"{hl.BOLD}{fg.BLUE}Normalisation du nom des colonnes de notes{fg.OFF}")
     print(f"{hl.BOLD}Dataframe = {dfCCname}.{fg.OFF} {labelNoteCC} --> {nomCC}")

{pyphyschemtools-0.1.0.dist-info → pyphyschemtools-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyphyschemtools
-Version: 0.1.0
+Version: 0.1.2
 Summary: A comprehensive Python toolbox for physical chemistry and cheminformatics
 Author-email: "Romuald POTEAU, LPCNO" <romuald.poteau@utoulouse.fr>
 Project-URL: Homepage, https://github.com/rpoteau/pyphyschemtools
@@ -29,7 +29,7 @@ Requires-Dist: numpydoc; extra == "docs"
 Dynamic: license-file
 
 <div style="text-align:center">
-<img src="https://raw.githubusercontent.com/rpoteau/pyphyschemtools/main/pyphyschemtools/icons-logos-banner/tools4pyPC_banner.png" alt="t4pyPCbanner" width="800"/>
+<img src="https://raw.githubusercontent.com/rpoteau/pyphyschemtools/main/pyphyschemtools/icons_logos_banner/tools4pyPC_banner.png" alt="t4pyPCbanner" width="800"/>
 </div>
 
 # pyPhysChemTools

{pyphyschemtools-0.1.0.dist-info → pyphyschemtools-0.1.2.dist-info}/RECORD

@@ -1,22 +1,32 @@
-pyphyschemtools/Chem3D.py,sha256=i6ieFGEiO1bwZ7GdtNnFCEbfVRXa4YSGkd7SLnjndUs,32709
-pyphyschemtools/ML.py,sha256=ofNGptNqv31BGG_QKepYmpF9M_uPLkDRXhrJiDWsqWo,1608
-pyphyschemtools/PeriodicTable.py,sha256=bk11SIN3xofpIp2SIZHLx7t-EyRBFUVRUUpfddaSvCc,13499
-pyphyschemtools/__init__.py,sha256=CUZWtKfjmw964Dx6wfVxBu5j049Om-f6ScwhGyvjMsE,1465
-pyphyschemtools/aithermo.py,sha256=8x204bHVZwR2bb6j3G6XrUD0XePxcZG6NCH6808x8K0,15017
+pyphyschemtools/.__init__.py.swp,sha256=JxmB0a9RQHIw7mLGqOKJivHfhEca0dQRe3uVOBKNh9E,12288
+pyphyschemtools/.readthedocs.yaml,sha256=ZTw2bOyF9p3JpeF8Ux0fwhYWO6KHCsroNEOvnXxbYGM,469
+pyphyschemtools/Chem3D.py,sha256=LGMZYXF3iKaXERZGFCaqql3mQMN3di47TWv39FWSj3U,32719
+pyphyschemtools/ML.py,sha256=kR_5vm5TOOjVef8uXCW57y7685ts6K6OkRMBYKP_cYw,1599
+pyphyschemtools/PeriodicTable.py,sha256=LfLSFOzRkirREQlwfeSR3TyvgHyjGiltIZXNmvBkbhQ,13526
+pyphyschemtools/__init__.py,sha256=obYnkAlRpwE3vUFgeQDML3wvhkzTTW1BD5nFxV2qsZ4,1442
+pyphyschemtools/aithermo.py,sha256=kF8wtuYIJzkUKM2AGubmn9haAJKz-XaBskZ7HjivJeY,14984
 pyphyschemtools/cheminformatics.py,sha256=Qps_JSYWOzZQcXwKElI1iWGjWAPDgwmtDKuJwONsKmI,8977
-pyphyschemtools/core.py,sha256=m2WGuu3EmLTJvMoD_WDScGesbRfo9PIC6HIdAUQRGHg,4866
+pyphyschemtools/core.py,sha256=5fRu83b125w2p_m2H521fLjktyswZHJXNKww1wfBwbU,4847
 pyphyschemtools/kinetics.py,sha256=3YyzzQ7FKZ7wNALRDsLNLhpZpDp38LHWOUfMojsh8hE,7696
-pyphyschemtools/spectra.py,sha256=XMkkzrWK6QtDm2mcvNSJfbE6fiGPU-8U-nvTcPYWWdI,21626
-pyphyschemtools/survey.py,sha256=Rcw0xb0_nwsxETleB1C2xjKmZfrUw4PXDm48CMSptHU,45816
-pyphyschemtools/sympyUtilities.py,sha256=eZHv0vDAxJ5hWb40U3ZmhfDU-cwEdN-_1ZgcV_B6dGo,1558
-pyphyschemtools/tools4AS.py,sha256=733OboqFLDscmtVLDLdDNjAGQgUcBVm6H6Zm3uG_q3I,44778
+pyphyschemtools/spectra.py,sha256=eCN9X6pK5k4KMcfWUskedWYwtxbrmJH_BvFXU1GZfVo,21702
+pyphyschemtools/survey.py,sha256=YjZhhb8GFVNXoXSCxgGdZFqmCtNCx7O_uiFVCcGBYYo,24268
+pyphyschemtools/sympyUtilities.py,sha256=LgLloh9dD9Mkff2WNoSnrJa3hxK0axOnK-4GS9wPtT0,1545
+pyphyschemtools/tools4AS.py,sha256=BVfxf6bHnCciBMdQBSJ76Ja_aA-I_iOqQHZuVb-DsdY,44783
 pyphyschemtools/visualID.py,sha256=JlAd5nnZIliHOiKvkToArYhkbty-OntuFGf2CdPbgo8,3061
 pyphyschemtools/visualID_Eng.py,sha256=o-EdCOduo_qruRrr5kkplixaT1t79f3I3M1Ya5TOc_Q,5244
-pyphyschemtools/icons-logos-banner/Logo_pyPhysChem_border.svg,sha256=w6AhEF3Ym5Xe6AyUJ0WZ8rTzYXCFCSQLCAftrmPaG7w,55288
-pyphyschemtools/icons-logos-banner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyphyschemtools/icons-logos-banner/logo.png,sha256=qnxdLQGvv1TNcz_n4EseQhzZgIX6O710tqm418_EIRY,388311
-pyphyschemtools/icons-logos-banner/tools4pyPC_banner.png,sha256=z7o_kBK0sIBsXHEJrT2GyLHu-0T0T3S8YkWcpxR2joA,89058
-pyphyschemtools/icons-logos-banner/tools4pyPC_banner.svg,sha256=JQhtJmTXkatvHwGtSc0gHBTZB_E0eh_nLB9kX7sxt7k,99752
+pyphyschemtools/.ipynb_checkpoints/Chem3D-checkpoint.py,sha256=LGMZYXF3iKaXERZGFCaqql3mQMN3di47TWv39FWSj3U,32719
+pyphyschemtools/.ipynb_checkpoints/PeriodicTable-checkpoint.py,sha256=LfLSFOzRkirREQlwfeSR3TyvgHyjGiltIZXNmvBkbhQ,13526
+pyphyschemtools/.ipynb_checkpoints/aithermo-checkpoint.py,sha256=kF8wtuYIJzkUKM2AGubmn9haAJKz-XaBskZ7HjivJeY,14984
+pyphyschemtools/.ipynb_checkpoints/core-checkpoint.py,sha256=5fRu83b125w2p_m2H521fLjktyswZHJXNKww1wfBwbU,4847
+pyphyschemtools/.ipynb_checkpoints/spectra-checkpoint.py,sha256=eCN9X6pK5k4KMcfWUskedWYwtxbrmJH_BvFXU1GZfVo,21702
+pyphyschemtools/.ipynb_checkpoints/survey-checkpoint.py,sha256=Rcw0xb0_nwsxETleB1C2xjKmZfrUw4PXDm48CMSptHU,45816
+pyphyschemtools/.ipynb_checkpoints/sympyUtilities-checkpoint.py,sha256=LgLloh9dD9Mkff2WNoSnrJa3hxK0axOnK-4GS9wPtT0,1545
+pyphyschemtools/.ipynb_checkpoints/tools4AS-checkpoint.py,sha256=BVfxf6bHnCciBMdQBSJ76Ja_aA-I_iOqQHZuVb-DsdY,44783
+pyphyschemtools/icons_logos_banner/Logo_pyPhysChem_border.svg,sha256=w6AhEF3Ym5Xe6AyUJ0WZ8rTzYXCFCSQLCAftrmPaG7w,55288
+pyphyschemtools/icons_logos_banner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyphyschemtools/icons_logos_banner/logo.png,sha256=qnxdLQGvv1TNcz_n4EseQhzZgIX6O710tqm418_EIRY,388311
+pyphyschemtools/icons_logos_banner/tools4pyPC_banner.png,sha256=z7o_kBK0sIBsXHEJrT2GyLHu-0T0T3S8YkWcpxR2joA,89058
+pyphyschemtools/icons_logos_banner/tools4pyPC_banner.svg,sha256=JQhtJmTXkatvHwGtSc0gHBTZB_E0eh_nLB9kX7sxt7k,99752
 pyphyschemtools/resources/css/BrainHalfHalf-120x139.base64,sha256=rn-r0NKiX92EEEOlME-nUw_fC8B6mrEThX7v9L1y4Eg,25092
 pyphyschemtools/resources/css/BrainHalfHalf-120x139.png,sha256=tBhhTXidkqjvmavprPAl3BZlsqswu7DbP_rAz-tyS_Q,18818
 pyphyschemtools/resources/css/BrainHalfHalf.base64,sha256=0VLlFvSdEaVfHJR-RDNu27V0PzBN0HSfsXxGU0mRFXw,633735
@@ -73,8 +83,8 @@ pyphyschemtools/resources/svg/pyPhysChemBanner.png,sha256=sK5NwjbEYJvMAAzPBCqwvr
 pyphyschemtools/resources/svg/pyPhysChemBanner.svg,sha256=39LrLnFn7R681Hh3YXB3K17Sp0Xp3ynDOGUbXuORQ3s,4388883
 pyphyschemtools/resources/svg/qrcode-pyPhysChem.png,sha256=rP7X-9eHL7HYj4ffmwBMLfQTaRIOyzShVfavRXiomtw,71070
 pyphyschemtools/resources/svg/repository-open-graph-template.png,sha256=UlnW5BMkLGOv6IAnEi7teDYS_5qeSLmpxRMT9r9m-5Q,51470
-pyphyschemtools-0.1.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pyphyschemtools-0.1.0.dist-info/METADATA,sha256=czaz2iQUWNclIfmwqo9E1ZIKio-KGYN8_jB6jSsJcaw,1352
-pyphyschemtools-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pyphyschemtools-0.1.0.dist-info/top_level.txt,sha256=N92w2qk4LQ42OSdzK1R2h_x1CyUFaFBOrOML2RnmFgE,16
-pyphyschemtools-0.1.0.dist-info/RECORD,,
+pyphyschemtools-0.1.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pyphyschemtools-0.1.2.dist-info/METADATA,sha256=-dKdPNmGcUsjudhxuYnjOjU6idzHn99AuV7Hg_02FSw,1352
+pyphyschemtools-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pyphyschemtools-0.1.2.dist-info/top_level.txt,sha256=N92w2qk4LQ42OSdzK1R2h_x1CyUFaFBOrOML2RnmFgE,16
+pyphyschemtools-0.1.2.dist-info/RECORD,,