shape2sas 0.0.1__py3-none-any.whl

shape2sas/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.7.0"

shape2sas/cli.py

@@ -0,0 +1,298 @@
+#!/usr/bin/python3
+
+import time
+import argparse
+import sys
+import numpy as np
+import shutil
+
+from . import __version__
+from .helpfunctions import (
+    check_3Dinput,
+    check_input,
+    float_list,
+    get_header_footer,
+    getStructureFactorClass,
+    printt,
+    separate_string,
+    str2bool,
+)
+from .models import getPointDistribution, save_points
+from .theoretical_scattering import (
+    calc_Iq_func,
+    calc_Pq_func,
+    calc_pr_func,
+    calc_S_func,
+    save_I_func,
+    save_pr_func,
+)
+from .structure_factors.structure_factors_helpfunctions import save_S_func
+from .simulated_scattering import save_Isim_func, simulate_data_func
+from .plots import generate_pdb, plot_2D, plot_fit, plot_results
+from .sesans import calc_G_sesans, plot_sesans, save_sesans, simulate_sesans
+
+
+def main(argv=None):
+    """Entry point for the ``shape2sas`` command."""
+    argv = sys.argv[1:] if argv is None else list(argv)
+       
+    ### start timing
+    start_total = time.time()
+
+    ### remove any existing log file
+    open('shape2sas.log','w').close()
+
+    ### welcome message
+    printt('#######################################################################################')
+    printt('RUNNING shape2sas version %s \n - for instructions type: shape2sas -h' % __version__)
+    command = "shape2sas"
+    for aa in argv:
+        if ' ' in aa:
+            command += " \"%s\"" % aa
+        else:
+            command += " %s" % aa
+    printt('command used: %s' % command)
+    printt('#######################################################################################')
+
+    ### input values 
+    parser = argparse.ArgumentParser(description='Shape2SaS - calculates small-angle scattering from a given shape defined by the user.')
+      
+    # mandatory inputs
+    parser.add_argument('-s', '--subunit', type=separate_string, nargs='+', action='extend',
+                       help='Type of subunits for each model.')
+    parser.add_argument('-d', '--dimension', type=float_list, nargs='+', action='append',
+                        help='dimensions of subunits for each model.')
+    
+    # optional model-dependent inputs:
+    parser.add_argument('-m', '--model_name', nargs='+', action='extend',
+                        help='Name of model.')
+    parser.add_argument('-sld', '--sld', type=float, nargs='+', action='append',
+                        help='excess scattering length density or contrast.')
+    parser.add_argument('-pd', '--polydispersity', type=float, nargs='+', action='extend',
+                        help='Polydispersity of subunits for each model.')
+    parser.add_argument('-com', '--com', type=float_list, nargs='+', action='append',
+                         help='displacement for each subunits in each model.')
+    parser.add_argument('-rot', '--rotation', type=float_list, nargs='+', action='append',
+                         help='rotation for each subunits in each model.')
+    parser.add_argument('-rotp', '--rotation_points', type=float_list, nargs='+', action='append',
+                         help='point to rotate around, for each subunit in each model (default: the subunit centre).')
+    parser.add_argument('-sigmar', '--sigma_r', type=float, nargs='+', action='extend',
+                        help='interface roughness for each model.')
+    parser.add_argument('-c', '--conc', type=float, nargs='+', action='extend',
+                        help='volume fraction concentration.')
+    parser.add_argument('-exclude', '--exclude_overlap', type=str2bool, nargs='+', action='extend',
+                        help='bool to exclude overlap.')
+
+    # optional structure factor related inputs
+    parser.add_argument('-S', '--S', type=str, nargs='+', action='extend',
+                        help='structure factor: None/HS/aggregation in each model.')
+    parser.add_argument('-Sp', '--S_par', type=float_list, nargs='+', action='append',
+                        help='parameters of structure factor for each model.')
+
+    # optional general inputs
+    parser.add_argument('-qmin', '--qmin', type=float, default=0.001, 
+                        help='Minimum q-value for the scattering curve.')
+    parser.add_argument('-qmax', '--qmax', type=float, default=0.5, 
+                        help='Maximum q-value for the scattering curve.')
+    parser.add_argument('-Nq', '--qpoints', type=int, default=400, 
+                        help='Number of points in q.')
+    parser.add_argument('-Np', '--prpoints', type=int, default=100, 
+                        help='Number of points in the pair distance distribution function.')
+    parser.add_argument('-N', '--Npoints', type=int, default=8000, 
+                        help='Number of simulated points per model.')
+    parser.add_argument('-expo', '--exposure', type=float, default=500, 
+                        help='Exposure time in arbitrary units.')
+
+    # optional plot options
+    parser.add_argument('-lin', '--xscale_lin', action='store_true', default=False, 
+                        help='include flag (no input) to make q scale linear instead of logarithmic.')
+    parser.add_argument('-hres', '--high_res', action='store_true', default=False, 
+                        help='include flag (no input) to output high resolution plot.')
+
+    # optional SESANS-related options (Shape2SESANS)
+    parser.add_argument('-ss', '--sesans', action='store_true', default=False,
+                        help='Calculate SESANS data from the SAS data.')
+    parser.add_argument('-sse', '--sesans_error', type=float, default=0.02, 
+                        help='Baseline SESANS error relative to max signal.')
+    parser.add_argument('-Nd', '--deltapoints', type=int, default=150,
+                        help='Number of points in delta.')
+    
+    # optional experimental data-related options (Shape2SAS-fit)
+    parser.add_argument('-dat','--data', 
+                        help='Path to experimental data')
+    
+    args = parser.parse_args(argv)
+
+    ### check input 
+  
+    # check that subunits and dimensions are provided
+    if args.subunit is None:
+        raise argparse.ArgumentError(args.subunit, "No subunit type was given as an input.")  
+    if args.dimension is None:
+        raise argparse.ArgumentError(args.dimension, "No dimensions were given as an input.")
+    # check that number of subunits matches number of dimension lists
+    for subunit, dimension in zip(args.subunit, args.dimension):
+         if len(subunit) != len(dimension):
+            raise argparse.ArgumentTypeError("Mismatch between number subunit types (%d) and dimensions lists (%d)." % (len(subunit),len(dimension)))    
+    num_models = len(args.subunit)
+    if num_models == 1:
+        printt(f"Simulating {num_models} model...")
+    else: 
+        printt(f"Simulating {num_models} models...")
+
+    # prepare lists (several models can be simulated simultaneously)
+    r_list, pr_norm_list, I_list, I_sim_list, sigma_list, S_list = [], [], [], [], [], [] 
+    x_list, y_list, z_list, sld_list, model_filename_list, model_name_list = [], [], [], [], [], []
+    if args.sesans:
+        delta_list,G_list,G_sim_list,sigma_G_list = [],[],[],[]
+
+    # loop over models
+    for i in range(num_models):
+        
+        ### read and print model name for model i
+        model_name = check_input(args.model_name, f"Model {i}", "model name", i)
+        if model_name in model_name_list:
+            #model names should be unique - else add a number
+            model_name += '_' + str(i+1)  
+        model_filename = "_".join(model_name.split()) # remove whitespace for filenames
+        model_name_list.append(model_name)
+        model_filename_list.append(model_filename)
+
+        #### read number of subunits, SLD, COM, rotation and exclude overlap for model i
+        N_subunits = len(args.subunit[i])
+        sld = check_3Dinput(args.sld, [1.0], "SLD", N_subunits, i)
+        com = check_3Dinput(args.com, [[0, 0, 0]], "COM", N_subunits, i)
+        rotation = check_3Dinput(args.rotation, [[0, 0, 0]], "rotation", N_subunits, i)
+        rotation_points = check_3Dinput(args.rotation_points, [[0, 0, 0]], "rotation points", N_subunits, i)
+        exclude_overlap = check_input(args.exclude_overlap, True, "exclude_overlap", i)
+
+        ### make point cloud
+        printt(f"    Generating points for Model: " + model_name)        
+        point_distribution = getPointDistribution(args.subunit[i],sld,args.dimension[i],com,rotation,exclude_overlap,args.Npoints,rotation_points)
+        save_points(point_distribution, model_filename)
+        x_list.append(np.concatenate(point_distribution.x))
+        y_list.append(np.concatenate(point_distribution.y))
+        z_list.append(np.concatenate(point_distribution.z))
+        sld_list.append(np.concatenate(point_distribution.sld))
+
+        ### read concentration, interface roughness/fuzziness, structure factor and structure factor-related parameters for model i
+        conc = check_input(args.conc, 0.02, "concentration", i)
+        sigma_r = check_input(args.sigma_r, 0.0, "sigma_r", i)
+        S_type = check_input(args.S, 'None', "Structure type", i)
+        stype = S_type.lower().replace("_", "").replace(" ", "")
+        try:
+            S_par = args.S_par[i][0]
+        except:
+            S_par = []
+
+        ### calculate p(r)
+        printt("\n    Calculating pair distance distribution, p(r)...")
+        polydispersity = check_input(args.polydispersity, 0.0, "polydispersity", i)
+        r, pr, pr_norm, dmax = calc_pr_func(point_distribution,prpoints=args.prpoints, polydispersity=polydispersity)
+        save_pr_func(r,pr_norm,model_filename)
+        r_list.append(r)
+        pr_norm_list.append(pr_norm)
+
+        ### define q (and if sesans is opted for, also define the spin echo length, delta)
+        if args.sesans:
+            # make extended q-range for sesans
+            # the structure factor decides the length scale: an aggregate is
+            # larger than the particle it is built from
+            qmin, deltamax = getStructureFactorClass(stype).getSesansRange(S_par, dmax)
+            qmax = 1e4 * qmin
+            qpoints = 5000
+            q = np.linspace(qmin,qmax,qpoints)
+            delta = np.linspace(0, deltamax, args.deltapoints)
+        elif args.data:
+            header,footer = get_header_footer(args.data) # replace with function
+            q,I_exp,sigma_exp = np.genfromtxt(args.data,skip_header=header,skip_footer=footer,usecols=[0,1,2],unpack=True)
+        else:
+            q = np.linspace(args.qmin,args.qmax,args.qpoints)
+
+        printt("\n    Calculating intensity, I(q)...")
+
+        ### calculate form factor and forward scattering I0
+        I0, Pq = calc_Pq_func(q, r, pr_norm, conc, point_distribution.volume_total)
+
+        ### calculate structure factor
+        S = calc_S_func(q,point_distribution, stype, S_par, Pq)
+        save_S_func(q,S,model_filename)
+        S_list.append(S)
+
+        ### calculate theoretical SAS (and SESANS)
+        I = calc_Iq_func(q, Pq, S, sigma_r)
+        save_I_func(q,I,model_filename)
+        I_list.append(I)
+        if args.sesans:
+            # calculated theoretical SESANS
+            G = calc_G_sesans(q,delta,I)
+            delta_list.append(delta)
+            G_list.append(G)
+
+        ### simulate SAXS (and SESANS)
+        I_sim,sigma = simulate_data_func(q,I,I0,args.exposure)
+        save_Isim_func(q,I_sim,sigma,model_filename)
+        I_sim_list.append(I_sim)
+        sigma_list.append(sigma) 
+        if args.sesans:
+            # simulate sesans data         
+            G_sim,sigma_G = simulate_sesans(delta,G,args.sesans_error)
+            # append to list (in case of multiple models)
+            G_sim_list.append(G_sim)
+            sigma_G_list.append(sigma_G)   
+
+    printt(" ")
+    printt("Generating plots")
+    colors = ['blue','red','green','orange','purple','cyan','magenta','black','grey','pink','forestgreen','gold','darkred','coral','peru','olive','springgreen','teal','skyblue','navy','lavender','blueviolet','deeppink']
+
+    if args.high_res:
+        filetype = 'pdf'
+    else:
+        filetype = 'png'
+
+    # plot 2D projections
+    for m in model_filename_list:
+        print("    2D projection:       points_" + m + "." + filetype)
+    plot_2D(x_list, y_list, z_list, sld_list, model_filename_list, filetype, colors)
+    
+    # 3D vizualization: generate pdb file with points
+    for m in model_filename_list:
+        print("    3D models:           " + m + ".pdb")
+    generate_pdb(x_list, y_list, z_list, sld_list, model_filename_list)
+    
+    # plot p(r) and I(q)
+    print("    pr, Iq, and Isim:    plot." + filetype)
+    plot_results(q, r_list, pr_norm_list, I_list, I_sim_list, sigma_list, S_list, model_name_list, args.xscale_lin, filetype, colors)
+
+    # plot fit
+    if args.data:
+        data_filename = args.data.split('/')[-1]
+        print("    fit(s) to exp data : fit." + filetype)
+        plot_fit(q, I_list, I_exp, sigma_exp, model_name_list, data_filename, args.xscale_lin, filetype, colors)
+
+    # plot and save sesans 
+    if args.sesans:
+        print("    SESANS G and Gsim  : sesans." + filetype)
+        plot_sesans(delta_list, G_list, G_sim_list, sigma_G_list, model_name_list, filetype, colors)
+        save_sesans(delta_list, G_list, G_sim_list, sigma_G_list, model_filename_list)
+
+    time_total = time.time() - start_total
+    printt(" ")
+    printt("Simulation successfully completed.")
+    printt("    Total run time:      " + str(round(time_total, 1)) + " seconds.")
+    printt(" ")
+
+    # close log file and copy into model directories
+    #f_out.close()
+    extension = '.' + filetype
+    for model_filename in model_filename_list:
+        shutil.copy('shape2sas.log', model_filename + '/' + model_filename + '.log' )
+        shutil.copy('plot' + extension, model_filename + '/plot_' + model_filename + extension)
+        if args.data:
+            shutil.copy('fit' + extension, model_filename + '/fit_' + model_filename + '_' + data_filename + extension)
+        if args.sesans:
+            shutil.copy('sesans' + extension, model_filename + '/sesans_' + model_filename + extension )
+
+
+if __name__ == "__main__":
+    main()

