

import os
import pandas as pd
import matplotlib as mpl
import numpy as np
import matplotlib.pyplot as plt

from spec_functions import find_marker,norm_spectra,norm_spectra_c1,baseline_correction,calculate_mol_spectra,calc_k,id_spectra,part_specs,SlicedRamanshift,voigt_paras,pseudo_voigt
from thermo_functions import Calculate_gamma,GibbsExcess
from matplotlib.ticker import MultipleLocator
from matplotlib.lines import Line2D
import matplotlib.gridspec as gridspec
          

        
basepoints_dict = {
                   'Acetone-Cyclohexane' : [660,1900, 2150,2400,3900],
                   'Acetone-Water' : [660,1900,2150, 2400, 3900],
                   'Acetone-Acetic acid' : [660,1900,2150,2400,3900],
                   'Acetone-ACN' : [660,1900,2150,2400, 3900],
                 }


# all datapaths have to be adjusted so that they match your directroy

base_path='Y:\Publications\ITUN journal publications\Industrial and Chemical Engineering Research\Miriam 2025\OpARA'

foldernames=os.listdir(base_path)


ramanshift=np.loadtxt('Y:\Publications\ITUN journal publications\Industrial and Chemical Engineering Research\Miriam 2025\OpARA/ramanshift.txt')
rs=np.loadtxt('Y:\Publications\ITUN journal publications\Industrial and Chemical Engineering Research\Miriam 2025\OpARA/rs.txt')


preprocessed_data_path = 'Y:\Publications\ITUN journal publications\Industrial and Chemical Engineering Research\Miriam 2025\OpARA/data_spec-pkl'
voigt_data_path = 'Y:\Publications\ITUN journal publications\Industrial and Chemical Engineering Research\Miriam 2025\OpARA/data_spec_voigt.pkl'
#data_show_path = 'Y:\Publications\ITUN journal publications\Industrial and Chemical Engineering Research\Miriam 2025\OpARA/data_spec_show.pkl'

pure_voigt_data_path='Y:\Publications\ITUN journal publications\Industrial and Chemical Engineering Research\Miriam 2025\OpARA/pure_paras.pkl'

rs_start=575 # wavenumber where spectrum starts
idx_start= int((np.abs(ramanshift - rs_start)).argmin())
rs_end=3800 # wavenumber where spectrum ends
idx_end = int((np.abs(ramanshift - rs_end)).argmin())

read_all_mixtures=False
fit_voigt=False

slicestart=[1590,3189]
sliceend=[2500,rs_end]
idx_slicestart=np.zeros_like(slicestart)
idx_sliceend=np.zeros_like(slicestart)
for i in range(len(slicestart)):
    idx_slicestart[i]=np.argmin(np.abs(rs-slicestart[i]))
    idx_sliceend[i]=np.argmin(np.abs(rs-sliceend[i]))

if os.path.isfile(preprocessed_data_path) and not read_all_mixtures :
    data_spec=pd.read_pickle(preprocessed_data_path)
    data_exist=True
else:
    data_exist=False




#%% read spectra from txt files\ real compositions from excel files

data_spec_list = []
if read_all_mixtures or data_exist==False:
    for foldername in foldernames:
        if (os.path.isdir(foldername)) and (not foldername=='__pycache__'):
            raw_folder = os.path.join(base_path, foldername.replace("-", "_"))
            if not os.path.isdir(raw_folder):       
                continue
        
            filenames = os.listdir(raw_folder)
            if len(filenames) == 0:       
                continue
        
            x1_list = []
            compound_1 = []
            compound_2 = []
            mixture = []
            spectra = np.empty([len(filenames), 1043]) 
            for i, filename in enumerate(filenames):
                fpath = os.path.join(raw_folder, filename)
                
                with open(fpath, "r", encoding="utf-8", errors="ignore") as f:
                    first_line = f.readline().strip()
                    x1_val = float(first_line)
                    x1_list.append(x1_val)
                    df = pd.read_csv(f, header=None, delimiter=r"\s+")
        
                spectra[i,:] = df.iloc[:-1,1].to_numpy()  
        
            
                mixture_name_raw = foldername.replace("_data_raw", "")
                parts = mixture_name_raw.split("_", 1)
                compound_1_val = parts[0]
                compound_2_val = parts[1].replace("_", " ") if len(parts) > 1 else ""
                
               
                mixture_name = f"{compound_1_val}-{compound_2_val}"
                
                compound_1.append(compound_1_val)
                compound_2.append(compound_2_val)
                mixture.append(mixture_name)
        
          
            dict_data_spec = {
                'Mixture': mixture,
                'compound_1': compound_1,
                'compound_2': compound_2,
                'x1': x1_list,
                'spectra': list(spectra)
            }
            data_spec = pd.DataFrame(dict_data_spec)
            data_spec['T'] = 298.15
    
            # Ramanshift-Indizes
            idx_start = int((np.abs(ramanshift - rs_start)).argmin())
            idx_end = int((np.abs(ramanshift - rs_end)).argmin())
            data_spec['ramanshift'] = pd.Series([ramanshift]*len(data_spec))
            data_spec['ramanshift_sliced'] = data_spec['ramanshift'].apply(SlicedRamanshift, idx_start=idx_start, idx_end=idx_end)
            data_spec = data_spec.sort_values(by=['x1']).reset_index(drop=True)
        
            mixturename = data_spec['Mixture'].iloc[0]
            basepoints = np.array(basepoints_dict[mixturename])
            data_spec['spectra_bc'] = data_spec['spectra'].apply(baseline_correction, ramanshift=ramanshift, basepoints=basepoints)
        
            # Methode A
            data_spec[['spectra_norm_c1','J']] = norm_spectra_c1(data_spec['spectra_bc'], ramanshift, idx_start, idx_end)
            data_spec['spectra_norm_c1_id'] = id_spectra(data_spec['x1'], data_spec['spectra_norm_c1'])
            data_spec['spectra_norm_c1_ex'] = data_spec['spectra_norm_c1'] - data_spec['spectra_norm_c1_id']
        
            # Methode B
            data_spec['spectra_norm'] = data_spec['spectra_bc'].apply(norm_spectra, ramanshift=ramanshift, idx_start=idx_start, idx_end=idx_end)
            data_spec[['spectra_id_norm','k']] = calc_k(ramanshift, data_spec['spectra_norm'], data_spec['x1'], idx_start, idx_end)
            data_spec['spectra_mol'] = calculate_mol_spectra(data_spec['x1'], data_spec['k'], data_spec['spectra_norm'])
            data_spec['I'] = (data_spec['x1'] + (1 - data_spec['x1']) * data_spec['k'])
            data_spec['spectra_mol_id'] = id_spectra(data_spec['x1'], data_spec['spectra_mol'])
            data_spec['spectra_mol_ex'] = data_spec['spectra_mol'] - data_spec['spectra_mol_id']
        
            # Partial spectra
            data_spec[['spectra_ex_part_c1','spectra_ex_part_c2']] = part_specs(data_spec['spectra_mol_ex'], data_spec['x1'])
            data_spec[['spectra_part_c1','spectra_part_c2']] = part_specs(data_spec['spectra_mol'], data_spec['x1'])
        
            # Thermodynamics
            NRTL_paras_all={'Acetone-Cyclohexane':[5957.1,12049.7,-12363,-42410.6,337.8,4950.4,0.4212],
                        'Acetone-Water':[3489.3,-13165.1,3477.2,73040.1,-1582.2,-5699.4,0.5466],
                        'Acetone-ACN':[1.84173,-373.389,-55.8721,1299.95,1088.62,-855.896,0.3],
                        'Acetone-Acetic acid':[-841.993,210.766,2178.95,1798.66,0,0,0.3]}
        
        
            NRTL_paras = np.array(NRTL_paras_all[mixturename][:-1])
            alpha=NRTL_paras_all[mixturename][-1]
            data_spec = pd.concat([data_spec,Calculate_gamma(298.15,data_spec['x1'],NRTL_paras,alpha)],axis=1)
            data_spec['gibbs_excess'] = GibbsExcess(data_spec['gamma_1'], data_spec['gamma_2'], data_spec['x1'], data_spec['T'])
        
            # Daten speichern
            if not data_exist:
                data_spec.to_pickle(preprocessed_data_path)
                data_exist = True
            else:
                data_old = pd.read_pickle(preprocessed_data_path)
                data_spec = pd.concat([data_old, data_spec])
                data_spec.to_pickle(preprocessed_data_path)

    data_spec = data_spec.reset_index(drop=True)
    data_spec = data_spec[data_spec['Mixture'] != 'Acetone-Ethanol']
    data_spec.to_pickle(preprocessed_data_path)

