def run():
    # Quantities for the response function
    # and randomization
    # 
    #E_mod = 70 * 1e+9 # Pa
    #sig_u = 1.25 * 1e+9 # Pa
    #D = 26 * 1.0e-6 # m
    #A = ( D / 2.0 ) ** 2 * pi
    #xi_u = sig_u / E_mod

    # construct a default response function for a single filament
    dict_var = {'fu':1200.0e6,
                'qf':1500.,
                'L':0.02,
                'A':5.30929158457e-10,
                'E_mod':70.0e9,
                'z':0.0,
                'phi':0.0,
                'f':0.0}

    # random variable dictionary
    n_int = 20 # 10
    dict_rv = {
               'fu':{'variable':'fu', 'distribution':'weibull_min', 'loc':1200.0e6, 'scale':200., 'n_int':n_int },
               'qf':{'variable':'qf', 'distribution':'uniform', 'loc':1500., 'scale':100., 'n_int':n_int },
               'L':{'variable':'L', 'distribution':'uniform', 'loc':0.02, 'scale':0.02 / 2., 'n_int':n_int},
               'A':{'variable':'A', 'distribution':'uniform', 'loc':5.30929158457e-10, 'scale':.03 * 5.30929158457e-10, 'n_int':n_int },
               'E_mod':{'variable':'E_mod', 'distribution':'uniform', 'loc':70.e9, 'scale':250.e9, 'n_int':n_int},
               'z':{'variable':'z', 'distribution':'uniform', 'loc':0., 'scale':.03, 'n_int':n_int },
               'phi':{'variable':'phi', 'distribution':'sin_distr', 'loc':0., 'scale':1., 'n_int':n_int},
               'f':{'variable':'f', 'distribution':'uniform', 'loc':0., 'scale':.03, 'n_int':n_int },
               }

    # list of all combinations of response function parameters
    rv_comb_list = list(powerset(dict_rv))

    # define a tables with the run configurations to start in a batch
    run_list = [
                (
                 {'cached_dG'         : False,
                  'compiled_QdG_loop'  : True,
                  'compiled_eps_loop' : True },
                  'bx-',
                  '$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot g[\\theta_1]  g[\\theta_2] \dots g[\\theta_n] ) $ - %4.2f sec'
                 ),
                (
                 {'cached_dG'         : False,
                  'compiled_QdG_loop'  : True,
                  'compiled_eps_loop' : False },
                 'r-2',
                 '$\mathrm{P}_{e} ( \mathrm{C}_{\\theta} ( q(e,\\theta) \cdot g[\\theta_1]  g[\\theta_2] \dots g[\\theta_n] ) ) $ - %4.2f sec',
                 ),
                 (
                 {'cached_dG'         : True,
                  'compiled_QdG_loop'  : False,
                  'compiled_eps_loop' : False },
                 'y--',
                 '$\mathrm{P}_{e} ( \mathrm{N}_{\\theta} ( q(e,\\theta) \cdot G[\\theta] ) ) $ - %4.2f sec'
                 ),
                (
                 {'cached_dG'         : True,
                  'compiled_QdG_loop'  : True,
                  'compiled_eps_loop' : True },
                  'go-',
                  '$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot G[\\theta] ) $ - %4.2f sec',
                  ),
                ]

    outfile = open('pullout_comb_stat.dat', 'w')
    sp1_outfile = open('pullout_comb_1.dat', 'w')
    sp2_outfile = open('pullout_comb_2.dat', 'w')

    plot = True

    for id, rv_comb in enumerate(rv_comb_list[163:219]):#[0,-1]
        for i in range(0, 2):
            num_rv = len(rv_comb) # number of randomized variables
            if i == 0:
                sp1_outfile.write('%i \t %i' % (id, num_rv))
            else:
                sp2_outfile.write('%i \t %i' % (id, num_rv))
            # construct a default response function
            rf = ConstantFrictionFiniteFiber()
            rf.set(**dict_var)

            # construct the integrator and provide it with the response function.  
            s = SPIRRID(rf = rf,
                        min_eps = 0.00, max_eps = 0.012, n_eps = 40) # max_eps = 0.05

            for rv in rv_comb:#['fu', 'A', 'E_mod', 'z', 'f']:
                s.add_rv(**dict_rv[rv])

            if plot == True:
                legend = []

            print 'Combination', rv_comb, ' -- ', i
            outfile.write("Combination %s -- %i\n" % (rv_comb, i))
            outfile.write("%s \t %s\n" % ("Run", "Time"))

            for idx, run in enumerate(run_list):
                run_options, plot_options, legend_string = run
                print 'run', idx,
                s.set(**run_options)
                if plot == True:
                    plt.figure(id)
                    #s.mean_curve.plot(plt, plot_options)
                    plt.plot(np.linspace(s.min_eps, s.max_eps, s.n_eps), s.mu_q_arr, plot_options)
                    legend.append(legend_string % s.exec_time)
                print 'execution time', s.exec_time
                outfile.write("%s \t %.6f\n" % (idx, s.exec_time))

                if i == 0:
                    sp1_outfile.write("\t %.6f" % (s.exec_time))
                else:
                    sp2_outfile.write("\t %.6f" % (s.exec_time))
            plt.show()

            outfile.write("=================\n")
            outfile.flush()

            if i == 0:
                sp1_outfile.write('\t %s\n' % str(rv_comb))
                sp1_outfile.flush()
            else:
                sp2_outfile.write('\t %s\n' % str(rv_comb))
                sp2_outfile.flush()
            if plot == True:
                plt.xlabel('strain [-]')
                plt.ylabel('stress')
                plt.legend(legend)
                plt.title(s.rf.title)

        del s


    outfile.close()
    sp1_outfile.close()
    sp2_outfile.close()
    if plot == True:
        plt.show()
        offset = idx * width
        n_rv = idx + 1

        n_int = int(pow(memsize, 1 / float(n_rv)))
        print 'n_int', n_int


        s = SPIRRID(rf = rf,
                     min_eps = 0.00, max_eps = 1.0, n_eps = 20,
                     compiler_verbose = 0
                     )


        for rv in range(n_rv):
            param_key = rf.param_keys[ rv ]
            s.add_rv(param_key, n_int = n_int)
        time_plot.append(run_study(s, run_dict, offset, width)[1])

    plt.figure(0)
    plt.plot(range(1, len(rf.param_keys) + 1), time_plot, '-o', color = 'black', linewidth = 1)

    plt.figure(1)
    plt.plot([1.0, 2.0 + width * n_params], [1.0, 1.0], '-o', color = 'black')

    plt.figure(0)
    plt.ylabel('$\mathrm{normalized \, execution \, time \, [-]}$', size = 20)
    plt.xlabel('$\mathrm{number \, of \, randomized \, parameters}$', size = 20)
    newYTicks = [ ('$%i$' % y) for y in plt.yticks()[0]]
    plt.yticks(plt.yticks()[0], newYTicks)
    newXTicks = [ ('$%i$' % x) for x in plt.xticks()[0]]
    plt.xticks(plt.xticks()[0], newXTicks, position = (0, -.01))