shape2sas/compare.py

@@ -0,0 +1,222 @@
+import argparse
+import re
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def main(argv=None):
+    """Entry point for the ``shape2sas-compare`` command."""
+
+    # input arguments
+    parser = argparse.ArgumentParser(description='Compare results from Shape2SAS')
+    parser.add_argument('-m', '--model_names',help='Model names')
+    parser.add_argument('-lin', '--xscale_lin', action='store_true', default=False, 
+                            help='include flag (no input) to make q scale linear instead of logarithmic.')
+    parser.add_argument('-hres', '--high_res', action='store_true', default=False, 
+                            help='include flag (no input) to output high resolution plot.')
+    parser.add_argument('-s', '--scale', action='store_true', default=False,
+                            help='include flag (no input) to scale the simulated intensity of each model in the plots to avoid overlap')    
+    parser.add_argument('-n', '--name', help='output filename', default='None')   
+    parser.add_argument('-g', '--grid',action='store_true',help='add grid in 2D point representation',default=False)
+    parser.add_argument('-norm', '--normalization',help='normalization method: max, I0 (default) or none ',default='max')
+    parser.add_argument('-ss', '--sesans', action='store_true',help='plot SESANS data',default=False)
+    parser.add_argument('-p', '--plot_points', action='store_true',help='plot point distribution data',default=False)
+
+    args = parser.parse_args(argv)
+
+    # colors and models
+    colors = ['blue','red','green','orange','purple','cyan','magenta','black','grey','pink','forrestgreen']
+    models = re.split('[ ,]+', args.model_names)
+
+    # resolution
+    if args.high_res:
+        format = '.pdf'
+    else:
+        format ='.png'
+
+    ### plot SAS data: p(r), I(q), Isim(q)
+    fig, ax = plt.subplots(1,3,figsize=(12,4))
+    scale_factor = 1
+    zo=1
+    all_model_names = ''
+    for i,model in enumerate(models):
+        pr_filename = model + '/pr_' + model + '.dat'
+        r,pr = np.genfromtxt(pr_filename,skip_header=1,unpack=True)
+        if args.normalization in ['I0','Forward_Scattering','I0','I(0)','integral']:
+            dr = r[4]-r[3]
+            pr /= pr.sum()*dr
+        elif args.normalization in ['max','Max','pr_max','prmax']:
+            pr /= np.max(pr)
+        elif args.normalization in ['none','no','None','No']:
+            pass
+        else: 
+            print('\n\nERROR: unknown normalization argument: ' + args.normalization + '. Should be "max" or "I0" or "none".\n\n')
+            exit()
+        ax[0].plot(r,pr,color=colors[i],label=model)
+
+        Iq_filename = model + '/Iq_' + model + '.dat'
+        q,I = np.genfromtxt(Iq_filename,skip_header=2,unpack=True)
+        ax[1].plot(q,I,color=colors[i],label=model)
+
+        Isim_filename = model + '/Isim_' + model + '.dat'
+        q,Isim,sigma = np.genfromtxt(Isim_filename,skip_header=3,unpack=True)
+        if args.scale: 
+            ax[2].errorbar(q,Isim*scale_factor,yerr=sigma*scale_factor,linestyle='none',marker='.', color=colors[i],label=r'$I_\mathrm{sim}(q)$, %s, scaled by %1.0e' % (model,scale_factor),zorder=1/zo)
+            scale_factor *= 0.1
+        else:
+            ax[2].errorbar(q,Isim,yerr=sigma,linestyle='none',marker='.', color=colors[i],label=r'$I_\mathrm{sim}(q)$, %s' % model,zorder=zo)
+        if i > 0:
+            all_model_names += '_'
+        all_model_names += model
+
+    ax[0].set_xlabel(r'$r$ [$\mathrm{\AA}$]')
+    ax[0].set_ylabel(r'$p(r)$')
+    ax[0].set_title('pair distance distribution function')
+    ax[0].legend(frameon=False)
+
+    if not args.xscale_lin:
+        ax[1].set_xscale('log')
+    ax[1].set_yscale('log')
+    ax[1].set_xlabel(r'$q$ [$\mathrm{\AA}^{-1}$]')
+    ax[1].set_ylabel(r'normalized $I(q)$')
+    ax[1].set_title('normalized scattering, no noise')
+    ax[1].legend(frameon=False)
+
+    if not args.xscale_lin:
+        ax[2].set_xscale('log')
+    ax[2].set_yscale('log')
+    ax[2].set_xlabel(r'$q$ [$\mathrm{\AA}^{-1}$]')
+    ax[2].set_ylabel(r'$I(q)$ [a.u.]')
+    ax[2].set_title('simulated scattering, with noise')
+    ax[2].legend(frameon=True)
+
+    plt.tight_layout()
+    if args.name == 'None':
+        plt.savefig(all_model_names + '_compare' + format)
+    else:
+        plt.savefig(args.name + '_compare' + format)
+
+
+    ### plot points: 2D projection  - if opted for
+    if args.plot_points:
+        n_models = len(models)
+        if n_models < 4: 
+            fig, ax = plt.subplots(len(models),3,figsize=(9,3*len(models)))
+        elif n_models < 8:
+            fig, ax = plt.subplots(len(models),3,figsize=(6,2*len(models)))
+        else:
+            fig, ax = plt.subplots(len(models),3,figsize=(3,1*len(models)))
+        markersize = 0.5
+
+        # find max dimension
+        max_l = 0
+        for i,model in enumerate(models):
+            points_filename = model + '/points_' + model + '.txt'
+            x,y,z,sld = np.genfromtxt(points_filename,skip_header=1,unpack=True)
+            if np.amax(abs(x)) > max_l:
+                max_l = np.amax(abs(x))
+            if np.amax(abs(y)) > max_l:
+                max_l = np.amax(abs(y))
+            if np.amax(abs(z)) > max_l:
+                max_l = np.amax(abs(z)) 
+            max_l *= 1.1
+            
+        lim = [-max_l, max_l]
+
+        for i,model in enumerate(models):
+
+            points_filename = model + '/points_' + model + '.txt'
+            x,y,z,sld = np.genfromtxt(points_filename,skip_header=1,unpack=True)
+            
+            ## find indices of positive, zero and negatative contrast
+            idx_neg = np.where(sld < 0.0)
+            idx_pos = np.where(sld > 0.0)
+            idx_nul = np.where(sld == 0.0)        
+            
+            ## plot, perspective 1
+            ax[i,0].plot(x[idx_pos], z[idx_pos], linestyle='none', marker='.', markersize=markersize, color=colors[i])
+            ax[i,0].plot(x[idx_neg], z[idx_neg], linestyle='none', marker='.', markersize=markersize, color='black')
+            ax[i,0].plot(x[idx_nul], z[idx_nul], linestyle='none', marker='.', markersize=markersize, color='grey')
+            ax[i,0].set_xlim(lim)
+            ax[i,0].set_ylim(lim)
+            ax[i,0].set_xlabel('x')
+            ax[i,0].set_ylabel('z')
+            if i == 0:
+                ax[i,0].set_title('pointmodel, (x,z), "front"')
+            if args.grid:
+                ax[i,0].grid()
+
+            ## plot, perspective 2
+            ax[i,1].plot(y[idx_pos], z[idx_pos], linestyle='none', marker='.', markersize=markersize, color=colors[i]) 
+            ax[i,1].plot(y[idx_neg], z[idx_neg], linestyle='none', marker='.', markersize=markersize, color='black')
+            ax[i,1].plot(y[idx_nul], z[idx_nul], linestyle='none', marker='.', markersize=markersize, color='grey')
+            ax[i,1].set_xlim(lim)
+            ax[i,1].set_ylim(lim)
+            ax[i,1].set_xlabel('y')
+            ax[i,1].set_ylabel('z')
+            if i == 0:
+                ax[i,1].set_title('pointmodel, (y,z), "side"')
+            if args.grid:
+                ax[i,1].grid()
+
+            ## plot, perspective 3
+            ax[i,2].plot(x[idx_pos], y[idx_pos], linestyle='none', marker='.', markersize=markersize, color=colors[i]) 
+            ax[i,2].plot(x[idx_neg], y[idx_neg], linestyle='none', marker='.', markersize=markersize, color='black')
+            ax[i,2].plot(x[idx_nul], y[idx_nul], linestyle='none', marker='.', markersize=markersize, color='grey')    
+            ax[i,2].set_xlim(lim)
+            ax[i,2].set_ylim(lim)
+            ax[i,2].set_xlabel('x')
+            ax[i,2].set_ylabel('y')
+            if i == 0:
+                ax[i,2].set_title('pointmodel, (x,y), "bottom"')
+            if args.grid:
+                ax[i,2].grid()
+        
+        plt.tight_layout()
+        if args.name == 'None':
+            plt.savefig(all_model_names + '_compare_points' + format)
+        else:
+            plt.savefig(args.name + '_compare_points' + format)
+    
+    ### plot sesans data, G(delta), G_sim(delta) - if opted for
+    if args.sesans:
+
+        fig, ax = plt.subplots(1,2,figsize=(8,4))
+        scale_factor = 1
+        for i,model in enumerate(models):
+            G_filename = model + '/G_' + model + '.ses'
+            d,G = np.genfromtxt(G_filename,skip_header=2,unpack=True)
+            ax[0].plot(d,G,color=colors[i],label=model)
+
+            ax[0].set_ylabel(r'$G(\delta)$ [cm$^{-1}$]')
+            ax[0].set_xlabel(r'$\delta$ [$\mathrm{\AA}$]')
+            ax[0].set_title('theoretical SESANS, no noise')
+            ax[0].legend(frameon=False)
+        
+            Gsim_filename = model + '/Gsim_' + model + '.ses'
+            d,Gsim,sigmaG = np.genfromtxt(Gsim_filename,skip_header=2,unpack=True)
+            if args.scale: 
+                ax[1].errorbar(d,Gsim*scale_factor,yerr=sigmaG*scale_factor,linestyle='none',marker='.', color=colors[i],label=r'$I_\mathrm{sim}(q)$, %s, scaled by %1.0e' % (model,scale_factor),zorder=1/zo)
+                scale_factor *= 0.1
+            else:
+                ax[1].errorbar(d,Gsim,yerr=sigmaG,linestyle='none',marker='.', color=colors[i],label=r'$I_\mathrm{sim}(q)$, %s' % model,zorder=zo)
+            if i > 0:
+                all_model_names += '_'
+            all_model_names += model
+
+            ax[1].set_xlabel(r'$\delta$ [$\mathrm{\AA}$]')
+            ax[1].set_ylabel(r'$\ln(P)/(t\lambda^2)$ [$\mathrm{\AA}^{-2}$cm$^{-1}$]')
+            ax[1].set_title('simulated SESANS, with noise')
+            ax[1].legend(frameon=True)
+
+        plt.tight_layout()
+        if args.name == 'None':
+            plt.savefig(all_model_names + '_sesans' + format)
+        else:
+            plt.savefig(args.name + '_sesans' + format)
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()