#%%    
#general settings for plotting
plt.rcParams.update({
    #"text.usetex": True,
   
    'font.size':'12'
})


#%% Fit of voigt profiles 

 
# peakcenters that shall be excluded in mixture fit

fit_dict_c1={'Acetone-Acetic acid':[900,1570,1750,2730,2855,3082],#1750,
              'Acetone-Cyclohexane':[900,1550,1750,2730,2855,3082],
              'Acetone-Water':[900,1550,1750,2730,2855,3082],
              'Acetone-ACN':[900,1550,1750,2730,2855,3082]}

fit_dict_c2={'Acetone-Acetic acid':[1515,2623],
              'Acetone-Cyclohexane':[1100,2458,2575,2606,2805,2970,3014],#1348,
              'Acetone-Water':[],
              'Acetone-ACN':[3100]}






voigt_mix_path = 'Y:\Publications\ITUN journal publications\Industrial and Chemical Engineering Research\Miriam 2025\OpARA/voigt.pkl'
if os.path.isfile(voigt_mix_path):
    old_voigt_frame=pd.read_pickle(voigt_mix_path)
    first=False
else:
    first=True
                   
mixtures=data_spec.groupby(['Mixture'])
n_mix=mixtures.ngroups

fp_start = rs[0]
fp_end = 1900
CH_OH_start = 2550
CH_OH_end = rs[-1]
idx_fp_start = np.argmin(np.abs(rs - fp_start))
idx_fp_end = np.argmin(np.abs(rs - fp_end))
idx_CH_OH_start = np.argmin(np.abs(rs - CH_OH_start))
idx_CH_OH_end = np.argmin(np.abs(rs - CH_OH_end))
mult_fact=4

i=0
for mixturename, mixture in mixtures:
    mixture=mixture.reset_index(drop=True)
    colors=plt.get_cmap('jet', 101)
    peaks_fixed_c1= np.array(fit_dict_c1[mixturename])
    peaks_fixed_c2= np.array(fit_dict_c2[mixturename])
    
    if first==False:
        if mixturename not in old_voigt_frame['Mixture'].values:
            
            print(mixturename)
           
            
            voigt_frame=voigt_paras(mixture['spectra_mol'],rs,mixture['x1'],peaks_fixed_c1,peaks_fixed_c2)
            
            voigt_frame_complete_new=mixture.join(voigt_frame)  
            comp_frame=pd.concat([old_voigt_frame,voigt_frame_complete_new])    
            comp_frame.to_pickle(voigt_mix_path)
            old_voigt_frame=comp_frame    
    else:
        print(mixturename)
    
        voigt_frame=voigt_paras(mixture['spectra_mol'],rs,mixture['x1'],peaks_fixed_c1,peaks_fixed_c2)
        
        voigt_frame_complete_new=mixture.join(voigt_frame)  
        voigt_frame_complete_new.to_pickle(voigt_mix_path)
        old_voigt_frame=voigt_frame_complete_new    
        first=False
            
data_voigt=pd.read_pickle(voigt_mix_path)
    



    

 #%% Figure 1
mixtures=data_spec.groupby(['Mixture'])
 
plot=True
if plot==True: 
    plt.rcParams.update({
        #"text.usetex": True,
       
        'font.size':'22'
    }) 
     
    mult_fact=4 
    
    for mixturename, mixture in mixtures:
        mixture = mixture.reset_index(drop=True)
        fig, axes = plt.subplots(1, 2, sharey=True, figsize=(10, 8))#, figsize=(20, 15)
        fig.subplots_adjust(left=0.12,right=0.93, wspace=0.02)
        
        ax1_left, ax1_right, = axes  # Achsen zuweisen
        for j in range(len(mixture)):
            
            c = mixture['x1'].iloc[j] * 100
            ax1_left.plot(rs[:idx_fp_end], mult_fact * mixture['spectra_mol'].iloc[j][:idx_fp_end], color=colors(int(c)))
            ax1_right.plot(rs[idx_CH_OH_start:], mixture['spectra_mol'].iloc[j][idx_CH_OH_start:], color=colors(int(c)))
            # X-Limits setzen
        ax1_left.set_xlim(rs[0], fp_end)
        ax1_right.set_xlim(CH_OH_start, rs[-1])
        
        norm = mpl.colors.Normalize(vmin=0,vmax=1)     
        sm = plt.cm.ScalarMappable(cmap=colors, norm=norm)
        sm.set_array([])
        cbar=plt.colorbar(sm, ticks=np.linspace(0,1,11), 
                      boundaries=np.arange(0,1,0.05))
        comp_1=mixture['compound_1'].iloc[0]
        cbar.set_label(f'x$_\mathregular{{{comp_1}}}$')
            
        # Achsenstile anpassen (gebrochene x-Achse)
        for ax_left, ax_right in [(ax1_left, ax1_right)]:
            ax_left.spines.right.set_visible(False)
            ax_right.spines.left.set_visible(False)
            ax_left.yaxis.tick_left()
            ax_right.yaxis.tick_right()
            ax_right.tick_params(labelleft=False)  # Labels nur links
        
            # Schrägstriche einfügen, um den Bruch zu visualisieren
            d = .015  # Neigung der Trennlinie
            kwargs = dict(transform=ax_left.transAxes, color='k', clip_on=False)
            ax_left.plot((1 - d, 1 + d), (-d, +d), **kwargs)  
            ax_left.plot((1 - d, 1 + d), (1 - d, 1 + d), **kwargs)  
            kwargs.update(transform=ax_right.transAxes)
            ax_right.plot((-d, +d), (-d, +d), **kwargs)  
            ax_right.plot((-d, +d), (1 - d, 1 + d), **kwargs)    
        
        ax_left.text(0.95, 0.9, f"x {mult_fact}", transform=ax_left.transAxes,
                  verticalalignment='top', horizontalalignment='right')
        
        ax_right.text(0.95, 0.9, "x 1", transform=ax_right.transAxes,
                  verticalalignment='top', horizontalalignment='right')
        # Labels setzen
        
        ax1_left.set_ylabel("Intensity")
        fig.text(0.5, 0.03, "Raman shift / $cm^{-1}$", ha='center', va='center')      
        
        
        plt.show()
    
    
 #%% Figure 2