Esempio n. 3
0
def run():
    # Quantities for the response function
    # and randomization

    # construct a default response function for a single filament

    rf = ConstantFrictionFiniteFiber(fu = 1200e15, qf = 1200,
                                     L = 0.02, A = 0.00000002,
                                     E = 210.e9, z = 0.004,
                                     phi = 0.5, f = 0.01)

    # construct the integrator and provide it with the response function.

    s = SPIRRID(rf = rf,
                 min_eps = 0.00, max_eps = 0.0008, n_eps = 380)

    # construct the random variables

    n_int = 25

    s.add_rv('E_mod', distribution = 'uniform', loc = 170.e9, scale = 250.e9, n_int = n_int)
    s.add_rv('L', distribution = 'uniform', loc = 0.02, scale = 0.03, n_int = n_int)
    s.add_rv('phi', distribution = 'sin_distr', loc = 0., scale = 1., n_int = n_int)
    s.add_rv('z', distribution = 'uniform', loc = 0, scale = rf.L / 2., n_int = n_int)

    # define a tables with the run configurations to start in a batch

    run_list = [
                (
                 {'cached_dG'         : False,
                  'compiled_QdG_loop'  : True,
                  'compiled_eps_loop' : True },
                  'bx-',
                  '$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot g[\\theta_1]  g[\\theta_2] \dots g[\\theta_n] ) $ - %4.2f sec'
                 ),
                (
                 {'cached_dG'         : False,
                  'compiled_QdG_loop'  : True,
                  'compiled_eps_loop' : False },
                 'r-2',
                 '$\mathrm{P}_{e} ( \mathrm{C}_{\\theta} ( q(e,\\theta) \cdot g[\\theta_1]  g[\\theta_2] \dots g[\\theta_n] ) ) $ - %4.2f sec',
                 ),
                (
                 {'cached_dG'         : True,
                  'compiled_QdG_loop'  : True,
                  'compiled_eps_loop' : True },
                  'go-',
                  '$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot G[\\theta] ) $ - %4.2f sec',
                  ),
                (
                 {'cached_dG'         : True,
                  'compiled_QdG_loop'  : False,
                  'compiled_eps_loop' : False },
                 'b--',
                 '$\mathrm{P}_{e} ( \mathrm{N}_{\\theta} ( q(e,\\theta) \cdot G[\\theta] ) ) $ - %4.2f sec'
                 ),
                ]

    for idx, run in enumerate(run_list):
        run_options, plot_options, legend_string = run
        print 'run', idx,
        s.set(**run_options)
        s.mean_curve.plot(plt, plot_options, linewidth = 2, label = legend_string % s.exec_time)
        print 'execution time', s.exec_time

