Esempio n. 1
0
def run():
    # Quantities for the response function
    # and randomization

    # 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.,
                'f':0.0}
        
    outfile = open( 'pullout_comb_stat.dat', 'w' )
    
    comb = 0
    while_cond = 1
    while while_cond == 1: #for comb in range( 1, n_com + 1 ):
        comb += 1
        for i in range( 0, 2 ):
            # construct a default response function for a single filament
            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.05, n_eps=80 )
        
            # construct the random variables
        
            n_int = 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':rf.L / 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':'cos_distr', 'loc':0., 'scale':1., 'n_int':n_int},
                       'f':{'variable':'f', 'distribution':'uniform', 'loc':0., 'scale':.03, 'n_int':n_int },
                       }

            n_var = len( dict_rv )
            n_com = 0
            for k in range( 6, 7 ):
                n_com += choose( n_var, k )
                
            # end of the while loop
            if comb == n_com:
                while_cond = 0
                
            list_rv_comb = list( powerset( dict_rv, par=6 ) )

            for rv in list_rv_comb[comb]:
                s.add_rv( **dict_rv[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'  : 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'
                         ),
                        ]
            
            print 'Combination', list_rv_comb[comb], ' -- ', i
            outfile.write( "Combination %s -- %i\n" % ( list_rv_comb[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 )
                plt.figure( comb )
                s.mean_curve.plot( plt, plot_options, linewidth=2, label=legend_string % s.exec_time )
                print 'execution time', s.exec_time, s.mu_q_peak
                outfile.write( "%s \t %s\n" % ( idx, s.exec_time ) )
            
            outfile.write( "=================\n" )
        
            plt.xlabel( 'strain [-]' )
            plt.ylabel( 'stress' )
            plt.legend( loc='lower right' )
        
            plt.title( s.rf.title )
            del s
    plt.show()
Esempio n. 2
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_mod=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=80 )

    # construct the random variables

    n_int = 15

    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='cos_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_qg'         : False,
                  'compiled_qg_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_qg'         : False,
                  'compiled_qg_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_qg'         : True,
                  'compiled_qg_loop'  : True,
                  'compiled_eps_loop' : True },
                  'go-',
                  '$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot G[\\theta] ) $ - %4.2f sec',
                  ),
                ( 
                 {'cached_qg'         : True,
                  'compiled_qg_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, s.mu_q_peak

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

    plt.title( s.rf.title )
    plt.show()
Esempio n. 3
0
def run():
    # Quantities for the response function
    # and randomization
    # 
    dict_var = {'x' : 10,
                'y' : 20,
                'z' : 30,
                'a' : 40}
    
    n_var = len( dict_var )
    n_com = 0
    for k in range( 0, n_var ):
        n_com += choose( n_var, k )
        
    outfile = open( 'simple_comb_stat.dat', 'w' )
    
    for comb in range( 1, n_com + 1 ):
        for i in range( 0, 2 ):
            # construct a default response function for a single filament
            rf = Filament()
            rf.set( **dict_var ) # (x=10, y=20, ...)
        
            # construct the integrator and provide it with the response function.
        
            s = SPIRRID( rf=rf,
                         min_eps=0.00, max_eps=0.05, n_eps=1 )
        
            # construct the random variables
        
            n_int = 35
            
            dict_rv = {
                       'x':{'variable':'x', 'distribution':'norm', 'loc':10., 'scale':2., 'n_int':n_int},
                       'y':{'variable':'y', 'distribution':'norm', 'loc':10., 'scale':2., 'n_int':n_int},
                       'z':{'variable':'z', 'distribution':'norm', 'loc':10., 'scale':2., 'n_int':n_int},
                       'a':{'variable':'a', 'distribution':'norm', 'loc':10., 'scale':2., 'n_int':n_int},
                       }
            list_rv_comb = list( powerset( dict_rv ) )
            for rv in list_rv_comb[comb]:
                s.add_rv( **dict_rv[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'  : 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 = []
        
            print 'Combination', list_rv_comb[comb], ' -- ', i
            outfile.write( "Combination %s -- %i\n" % ( list_rv_comb[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 )
                s.mean_curve.plot( plt, plot_options )
                print 'execution time', s.exec_time, s.mu_q_peak
                outfile.write( "%s \t %s\n" % ( idx, s.exec_time ) )
                legend.append( legend_string % s.exec_time )

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

            plt.xlabel( 'strain [-]' )
            plt.ylabel( 'stress' )
            plt.legend( legend )
        
            plt.title( s.rf.title )
            del s 
    plt.show()
    outfile.close()
Esempio n. 4
0
                    erf(0.5 * math.sqrt(2) * (e - m_xi) / std_xi)) * m_la

    #===========================================================================
    # Lab
    #===========================================================================
    slab = SPIRRIDLAB(s = s, save_output = True, show_output = True,
                      exact_arr = mu_q_ex(e_arr, m_xi, std_xi, m_la))

    #===========================================================================
    # Compare efficiency of sampling types 
    #===========================================================================
    powers = np.linspace(1, math.log(1000, 10), 80)
    n_int_range = np.array(np.power(10, powers), dtype = int)

#   slab.sampling_efficiency(n_int_range = n_int_range)

    #===========================================================================
    # Compare the structure of sampling
    #===========================================================================

#    slab.sampling_structure(ylim = 18.0, xlim = 1.2,)

    #===========================================================================
    # Compare the code efficiency
    #==============================8=============================================

    s.set(e_arr = np.linspace(0, 2.0, 40), n_int = 400)
    #slab.codegen_language_efficiency(extra_compiler_args = False)
    slab.codegen_language_efficiency(extra_compiler_args = True)

Esempio n. 5
0
def run():
    # Quantities for the response function
    # and randomization
    #
    dict_var = {"x": 10, "y": 20, "z": 30, "a": 40}

    n_var = len(dict_var)
    n_com = 0
    for k in range(0, n_var):
        n_com += choose(n_var, k)

    outfile = open("simple_comb_loop_stat.dat", "w")

    for comb in range(1, n_com + 1):
        for i in range(0, 2):
            # construct a default response function for a single filament
            rf = Filament()
            rf.set(**dict_var)  # (x=10, y=20, ...)

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

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

            # construct the random variables

            n_int = 35

            dict_rv = {
                "x": {"variable": "x", "distribution": "norm", "loc": 10.0, "scale": 2.0, "n_int": n_int},
                "y": {"variable": "y", "distribution": "norm", "loc": 10.0, "scale": 2.0, "n_int": n_int},
                "z": {"variable": "z", "distribution": "norm", "loc": 10.0, "scale": 2.0, "n_int": n_int},
                "a": {"variable": "a", "distribution": "norm", "loc": 10.0, "scale": 2.0, "n_int": n_int},
            }
            list_rv_comb = list(powerset(dict_rv))
            for rv in list_rv_comb[comb]:
                s.add_rv(**dict_rv[rv])

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

            run_list = [
                (
                    {"cached_qg": False, "compiled_qg_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_qg": False, "compiled_qg_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_qg": True, "compiled_qg_loop": True, "compiled_eps_loop": True},
                    "go-",
                    "$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot G[\\theta] ) $ - %4.2f sec",
                ),
                (
                    {"cached_qg": True, "compiled_qg_loop": False, "compiled_eps_loop": False},
                    "y--",
                    "$\mathrm{P}_{e} ( \mathrm{N}_{\\theta} ( q(e,\\theta) \cdot G[\\theta] ) ) $ - %4.2f sec",
                ),
            ]

            legend = []

            print "Combination", list_rv_comb[comb], " -- ", i
            outfile.write("Combination %s -- %i\n" % (list_rv_comb[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)
                s.mean_curve.plot(plt, plot_options)
                print "execution time", s.exec_time, s.mu_q_peak
                outfile.write("%s \t %s\n" % (idx, s.exec_time))
                legend.append(legend_string % s.exec_time)

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

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

            plt.title(s.rf.title)
            del s
    plt.show()
    outfile.close()
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
    
    dict_var = {'E_mod':70.e9,
                'xi':0.02,
                'A':A,
                'theta':0,
                'lambd':0}
        
    outfile = open( 'filament_comb_stat.dat', 'w' )
    
    comb = 0
    while_cond = 1
    while while_cond == 1: #for comb in range( 1, n_com + 1 ):
        comb += 1
        for i in range( 0, 2 ):
            # construct a default response function for a single filament
            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.05, n_eps=80 )
            
            # construct the random variables
        
            n_int = 32
        
            dict_rv = {
                       'xi':{'variable':'xi', 'distribution':'weibull_min', 'scale':0.02, 'shape':10., 'n_int':n_int},
                       'E_mod':{'variable':'E_mod', 'distribution':'uniform', 'loc':70e+9, 'scale':15e+9, 'n_int':n_int},
                       'theta':{'variable':'theta', 'distribution':'uniform', 'loc':0.0, 'scale':0.01, 'n_int':n_int},
                       'lambd':{'variable':'lambd', 'distribution':'uniform', 'loc':0.0, 'scale':.2, 'n_int':n_int},
                       'A':{'variable':'A', 'distribution':'uniform', 'loc':A * 0.3, 'scale':0.7 * A, 'n_int':n_int},
                       }
            
            n_var = len( dict_rv )
            n_com = 0
            for k in range( 0, n_var ):
                n_com += choose( n_var, k )
            print 'The only last combination'
            comb = n_com
            # end of the while loop
            if comb == n_com:
                while_cond = 0
                        
            list_rv_comb = list( powerset( dict_rv ) )
            for rv in list_rv_comb[comb]:
                s.add_rv( **dict_rv[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',
                          ),
                        ]
        
            legend = []
        
            print 'Combination', list_rv_comb[comb], ' -- ', i
            outfile.write( "Combination %s -- %i\n" % ( list_rv_comb[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 )
                plt.figure( comb )
                s.mean_curve.plot( plt, plot_options )
                print 'execution time', s.exec_time
                outfile.write( "%s \t %s\n" % ( idx, s.exec_time ) )
                legend.append( legend_string % s.exec_time )
                
            outfile.write( "=================\n" )
        
            plt.xlabel( 'strain [-]' )
            plt.ylabel( 'stress' )
            plt.legend( legend )
        
            plt.title( s.rf.title )
            
            del s
    plt.show()
Esempio n. 7
0
def run():
    # Quantities for the response function
    # and randomization
    # 
    xx = 10 # Pa
    yy = 20 # Pa
    zz = 30
    aa = 40


    # construct a default response function for a single filament

    rf = Filament( x=xx, y=yy, z=zz, a=aa )

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

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

    # construct the random variables

    n_int = 80

    s.add_rv( 'x', distribution='norm', scale=10., shape=2., n_int=n_int )
    s.add_rv( 'y', distribution='norm', loc=10., scale=2., n_int=n_int )
    s.add_rv( 'z', distribution='norm', loc=10., scale=2., n_int=n_int )
    s.add_rv( 'a', distribution='norm', loc=10., scale=2., n_int=n_int )

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

    run_list = [
                ( 
                 {'cached_qg'         : False,
                  'compiled_qg_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_qg'         : False,
                  'compiled_qg_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_qg'         : True,
                  'compiled_qg_loop'  : True,
                  'compiled_eps_loop' : True },
                  'go-',
                  '$\mathrm{C}_{e,\\theta} ( q(e,\\theta) \cdot G[\\theta] ) $ - %4.2f sec',
                  ),
                ( 
                 {'cached_qg'         : True,
                  'compiled_qg_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 )
        s.mean_curve.plot( plt, plot_options )
        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. 8
0
                      exact_arr = mu_q_ex(e_arr))

    #===========================================================================
    # Compare efficiency of sampling types 
    #===========================================================================
    powers = np.linspace(1, math.log(20, 10), 15)
    n_int_range = np.array(np.power(10, powers), dtype = int)

    #slab.sampling_efficiency(n_int_range = n_int_range)

    #===========================================================================
    # Compare the structure of sampling
    #===========================================================================

    #slab.sampling_structure( ylim = 1.1, xlim = 0.04 )

    #===========================================================================
    # Compare the code efficiency
    #===========================================================================

    s.set(e_arr = np.linspace(0, 0.04, 20), n_int = 40)
    s.sampling_type = 'PGrid'
    slab.codegen_efficiency()

    #===========================================================================
    # Compare the efficiency wrt. order and number of RV (combinations)
    #===========================================================================

    #slab.combination_efficiency(tvars_det = dict(lambd = la_mean, xi = xi_mean, E_mod = E_mean, theta = th_mean, A = A_mean),
    #                            tvars_rand = dict(lambd = g_la, xi = g_xi, E_mod = g_E, theta = g_th, A = g_A))
Esempio n. 9
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=80 )

    # construct the random variables

    n_int = 70

    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 )
        s.mean_curve.plot( plt, plot_options )
        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()