mixtures=data_spec.groupby(['Mixture'])
plot=True
if plot==True: 
    plt.rcParams.update({
        #"text.usetex": True,
       
        'font.size':'26'
    }) 
     
    mult_fact=3
    show_mixtures=['Acetone-Cyclohexane','Acetone-Acetic acid']#,
    
    fig, axes = plt.subplots(len(show_mixtures),2, sharey=True, figsize=(12, 15))#, figsize=(20, 15)
    fig.subplots_adjust(left=0.16,right=0.93,top=0.97,bottom=0.1, wspace=0.02,hspace=0.1)
    i=0
    for mixturename, mixture in mixtures:
        if mixturename in show_mixtures:
            mixture = mixture.reset_index(drop=True)
            
            
            ax1_left, ax1_right, = axes[i,:]  # Achsen zuweisen
            for j in range(len(mixture)):
                
                c = mixture['x1'].iloc[j] * 100
                ax1_left.plot(rs[:idx_fp_end], mult_fact * mixture['spectra_mol_ex'].iloc[j][:idx_fp_end], color=colors(int(c)))
                ax1_right.plot(rs[idx_CH_OH_start:], mixture['spectra_mol_ex'].iloc[j][idx_CH_OH_start:], color=colors(int(c)))
                # X-Limits setzen
            ax1_left.set_xlim(rs[0], fp_end) 
            ax1_right.set_xlim(CH_OH_start, rs[-1])
            

            # Achsenstile anpassen (gebrochene x-Achse)
            for ax_left, ax_right in [(ax1_left, ax1_right)]:
                ax_left.spines.right.set_visible(False)
                ax_right.spines.left.set_visible(False)
                ax_left.yaxis.tick_left()
                ax_right.yaxis.tick_right()
                ax_right.tick_params(labelleft=False)  # Labels nur links
            
                # Schrägstriche einfügen, um den Bruch zu visualisieren
                d = .015  # Neigung der Trennlinie
                kwargs = dict(transform=ax_left.transAxes, color='k', clip_on=False)
                ax_left.plot((1 - d, 1 + d), (-d, +d), **kwargs)  
                ax_left.plot((1 - d, 1 + d), (1 - d, 1 + d), **kwargs)  
                kwargs.update(transform=ax_right.transAxes)
                ax_right.plot((-d, +d), (-d, +d), **kwargs)  
                ax_right.plot((-d, +d), (1 - d, 1 + d), **kwargs)    
            
            ax_left.text(0.95, 0.9, f"x {mult_fact}", transform=ax_left.transAxes,
                      verticalalignment='top', horizontalalignment='right')
            
            ax_right.text(0.95, 0.9, "x 1", transform=ax_right.transAxes,
                      verticalalignment='top', horizontalalignment='right')
           
            ax1_left.set_ylabel("Intensity")
            fig.text(0.5, 0.05, "Raman shift / $cm^{-1}$", ha='center', va='center',)      
            
            y_min=-0.005
            y_max=0.005
            ax1_left.set_ylim(y_min,y_max) 
            ax1_right.set_ylim(y_min,y_max)
            

            i+=1
            
    axes[0,0].text(0.05, 0.95, "a)", transform=axes[0,0].transAxes,
              fontsize=22, verticalalignment='top', horizontalalignment='left')
    
    axes[1,0].text(0.05, 0.95, "b)", transform=axes[1,0].transAxes,
              fontsize=22, verticalalignment='top', horizontalalignment='left')
            
            
            
    norm = mpl.colors.Normalize(vmin=0,vmax=1)     
    sm = plt.cm.ScalarMappable(cmap=colors, norm=norm)
    sm.set_array([])
    #cbar=plt.colorbar(sm, ticks=np.linspace(0,1,11), 
                  #boundaries=np.arange(0,1,0.05))
    cbar = fig.colorbar(sm, ax=axes.ravel().tolist(), location='right', shrink=0.95)
    
    comp_1=mixture['compound_1'].iloc[0]
    cbar.set_label(f'x$_\mathregular{{{comp_1}}}$')
    plt.show()