#    def f():
#        print 'exec_time', s.exec_time
#
#    global f
#
#    import cProfile
#
#    cProfile.run('f()', 'spirrid.tprof')
#    import pstats
#    p = pstats.Stats('spirrid.tprof')
#    p.strip_dirs()
#    print 'cumulative'
#    p.sort_stats('cumulative').print_stats(50)
#    print 'time'
#    p.sort_stats('time').print_stats(50)

    plt.xlabel('strain [-]')
    plt.ylabel('stress')
    plt.legend(loc = 'lower right')

    plt.title(s.rf.title)
    plt.show()
Esempio n. 4
0
def run():
    # Quantities for the response function
    # and randomization
    #
    E_mod = 70 * 1e+9  # Pa
    sig_u = 1.25 * 1e+9  # Pa
    D = 26 * 1.0e-6  # m
    A = (D / 2.0)**2 * pi
    xi_u = sig_u / E_mod

    # construct a default response function for a single filament

    rf = Filament(E_mod=70.e9, xi=0.02, A=A, theta=0, lambd=0)

    # construct the integrator and provide it with the response function.

    s = SPIRRID(rf=rf, min_eps=0.00, max_eps=0.05, n_eps=20)

    # construct the random variables

    n_int = 40

    s.add_rv('xi',
             distribution='weibull_min',
             scale=0.02,
             shape=10.,
             n_int=n_int)
    s.add_rv('E_mod',
             distribution='uniform',
             loc=70e+9,
             scale=15e+9,
             n_int=n_int)
    s.add_rv('theta', distribution='uniform', loc=0.0, scale=0.01, n_int=n_int)
    s.add_rv('lambd', distribution='uniform', loc=0.0, scale=.2, n_int=n_int)
    s.add_rv('A',
             distribution='uniform',
             loc=A * 0.3,
             scale=0.7 * A,
             n_int=n_int)

    # define a tables with the run configurations to start in a batch

    run_list = [
        ({
            'cached_dG': False,
            'compiled_QdG_loop': True,
            'compiled_eps_loop': True
        }, 'bx-',
         '$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot g[\\theta_1]  g[\\theta_2] \dots g[\\theta_n] ) $ - %4.2f sec'
         ),
        (
            {
                'cached_dG': False,
                'compiled_QdG_loop': True,
                'compiled_eps_loop': False
            },
            'r-2',
            '$\mathrm{P}_{e} ( \mathrm{C}_{\\theta} ( q(e,\\theta) \cdot g[\\theta_1]  g[\\theta_2] \dots g[\\theta_n] ) ) $ - %4.2f sec',
        ),
        (
            {
                'cached_dG': True,
                'compiled_QdG_loop': True,
                'compiled_eps_loop': True
            },
            'go-',
            '$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot G[\\theta] ) $ - %4.2f sec',
        ),
        ({
            'cached_dG': True,
            'compiled_QdG_loop': False,
            'compiled_eps_loop': False
        }, 'y--',
         '$\mathrm{P}_{e} ( \mathrm{N}_{\\theta} ( q(e,\\theta) \cdot G[\\theta] ) ) $ - %4.2f sec'
         ),
    ]

    legend = []

    for idx, run in enumerate(run_list):
        run_options, plot_options, legend_string = run
        print 'run', idx,
        s.set(**run_options)
        print 'xdata', s.mean_curve.xdata
        print 'ydata', s.mean_curve.ydata
        s.mean_curve.plot(plt, plot_options)

        print 'integral of the pdf theta', s.eval_i_dG_grid()
        print 'execution time', s.exec_time
        legend.append(legend_string % s.exec_time)

    plt.xlabel('strain [-]')
    plt.ylabel('stress')
    plt.legend(legend)

    plt.title(s.rf.title)
    plt.show()