#%% Figure 3
mixtures=data_spec.groupby(['Mixture'])
plot=True
if plot==True: 
    plt.rcParams.update({
        #"text.usetex": True,
       
        'font.size':'26'
    }) 
     
    mult_fact=3
    show_mixtures=['Acetone-Water']#,'Acetone-Acetic acid'
    
    fig, axes = plt.subplots(2,2, sharey=True, figsize=(12, 15))#, figsize=(20, 15)
    fig.subplots_adjust(left=0.16,right=0.93,top=0.97,bottom=0.1, wspace=0.02,hspace=0.1)
   
    for mixturename, mixture in mixtures:
        if mixturename in show_mixtures:
            mixture = mixture.reset_index(drop=True)
            
            ax1_left, ax1_right, ax2_left, ax2_right= axes[0,0],axes[0,1],axes[1,0],axes[1,1]  # Achsen zuweisen
            for j in range(len(mixture)):
                
                c = mixture['x1'].iloc[j] * 100
                ax1_left.plot(rs[:idx_fp_end], mult_fact * mixture['spectra_ex_part_c1'].iloc[j][:idx_fp_end], color=colors(int(c)))
                ax1_right.plot(rs[idx_CH_OH_start:], mixture['spectra_ex_part_c1'].iloc[j][idx_CH_OH_start:], color=colors(int(c)))
                ax2_left.plot(rs[:idx_fp_end], mult_fact * mixture['spectra_ex_part_c2'].iloc[j][:idx_fp_end], color=colors(int(c)))
                ax2_right.plot(rs[idx_CH_OH_start:], mixture['spectra_ex_part_c2'].iloc[j][idx_CH_OH_start:], color=colors(int(c)))
                # X-Limits setzen
            ax1_left.set_xlim(rs[0], fp_end) 
            ax1_right.set_xlim(CH_OH_start, rs[-1])
            ax2_left.set_xlim(rs[0], fp_end) 
            ax2_right.set_xlim(CH_OH_start, rs[-1])
            

            # Achsenstile anpassen (gebrochene x-Achse)
            for ax_left, ax_right in [(ax1_left, ax1_right)]:
                ax_left.spines.right.set_visible(False)
                ax_right.spines.left.set_visible(False)
                ax_left.yaxis.tick_left()
                ax_right.yaxis.tick_right()
                ax_right.tick_params(labelleft=False)  # Labels nur links
            
                # Schrägstriche einfügen, um den Bruch zu visualisieren
                d = .015  # Neigung der Trennlinie
                kwargs = dict(transform=ax_left.transAxes, color='k', clip_on=False)
                ax_left.plot((1 - d, 1 + d), (-d, +d), **kwargs)  
                ax_left.plot((1 - d, 1 + d), (1 - d, 1 + d), **kwargs)  
                kwargs.update(transform=ax_right.transAxes)
                ax_right.plot((-d, +d), (-d, +d), **kwargs)  
            
                ax_right.plot((-d, +d), (1 - d, 1 + d), **kwargs)    
            for ax_left, ax_right in [(ax2_left, ax2_right)]:
                 ax_left.spines.right.set_visible(False)
                 ax_right.spines.left.set_visible(False)
                 ax_left.yaxis.tick_left()
                 ax_right.yaxis.tick_right()
                 ax_right.tick_params(labelleft=False)  # Labels nur links
             
                 # Schrägstriche einfügen, um den Bruch zu visualisieren
                 d = .015  # Neigung der Trennlinie
                 kwargs = dict(transform=ax_left.transAxes, color='k', clip_on=False)
                 ax_left.plot((1 - d, 1 + d), (-d, +d), **kwargs)  
                 ax_left.plot((1 - d, 1 + d), (1 - d, 1 + d), **kwargs)  
                 kwargs.update(transform=ax_right.transAxes)
                 ax_right.plot((-d, +d), (-d, +d), **kwargs)  
                 ax_right.plot((-d, +d), (1 - d, 1 + d), **kwargs)    
            
            ax1_left.text(0.95, 0.9, f"x {mult_fact}", transform=ax1_left.transAxes,
                      verticalalignment='top', horizontalalignment='right')
            ax1_right.text(0.95, 0.9, "x 1", transform=ax1_right.transAxes,
                      verticalalignment='top', horizontalalignment='right')
            ax1_left.set_ylabel("Intensity")
            
            ax2_left.text(0.95, 0.9, f"x {mult_fact}", transform=ax2_left.transAxes,
                      verticalalignment='top', horizontalalignment='right')
            ax2_right.text(0.95, 0.9, "x 1", transform=ax2_right.transAxes,
                      verticalalignment='top', horizontalalignment='right')
            ax2_left.set_ylabel("Intensity")
            
            
            
            fig.text(0.5, 0.05, "Raman shift / $cm^{-1}$", ha='center', va='center',)      
            
            y_min=-0.02
            y_max=0.02
            ax1_left.set_ylim(y_min,y_max) 
            ax1_right.set_ylim(y_min,y_max)
            ax2_left.set_ylim(y_min,y_max) 
            ax2_right.set_ylim(y_min,y_max)
            

            i+=1
            
    axes[0,0].text(0.05, 0.95, "a)", transform=axes[0,0].transAxes,
              fontsize=22, verticalalignment='top', horizontalalignment='left')
    
    axes[1,0].text(0.05, 0.95, "b)", transform=axes[1,0].transAxes,
              fontsize=22, verticalalignment='top', horizontalalignment='left')
            
            
            
    norm = mpl.colors.Normalize(vmin=0,vmax=1)     
    sm = plt.cm.ScalarMappable(cmap=colors, norm=norm)
    sm.set_array([])
    #cbar=plt.colorbar(sm, ticks=np.linspace(0,1,11), 
                  #boundaries=np.arange(0,1,0.05))
    cbar = fig.colorbar(sm, ax=axes.ravel().tolist(), location='right', shrink=0.95)
    
    comp_1=mixture['compound_1'].iloc[0]
    cbar.set_label(f'x$_\mathregular{{{comp_1}}}$')
    plt.show()

#%% Figure 4+5
plot=True
mixtures=data_spec.groupby(['Mixture'])
if plot==True:
    plt.rcParams.update({'font.size': '17'})
    
    fig, ax1 = plt.subplots(figsize=(11, 11))
    fig.subplots_adjust(left=0.2,right=0.77,bottom=0.15)
    ax2 = ax1.twinx() 
    for mixturename, mixture in mixtures:
        marker, color = find_marker(mixturename)
        ax1.plot(mixture['x1'],mixture['gibbs_excess'],color=color)
        ax2.scatter(mixture['x1'],np.sum(np.abs(np.vstack(np.array(mixture['spectra_mol_ex']))),axis=1),marker=marker,color=color,label=mixturename)
   
    mL, ML = ax1.get_ylim()
    mR, MR = ax2.get_ylim()
    
    wL = abs(mL)/(ML+abs(mL))
    wR = abs(mR)/(MR+abs(mR))
    
    MR = (mR*ML/mL if wL<=wR else MR      )
    mR = (mR       if wL<=wR else MR*mL/ML)
    
    ratio=np.abs(ML-mL)/(MR-mR)
    fac=0.25
    ax1.set_ylim(mL,ML+ML*fac)
    ax2.set_ylim(mR,MR+ML*fac/ratio)
    
    
    ax1.set_xlabel('$x_1$')
    ax1.set_ylabel('$g^E$/ kJ / mol')
    ax2.set_ylabel(r"$\left|I^E\right|$")
    #ax2.legend(loc='upper right', frameon=True, framealpha=0.8)
    
   
    markerslist=['o','D']
    legend_elements = [
        Line2D([0], [0], linestyle='-', color='black', label='$g^E$'),
        Line2D([0], [0], marker='o', color='w',markersize=10, markerfacecolor='w',label=r"$\left|I^E\right|$"),
        Line2D([0], [0], marker='o', color='w',markersize=10, markerfacecolor='w',label=''),
        Line2D([0], [0], marker='o', color='w',markersize=10, markerfacecolor='w',label='')]    
   
    for mixturename, (marker, color) in zip([m[0] for m in mixtures], [find_marker(m[0]) for m in mixtures]):
        legend_elements.append(Line2D([0], [0], marker=marker, color='w', markersize=10, markerfacecolor=color, label=mixturename if mixturename !="Acetone-ACN" else "Acetone-Acetonitrile" ))
  
    ax2.legend(handles=legend_elements, loc='upper center',framealpha=0.8, ncol=2,frameon=False)
    ax1.set_xlim(0,1)
    ax2.set_xlim(0,1)
     
    
    fig, ax1 = plt.subplots(figsize=(11, 7))
    fig.subplots_adjust(left=0.2,right=0.77,bottom=0.15)
    ax2 = ax1.twinx() 
    for mixturename, mixture in mixtures:
        marker, color = find_marker(mixturename)
        ax1.plot(mixture['x1'],np.log(mixture['gamma_1']),color=color)
        ax1.plot(mixture['x1'],np.log(mixture['gamma_2']),color=color)
        ax2.scatter(mixture['x1'],np.sum(np.abs(np.vstack(np.array(mixture['spectra_ex_part_c1']))),axis=1),marker=marker,color=color,label=mixturename)
        ax2.scatter(mixture['x1'],np.sum(np.abs(np.vstack(np.array(mixture['spectra_ex_part_c2']))),axis=1),marker=marker,color=color,label=mixturename)
    
    mL, ML = ax1.get_ylim()
    mR, MR = ax2.get_ylim()
    
    wL = abs(mL)/(ML+abs(mL))
    wR = abs(mR)/(MR+abs(mR))

    ML = (mL*MR/mR if wR<=wL else ML      )
    mL = (mL       if wR<=wL else ML*mR/MR)
    
    ax1.set_ylim(mL,6.2)
    ax2.set_ylim(mR,0.51)
    #ax2.set_ylim(mR,MR)
    
    ax1.set_xlim(0,1)
    ax2.set_xlim(0,1)
        
    ax1.set_xlabel('$x_1$')
    ax1.set_ylabel('ln($\gamma_i$)')
    ax2.set_ylabel(r"$\left|\bar{I}_i^{\ E}\right|$")

    legend_elements = [
        Line2D([0], [0], linestyle='-', color='black', label='ln($\gamma_i$)'),
        Line2D([0], [0], marker='D', color='w',markersize=10, markerfacecolor='w',label=r"$\left|\bar{I}_i^{\ E}\right|$"),
        Line2D([0], [0], marker='o', color='w',markersize=10, markerfacecolor='w',label=''),
        Line2D([0], [0], marker='o', color='w',markersize=10, markerfacecolor='w',label='')]

    for mixturename, (marker, color) in zip([m[0] for m in mixtures], [find_marker(m[0]) for m in mixtures]):
        legend_elements.append(Line2D([0], [0], marker=marker, color='w', markersize=10, markerfacecolor=color, label=mixturename))
    ax2.legend(handles=legend_elements, loc='upper center', framealpha=0.8, ncol=2,frameon=False)


#%% Figure 6
mixtures=data_voigt.groupby(['Mixture'])
plot=True

if plot==True:
    for mixturename,mixture in mixtures: 
        plt.rcParams.update({'font.size': '14'})
        
        fp_start = rs[0]
        fp_end = 1900
        CH_OH_start = 2550
        CH_OH_end = rs[-1]
        
        idx_fp_start = np.argmin(np.abs(rs - fp_start))
        idx_fp_end = np.argmin(np.abs(rs - fp_end))
        idx_CH_OH_start = np.argmin(np.abs(rs - CH_OH_start))
        idx_CH_OH_end = np.argmin(np.abs(rs - CH_OH_end))
        
        fig, axes = plt.subplots(1,2, sharey=True, figsize=(6, 5))
        fig.subplots_adjust(left=0.15,right=0.97, wspace=0.02)
        
        """ compound 1"""
        ax1_left, ax1_right, = axes[0],axes[1] 
        
        ax1_left.plot(rs[:idx_fp_end],mult_fact *mixture['spectra_mol'].iloc[-1][:idx_fp_end],color='k',label='spectrum')
        ax1_left.plot(rs[:idx_fp_end],mult_fact *mixture['voigt_fit'].iloc[-1][:idx_fp_end],color='k',linestyle='dashed',label='voigt fit')
        ax1_left.plot(rs[:idx_fp_end],mult_fact *(mixture['spectra_mol'].iloc[-1][:idx_fp_end]-mixture['voigt_fit'].iloc[-1][:idx_fp_end]),color='b',label='error')
        
        
        ax1_left.legend(handlelength=1,loc='upper right', frameon=False)
        
        ax1_right.plot(rs[idx_CH_OH_start:], mixture['spectra_mol'].iloc[-1][idx_CH_OH_start:],color='k')
        ax1_right.plot(rs[idx_CH_OH_start:], mixture['voigt_fit'].iloc[-1][idx_CH_OH_start:],color='k',linestyle='dashed')
        ax1_right.plot(rs[idx_CH_OH_start:], mixture['spectra_mol'].iloc[-1][idx_CH_OH_start:]-mixture['voigt_fit'].iloc[-1][idx_CH_OH_start:],color='b')
      
        first_fixed=True   
        first=True
        for i in range(len(mixture['paras_c1'].iloc[-1][0][:,0])):
            single_peak=pseudo_voigt(rs,mixture['paras_c1'].iloc[-1][0][i,:],1)
            if mixture['fitted_c1'].iloc[i]=='True':
                ax1_left.plot(rs[:idx_fp_end], mult_fact * single_peak[:idx_fp_end],color='dimgrey',linestyle='dashed')
               
                if first==True:
                    first=False
                    ax1_right.plot(rs[idx_CH_OH_start:], single_peak[idx_CH_OH_start:],color='dimgrey',linestyle='dashed',label='fitted')
                else:
                    ax1_right.plot(rs[idx_CH_OH_start:], single_peak[idx_CH_OH_start:],color='dimgrey',linestyle='dashed')
            else:
                if first_fixed==True:
                    first_fixed=False
                    ax1_right.plot(rs[idx_CH_OH_start:], single_peak[idx_CH_OH_start:],color='r',linestyle='dashed',label='fixed')
                else:
                    ax1_right.plot(rs[idx_CH_OH_start:], single_peak[idx_CH_OH_start:],color='r',linestyle='dashed')
                
                ax1_left.plot(rs[:idx_fp_end], mult_fact * single_peak[:idx_fp_end],color='r',linestyle='dashed')
        
        ax1_left.set_xlim(rs[0], fp_end)
        ax1_left.set_ylabel('Intensity')
        ax1_right.set_xlim(CH_OH_start, rs[-1])
       
        for ax_left, ax_right in [(ax1_left, ax1_right)]:
            ax_left.spines.right.set_visible(False)
            ax_right.spines.left.set_visible(False)
            ax_left.yaxis.tick_left()
            ax_right.yaxis.tick_right()
            ax_right.tick_params(labelleft=False)  
        
            d = .015  
            kwargs = dict(transform=ax_left.transAxes, color='k', clip_on=False)
            ax_left.plot((1 - d, 1 + d), (-d, +d), **kwargs)  
            ax_left.plot((1 - d, 1 + d), (1 - d, 1 + d), **kwargs)  
            kwargs.update(transform=ax_right.transAxes)
            ax_right.plot((-d, +d), (-d, +d), **kwargs)  
            ax_right.plot((-d, +d), (1 - d, 1 + d), **kwargs)    
        
        ax_left.text(0.95, 0.5, f"x {mult_fact}", transform=ax_left.transAxes,
                   verticalalignment='top', horizontalalignment='right')
        
        ax_right.text(0.95, 0.5, "x 1", transform=ax_right.transAxes,
                  verticalalignment='top', horizontalalignment='right')
        
        ax1_left.yaxis.set_major_locator(MultipleLocator(0.01))
        
        fig.text(0.5, 0.03, "Raman shift / $cm^{-1}$", ha='center', va='center')  
        ax1_right.legend(handlelength=1,loc='upper right',frameon=False)
        plt.show()        
    

        


    