Esempio n. 5
0
        for i in range(0, 1):#2
            num_rv = len(rv_comb) # number of randomized variables
            if i == 0:
                sp1_outfile.write('%i \t %i' % (id, num_rv))
            else:
                sp2_outfile.write('%i \t %i' % (id, num_rv))
            # construct a default response function
            rf = Filament()
            rf.set(**dict_var)

            # construct the integrator and provide it with the response function.  
            s = SPIRRID(rf = rf,
                        min_eps = 0.00, max_eps = 0.04, n_eps = 20) # max_eps = 0.05

            for rv in rv_comb:
                s.add_rv(**dict_rv[rv])

            if plot == True:
                legend = []

            print 'Combination', rv_comb, ' -- ', i
            outfile.write("Combination %s -- %i\n" % (rv_comb, i))
            outfile.write("%s \t %s\n" % ("Run", "Time"))

            for idx, run in enumerate(run_list):
                run_options, plot_options, legend_string = run
                print 'run', idx,
                s.set(**run_options)
                if plot == True:
                    plt.figure(id)
                    s.mean_curve.plot(plt, plot_options)
Esempio n. 6
0
def run():
    # Quantities for the response function
    # and randomization
    # 
    E_mod = 70 * 1e+9 # Pa
    sig_u = 1.25 * 1e+9 # Pa
    D = 26 * 1.0e-6 # m
    A = ( D / 2.0 ) ** 2 * pi
    xi_u = sig_u / E_mod

    # construct a default response function for a single filament

    rf = Filament( E_mod = 70.e9, xi = 0.02, A = A, theta = 0, lambd = 0 )

    # construct the integrator and provide it with the response function.

    s = SPIRRID( rf = rf,
                 min_eps = 0.00, max_eps = 0.05, n_eps = 20 )

    # construct the random variables

    n_int = 40

    s.add_rv( 'xi', distribution = 'weibull_min', scale = 0.02, shape = 10., n_int = n_int )
    s.add_rv( 'E_mod', distribution = 'uniform', loc = 70e+9, scale = 15e+9, n_int = n_int )
    s.add_rv( 'theta', distribution = 'uniform', loc = 0.0, scale = 0.01, n_int = n_int )
    s.add_rv( 'lambd', distribution = 'uniform', loc = 0.0, scale = .2, n_int = n_int )
    s.add_rv( 'A', distribution = 'uniform', loc = A * 0.3, scale = 0.7 * A, n_int = n_int )

    # define a tables with the run configurations to start in a batch

    run_list = [
                ( 
                 {'cached_dG'         : False,
                  'compiled_QdG_loop'  : True,
                  'compiled_eps_loop' : True },
                  'bx-',
                  '$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot g[\\theta_1]  g[\\theta_2] \dots g[\\theta_n] ) $ - %4.2f sec'
                 ),
                ( 
                 {'cached_dG'         : False,
                  'compiled_QdG_loop'  : True,
                  'compiled_eps_loop' : False },
                 'r-2',
                 '$\mathrm{P}_{e} ( \mathrm{C}_{\\theta} ( q(e,\\theta) \cdot g[\\theta_1]  g[\\theta_2] \dots g[\\theta_n] ) ) $ - %4.2f sec',
                 ),
                ( 
                 {'cached_dG'         : True,
                  'compiled_QdG_loop'  : True,
                  'compiled_eps_loop' : True },
                  'go-',
                  '$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot G[\\theta] ) $ - %4.2f sec',
                  ),
                ( 
                 {'cached_dG'         : True,
                  'compiled_QdG_loop'  : False,
                  'compiled_eps_loop' : False },
                 'y--',
                 '$\mathrm{P}_{e} ( \mathrm{N}_{\\theta} ( q(e,\\theta) \cdot G[\\theta] ) ) $ - %4.2f sec'
                 ),
                ]

    legend = []

    for idx, run in enumerate( run_list ):
        run_options, plot_options, legend_string = run
        print 'run', idx,
        s.set( **run_options )
        print 'xdata', s.mean_curve.xdata
        print 'ydata', s.mean_curve.ydata
        s.mean_curve.plot( plt, plot_options )

        print 'integral of the pdf theta', s.eval_i_dG_grid()
        print 'execution time', s.exec_time
        legend.append( legend_string % s.exec_time )

    plt.xlabel( 'strain [-]' )
    plt.ylabel( 'stress' )
    plt.legend( legend )

    plt.title( s.rf.title )
    plt.show()