#%% Figure 7
"""
Plot for peakcenters
compound 1

"""
mixtures=data_voigt.groupby(['Mixture'])
plot==True
if plot==True:
    plt.rcParams.update({'font.size': '15'})
    
    visible_ranges = [(3000, 3021), (2955, 2985), (2913, 2937), 
                       (1695, 1725), (1425, 1440.5), (1350, 1379),
                      (1217, 1245), (1062, 1082), (770, 805)]
    legend_range = (visible_ranges[0][1], visible_ranges[0][1] + 0.63)
    visible_ranges.insert(0, legend_range)
    
    fig, axes = plt.subplots(len(visible_ranges), 1, sharex=True, figsize=(6, 18), gridspec_kw={'hspace': 0.05})
    fig.subplots_adjust(left=0.14,right=0.93,top=0.99,bottom=0.08)
    legend_handles=[]

    for mixturename, mixture in mixtures:
        marker, color = find_marker(mixturename)
        x1 = np.array(mixture['x1'])
        centers_list_c1 = np.vstack(np.array(mixture['paras_c1'])).astype(np.float64)[:, :, 1]
        if mixturename !='Acetone-ACN':
            line =Line2D(x1, centers_list_c1[:, 2], linestyle='--', color=color, label=mixturename)
        else:
            line =Line2D(x1, centers_list_c1[:, 2], linestyle='--', color=color, label='Acetone-Acetonitrile' )
        legend_handles.append(line)  # Speichern des Handles
        for ax, (ymin, ymax) in zip(axes, visible_ranges):
            print(ymin)
            for i in range(len(centers_list_c1[0, :])):
                if not len(set(centers_list_c1[:, i])) == 1:
                    if i==0:
                        if mixturename !='Acetone-ACN':
                            ax.plot(x1, centers_list_c1[:, i],linestyle='--',marker=marker, color=color,label=mixturename )
                        else:
                            ax.plot(x1, centers_list_c1[:, i],linestyle='--',marker=marker, color=color,label='Acetone-Acetonitrile' )
                    else:
                        ax.plot(x1, centers_list_c1[:, i], linestyle='--',marker=marker, color=color)
    
            ax.set_ylim(ymin, ymax)
            ax.spines['top'].set_visible(False)
            ax.spines['bottom'].set_visible(False)
            
            d = 0.01  # Abstand der Striche
            kwargs = dict(transform=ax.transAxes, color='k', clip_on=False, linewidth=1)
            
            if ax!=axes[-1]:
                ax.plot((-d, +d), (-d, +d), **kwargs) 
                ax.plot((1 - d, 1 + d), (-d, +d), **kwargs)  
            if ax!=axes[0] and ax!=axes[1]:
                ax.plot((-d, +d), (1 - d, 1 + d), **kwargs)  
                ax.plot((1 - d, 1 + d), (1 - d, 1 + d), **kwargs)  
            ax.tick_params(axis='x', which='both', bottom=False, top=False, labelbottom=False)
            
        axes[-1].set_xlabel('$x_{acetone}$')
        axes[-1].tick_params(axis='x', which='both', bottom=True, top=False, labelbottom=True)
        axes[len(visible_ranges) // 2].set_ylabel('Raman shift/ $cm^{-1}$', loc='center')
    
        axes[-1].set_xlim([0, 1])
        axes[0].set_yticks([])
        axes[0].tick_params(axis='x', which='both', bottom=False, labelbottom=False)
    pos0 = axes[0].get_position()
    pos1 = axes[1].get_position()
    axes[0].set_position([pos0.x0, pos1.y1, pos0.width, pos0.height * 0.7]) 
        
    axes[-1].spines['bottom'].set_visible(True)
    axes[0].spines['top'].set_visible(True)
    axes[0].spines['bottom'].set_visible(False)
    axes[0].legend(handles=legend_handles, loc='lower center', fancybox=True, framealpha=0.6, ncol=2,handlelength=1,frameon=False)
    plt.show()






        


#%% Figure 8/ Figure S3
mixtures=data_voigt.groupby(['Mixture'])

plot=True
if plot==True:
    plt.rcParams.update({'font.size': '26'})

    show_mixtures=['Acetone-Cyclohexane','Acetone-Acetic acid']
    #show_mixtures=['Acetone-Water','Acetone-ACN']
    fig, ax = plt.subplots(len(show_mixtures),1, figsize=(12, 13))#, figsize=(12, 13)
    fig.subplots_adjust(left=0.1, right=0.95, bottom=0.1, top=0.95, wspace=0.02,hspace=0.02)
    k=0
    for mixturename, mixture in mixtures:
        if mixturename in show_mixtures:
            mixture = mixture.reset_index(drop=True)
            marker, color = find_marker(mixturename)
            x1 = np.array(mixture['x1'])
            x1_unique, unique_indices = np.unique(x1[:-1], return_index=True)
            x1_unique = np.append(x1_unique, x1[-1])
            unique_indices = np.append(unique_indices, len(x1) - 1)
            
            
            """compound 2"""    
            centers_list_c2 = np.vstack(np.array(mixture['paras_c2'])).astype(np.float64)[:, :, 1]
            centers_list_c2 = centers_list_c2[unique_indices, :]
            centers_list_c2[centers_list_c2 == 0] = np.nan
            centers_list_diff_c2 = centers_list_c2 - centers_list_c2[0, :]
            
            j=0
            for i in range(len(centers_list_diff_c2[0, :])):
                if not np.all((centers_list_diff_c2[:, i] == 0) | np.isnan(centers_list_diff_c2[:, i])):
                   
                    ax[k].plot(x1_unique, centers_list_diff_c2[:, i],linestyle= '--', color=color,marker=marker)
                    ax[k].text(x1_unique[-1] + 0.17, centers_list_diff_c2[-3, i],  f"{centers_list_c2[0, i]:.2f}", horizontalalignment='right' )
                    
            ax[k].set_xlim([0, 1.2])   
            ax[k].set_ylabel('Peak shift / $cm^{-1}$') 
            k+=1
    ax[0].tick_params(axis='x', which='both', bottom=False, labelbottom=False)
    ax[1].set_xlabel('x$_{1}$') 
    
    ax[0].text(0.05, 0.95, "a)", transform=ax[0].transAxes,
              verticalalignment='top', horizontalalignment='left')
    
    ax[1].text(0.05, 0.95, "b)", transform=ax[1].transAxes,
              verticalalignment='top', horizontalalignment='left')

plt.show()






#%% Figure S2
plot=False
if plot==True:
    plt.rcParams.update({'font.size': '14'})
    fp_start = rs[0]
    fp_end = 1900
    CH_OH_start = 2550
    CH_OH_start_ACN = 2100
    CH_OH_end = rs[-1]
    
    idx_fp_start = np.argmin(np.abs(rs - fp_start))
    idx_fp_end = np.argmin(np.abs(rs - fp_end))
    idx_CH_OH_start = np.argmin(np.abs(rs - CH_OH_start))
    idx_CH_OH_start_ACN = np.argmin(np.abs(rs - CH_OH_start_ACN))
    idx_CH_OH_end = np.argmin(np.abs(rs - CH_OH_end))
    
    fig = plt.figure(figsize=(15, 10))
    gs = gridspec.GridSpec(2, 5, wspace=0.02)  # 2 Zeilen, 4 Spalten (2 pro Mischung)
    
    positions = [(0, 0), (0, 3), (1, 0), (1, 3)]
    
    mix_nr_i=0
    mix_nr_j=0
    mixturen = list(mixtures)  # Falls mixtures ein Generator ist
    
    first=True
    first_fixed=True
    for idx, (mixturename, mixture) in enumerate(mixturen):
       
        row, col = positions[idx]
    
        ax1_left = fig.add_subplot(gs[row, col])
        ax1_right = fig.add_subplot(gs[row, col + 1], sharey=ax1_left)
        
        if mixturename=='Acetone-Water':
            
            mult_fact=1
        else:
            mult_fact=4
            
        if mixturename=='Acetone-ACN':
             idx_CH_OH_start=np.argmin(np.abs(rs - CH_OH_start_ACN))
        else:
            idx_CH_OH_start=np.argmin(np.abs(rs - CH_OH_start))
            
    
        """ compound 2"""
      
        ax1_left.plot(rs[:idx_fp_end],mult_fact *mixture['spectra_mol'].iloc[0][:idx_fp_end],color='k',label='spectrum')
        ax1_left.plot(rs[:idx_fp_end],mult_fact *mixture['voigt_fit'].iloc[0][:idx_fp_end],color='k',linestyle='dashed',label='voigt fit')
        ax1_left.plot(rs[:idx_fp_end],mult_fact *(mixture['spectra_mol'].iloc[0][:idx_fp_end]-mixture['voigt_fit'].iloc[0][:idx_fp_end]),color='b',label='error')
        
        if mix_nr_i==0 and mix_nr_j==0:
            ax1_left.legend(handlelength=1,frameon=False)
    
        ax1_right.plot(rs[idx_CH_OH_start:], mixture['spectra_mol'].iloc[0][idx_CH_OH_start:],color='k')
        ax1_right.plot(rs[idx_CH_OH_start:], mixture['voigt_fit'].iloc[0][idx_CH_OH_start:],color='k',linestyle='dashed')
        ax1_right.plot(rs[idx_CH_OH_start:], mixture['spectra_mol'].iloc[0][idx_CH_OH_start:]-mixture['voigt_fit'].iloc[0][idx_CH_OH_start:],color='b')
    
        
        for i in range(len(mixture['paras_c2'].iloc[0][0][:,0])):
            single_peak=pseudo_voigt(rs,mixture['paras_c2'].iloc[0][0][i,:],1)
            if mixture['fitted_c2'].iloc[i]=='True':
                ax1_left.plot(rs[:idx_fp_end], mult_fact * single_peak[:idx_fp_end],color='dimgrey',linestyle='dashed')
           
                if first==True:
                    first=False
                    ax1_right.plot(rs[idx_CH_OH_start:], single_peak[idx_CH_OH_start:],color='dimgrey',linestyle='dashed',label='fitted')
                else:
                    ax1_right.plot(rs[idx_CH_OH_start:], single_peak[idx_CH_OH_start:],color='dimgrey',linestyle='dashed')
            else:
                if first_fixed==True:
                    first_fixed=False
                    ax1_right.plot(rs[idx_CH_OH_start:], single_peak[idx_CH_OH_start:],color='r',linestyle='dashed',label='fixed')
                else:
                    ax1_right.plot(rs[idx_CH_OH_start:], single_peak[idx_CH_OH_start:],color='r',linestyle='dashed')
                
                ax1_left.plot(rs[:idx_fp_end], mult_fact * single_peak[:idx_fp_end],color='r',linestyle='dashed')
               
        
        if mix_nr_i==0 and mix_nr_j==0:
           
            ax1_right.legend(handlelength=1,frameon=False,loc='upper left')
        
        # X-Limits setzen
        ax1_left.set_xlim(rs[0], fp_end)
        # X-Limits setzen
        ax1_left.set_xlim(rs[0], fp_end)
        if mixturename=='Acetone-ACN':
            ax1_right.set_xlim(CH_OH_start_ACN, rs[-1])  
        else:
           
            ax1_right.set_xlim(CH_OH_start, rs[-1])
        
    
        ax1_left.spines['right'].set_visible(False)
        ax1_left.yaxis.set_ticks_position('left')
        
        ax1_right.spines['left'].set_visible(False)
        ax1_right.yaxis.set_ticks_position('none')
        ax1_right.get_yaxis().set_visible(False)
    
        # Schrägstriche einfügen, um den Bruch zu visualisieren
        d = .015  # Neigung der Trennlinie
        kwargs = dict(transform=ax1_left.transAxes, color='k', clip_on=False)
        ax1_left.plot((1 - d, 1 + d), (-d, +d), **kwargs)  
        ax1_left.plot((1 - d, 1 + d), (1 - d, 1 + d), **kwargs)  
        kwargs.update(transform=ax1_right.transAxes)
        ax1_right.plot((-d, +d), (-d, +d), **kwargs)  
        ax1_right.plot((-d, +d), (1 - d, 1 + d), **kwargs)    
    
        ax1_left.text(0.95, 0.8, f"x {mult_fact}", transform=ax1_left.transAxes,
                  fontsize=16, verticalalignment='top', horizontalalignment='right')
    
        ax1_right.text(0.95, 0.8, "x 1", transform=ax1_right.transAxes,
                  fontsize=16, verticalalignment='top', horizontalalignment='right')
        
        fig.text(0.75, 0.05, "Raman shift / $cm^{-1}$", ha='center', va='center')  
        fig.text(0.28, 0.05, "Raman shift / $cm^{-1}$", ha='center', va='center')  
       
        if mix_nr_i==0 and mix_nr_j==0:
                ax1_left.set_ylabel("Intensity")           
                mix_nr_j=2
                ax1_left.text(0.05, 0.95, "a)", transform=ax1_left.transAxes,verticalalignment='top', horizontalalignment='left')
        elif mix_nr_i==0 and mix_nr_j==2:        
                mix_nr_j=0
                mix_nr_i=1
                ax1_left.text(0.05, 0.95, "b)", transform=ax1_left.transAxes,verticalalignment='top', horizontalalignment='left')
        elif mix_nr_i==1 and mix_nr_j==0:
            ax1_left.set_ylabel("Intensity")
            mix_nr_j=2
            ax1_left.text(0.05, 0.95, "c)", transform=ax1_left.transAxes,verticalalignment='top', horizontalalignment='left')
        else:
            ax1_left.text(0.05, 0.95, "d)", transform=ax1_left.transAxes,verticalalignment='top', horizontalalignment='left')
                
        
    plt.show()  





#%% Figure S4
"""
Plot for peakwidths
compound 1

"""

mixtures=data_voigt.groupby(['Mixture'])
plot=False
if plot==True:
   
    plt.rcParams.update({'font.size': '15',
                         'axes.labelweight': 'normal',
                         'font.family': 'DejaVu Sans'})
    
    
    
    visible_ranges_width = [(40, 55), (5, 55), (10, 42), 
                        (15, 40), (37, 62), (10, 50),
                      (23, 37), (20, 37), (22, 53)]
    
   
    legend_range = (visible_ranges_width[0][1], visible_ranges_width[0][1] + 0.63)
    visible_ranges_width.insert(0, legend_range)
   
    
    fig, axes = plt.subplots(len(visible_ranges_width), 1, sharex=True,gridspec_kw={'hspace': 0.05}, figsize=(6, 18))#
    #fig.subplots_adjust(left=0.14,right=0.93,top=0.99,bottom=0.08)
    legend_handles=[]

    for mixturename, mixture in mixtures:
        marker, color = find_marker(mixturename)
        x1 = np.array(mixture['x1'])
        width_list_c1 = np.flip(np.vstack(np.array(mixture['paras_c1'])).astype(np.float64)[:, :, 2],axis=1)
        if mixturename !='Acetone-ACN':
            line =Line2D(x1, width_list_c1[:, 2], linestyle='--', color=color, label=mixturename)
        else:
            line =Line2D(x1, width_list_c1[:, 2], linestyle='--', color=color, label='Acetone-Acetonitrile' )
        legend_handles.append(line) 
        j=0
        i=0 
        axes_right=[]
        for ax, (ymin, ymax) in (zip(axes, visible_ranges_width)):
            if i==0:
               
                pass
            elif j<len(width_list_c1[0,:]):
                diff_widths_nan=list(set(width_list_c1[:, j]))
                diff_widths=[width for width in diff_widths_nan if not np.isnan(width)]
                
                while len(diff_widths) == 1 and j<len(width_list_c1[0,:])-1:
                    j+=1
                    diff_widths_nan=list(set(width_list_c1[:, j]))
                    diff_widths=[width for width in diff_widths_nan if not np.isnan(width)]
    
                if j==0:
                    if mixturename !='Acetone-ACN':
                        ax.plot(x1, width_list_c1[:, j],linestyle='--',marker=marker, color=color,label=mixturename )
                    else:
                        ax.plot(x1, width_list_c1[:, j],linestyle='--',marker=marker, color=color,label='Acetone-Acetonitrile' )
                else:
                    ax.plot(x1, width_list_c1[:, j], linestyle='--',marker=marker, color=color)
                    print(j)
            
    
            ax.spines['top'].set_visible(False)
            ax.spines['bottom'].set_visible(False)
            
            d = 0.01  
            kwargs = dict(transform=ax.transAxes, color='k', clip_on=False, linewidth=1)
            
            if ax != axes[-1]:
               ax.plot((-d, +d), (-d, +d), **kwargs) 
               ax.plot((1 - d, 1 + d), (-d, +d), **kwargs)  
            if ax != axes[0]:
                ax.plot((-d, +d), (1 - d, 1 + d), **kwargs)  
                ax.plot((1 - d, 1 + d), (1 - d, 1 + d), **kwargs)
            ax.tick_params(axis='x', which='both', bottom=False, top=False, labelbottom=False)
            ax.set_ylim(ymin, ymax)
            

            j+=1
            i+=1
        
            
    axes[-1].set_xlabel('$x_{acetone}$')
    axes[-1].tick_params(axis='x', which='both', bottom=True, top=False, labelbottom=True)
    axes[len(visible_ranges_width) // 2].set_ylabel('FWHM/ $cm^{-1}$', loc='center')
    

    axes[-1].set_xlim([0, 1])
    axes[0].set_yticks([])
   
    axes[0].tick_params(axis='x', which='both', bottom=False, labelbottom=False)
    pos0 = axes[0].get_position()
    pos1 = axes[1].get_position()
    axes[0].set_position([pos0.x0, pos1.y1, pos0.width, pos0.height * 0.7]) 
        
    axes[-1].spines['bottom'].set_visible(True)
    axes[0].spines['top'].set_visible(True)
    axes[0].spines['bottom'].set_visible(False)
    axes[0].legend(handles=legend_handles, loc='lower center', fancybox=True, framealpha=0.6, ncol=2,handlelength=1,frameon=False)
    
    
    plt.tight_layout()
    plt.show()
      