Esempio n. 7
0
def run():
    # Quantities for the response function
    # and randomization

    # construct a default response function for a single filament

    rf = ConstantFrictionFiniteFiber(fu=1200e15,
                                     qf=1200,
                                     L=0.02,
                                     A=0.00000002,
                                     E=210.e9,
                                     z=0.004,
                                     phi=0.5,
                                     f=0.01)

    # construct the integrator and provide it with the response function.

    s = SPIRRID(rf=rf, min_eps=0.00, max_eps=0.0008, n_eps=380)

    # construct the random variables

    n_int = 25

    s.add_rv('E_mod',
             distribution='uniform',
             loc=170.e9,
             scale=250.e9,
             n_int=n_int)
    s.add_rv('L', distribution='uniform', loc=0.02, scale=0.03, n_int=n_int)
    s.add_rv('phi', distribution='sin_distr', loc=0., scale=1., n_int=n_int)
    s.add_rv('z', distribution='uniform', loc=0, scale=rf.L / 2., n_int=n_int)

    # define a tables with the run configurations to start in a batch

    run_list = [
        ({
            'cached_dG': False,
            'compiled_QdG_loop': True,
            'compiled_eps_loop': True
        }, 'bx-',
         '$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot g[\\theta_1]  g[\\theta_2] \dots g[\\theta_n] ) $ - %4.2f sec'
         ),
        (
            {
                'cached_dG': False,
                'compiled_QdG_loop': True,
                'compiled_eps_loop': False
            },
            'r-2',
            '$\mathrm{P}_{e} ( \mathrm{C}_{\\theta} ( q(e,\\theta) \cdot g[\\theta_1]  g[\\theta_2] \dots g[\\theta_n] ) ) $ - %4.2f sec',
        ),
        (
            {
                'cached_dG': True,
                'compiled_QdG_loop': True,
                'compiled_eps_loop': True
            },
            'go-',
            '$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot G[\\theta] ) $ - %4.2f sec',
        ),
        ({
            'cached_dG': True,
            'compiled_QdG_loop': False,
            'compiled_eps_loop': False
        }, 'b--',
         '$\mathrm{P}_{e} ( \mathrm{N}_{\\theta} ( q(e,\\theta) \cdot G[\\theta] ) ) $ - %4.2f sec'
         ),
    ]

    for idx, run in enumerate(run_list):
        run_options, plot_options, legend_string = run
        print 'run', idx,
        s.set(**run_options)
        s.mean_curve.plot(plt,
                          plot_options,
                          linewidth=2,
                          label=legend_string % s.exec_time)
        print 'execution time', s.exec_time


#    def f():
#        print 'exec_time', s.exec_time
#
#    global f
#
#    import cProfile
#
#    cProfile.run('f()', 'spirrid.tprof')
#    import pstats
#    p = pstats.Stats('spirrid.tprof')
#    p.strip_dirs()
#    print 'cumulative'
#    p.sort_stats('cumulative').print_stats(50)
#    print 'time'
#    p.sort_stats('time').print_stats(50)

    plt.xlabel('strain [-]')
    plt.ylabel('stress')
    plt.legend(loc='lower right')

    plt.title(s.rf.title)
    plt.show()
    for idx in range(n_params):
        offset = idx * width
        n_rv = idx + 1

        n_int = int(pow(memsize, 1 / float(n_rv)))
        print 'n_int', n_int

        s = SPIRRID(rf=rf,
                    min_eps=0.00,
                    max_eps=1.0,
                    n_eps=20,
                    compiler_verbose=0)

        for rv in range(n_rv):
            param_key = rf.param_keys[rv]
            s.add_rv(param_key, n_int=n_int)
        time_plot.append(run_study(s, run_dict, offset, width)[1])

    plt.figure(0)
    plt.plot(range(1,
                   len(rf.param_keys) + 1),
             time_plot,
             '-o',
             color='black',
             linewidth=1)

    plt.figure(1)
    plt.plot([1.0, 2.0 + width * n_params], [1.0, 1.0], '-o', color='black')

    plt.figure(0)
    plt.ylabel('$\mathrm{normalized \, execution \, time \, [-]}$', size=20)