wind_section module
Classes used to define wind cross-sections (e.g. to calculate drag, lift loading)
@author: RIHY
# -*- coding: utf-8 -*- """ Classes used to define wind cross-sections (e.g. to calculate drag, lift loading) @author: RIHY """ import inspect import numpy import scipy from scipy.interpolate import CubicSpline import matplotlib.pyplot as plt #%% # ------------------- MODULE-LEVEL VARIABLES ---------------------------------- v_air = 15e-6 """ Kinematic viscocity of air [m2/s] """ #%% # ------------------- CLASSES ------------------------------------------------ class WindSection(): """ Generic cross-section, where (drag, lift, moment) resistances are defined explicitly _Note: this is intended to be an abstract class. Objects cannot be instantiated. Use derived classes instead._ """ def __init__(self,R_D, R_L=0.0, R_M=0.0): """ Defines general cross-section via functions that define variation in wind resistances with angle of attack **Important note 1**: Resistances are defined in a _wind-aligned_ axis system, which rotates with angle of attack. This is shown in the following figure: ![axes](../dynsys/img/wind_loading.png) In this context: $$ R_{D} = h C_{D} $$ $$ R_{L} = b C_{L} $$ $$ R_{M} = b^{2} C_{M} $$ **Important note 2**: Angle of attack to be specified in _radians_. This is important to ensure accurate calculation of deriviatives. *** Required: * `R_D`, wind resistance in the direction of the wind. Can be _float_ or function in the form `R_D(alpha)`, where `alpha` is the angle of attack Optional: * `R_L`, function to define wind resistance in the lift direction, perpendicular to the wind. Function in the form `R_L(alpha)` required * `R_M`, function to define wind resistance in terms of moment loading. Function in the form `R_M(alpha)` required """ # Prevent direct instatiation of this class if type(self) == WindSection: raise Exception("<WindSection> must be subclassed.") # Evaluate drag at zero angle of attack if not isinstance(R_D,float) and not callable(R_D): raise ValueError("`R_D` must be either a float or a function") self.R_D = R_D """ Wind resistance for calculation of drag load, i.e. load in the direction of the mean wind vector, projected into the section plane """ if not isinstance(R_L,float) and not callable(R_L): raise ValueError("`R_L` must be either a float or a callable") self.R_L = R_L """ Wind resistance for calculation of lift load, i.e. load perpendicular to the mean wind vector, but in the section plane """ if not isinstance(R_M,float) and not callable(R_M): raise ValueError("`R_M` must be either a float or a callable") self.R_M = R_M """ Wind resistance for calculation of moment load. Note: when expressed as a vector moment is about the (-x) section axis. Refer image included in `__init__()` doctring """ def calc_R_D(self,alpha,**kwargs): """ Calculates wind resistance for drag loading, given angle of attack `alpha` and mean wind speed `U` """ return _func_or_float(self.R_D,alpha) def calc_R_D_derivative(self,alpha,order=1,**kwargs): """ Evaluate derivative of drag resistance with respect to angle of attack at the specified angle `alpha` """ return _derivative_func(self.R_D,alpha,order=order) def calc_R_L(self,alpha,**kwargs): """ Calculates wind resistance for lift loading, given angle of attack `alpha` and mean wind speed `U` """ return _func_or_float(self.R_L,alpha) def calc_R_L_derivative(self,alpha,order=1,**kwargs): """ Evaluate derivative of lift resistance with respect to angle of attack at the specified angle `alpha` """ return _derivative_func(self.R_L,alpha,order=order) def calc_R_M(self,alpha,**kwargs): """ Calculates wind resistance for moment loading, given angle of attack `alpha` and mean wind speed `U` """ return _func_or_float(self.R_M,alpha) def calc_R_M_derivative(self,alpha,order=1,**kwargs): """ Evaluate derivative of lift resistance with respect to angle of attack at the specified angle `alpha` """ return _derivative_func(self.R_M,alpha,order=order) def calc_denHertog(self,alpha,find_roots:bool=True,**kwargs): r""" Evaluates the 'den Hertog stability criterion' at angles of attack `alpha`, i.e. the following function: $$ H(\alpha) = dR_L/d\alpha|_{\alpha} + R_D(\alpha) $$ *** **Required:** * `alpha`, array of angle of attack values at which to evaluate H *** **Optional** * `find_roots`: if True, method will seek all roots (where H=0) and return list to define regions of instablity (where H<0 between roots) *** **Returns:** If `find_roots` is False, returns array of H(alpha) values Otherwise returns tuple consisting of the following: * Array of H(alpha) values * List of roots, i.e. alpha values where H(alpha)=0 * List of 2-item lists, defining bounding alpha values for regions where H(alpha) < 0 """ def H_func(alpha): RL_derivative = self.calc_R_L_derivative(alpha,order=1,**kwargs) RD = self.calc_R_D(alpha,**kwargs) return RL_derivative + RD H = H_func(alpha) if find_roots: # Detect zero-crossings first brackets = [] for i in range(len(H)-1): H1 = H[i+1] H0 = H[i] if numpy.sign(H1)!=numpy.sign(H0): # Zero-crossing detected brackets.append([alpha[i],alpha[i+1]]) # Use bisection method to obtain precise zero-crossings roots = [] for (a,b) in brackets: roots.append(scipy.optimize.bisect(H_func,a,b)) # Identify instability regions (with H<0) regions = [] if len(roots)>0: # Wrap list around roots = [roots[-1]-2*numpy.pi] + roots + [roots[0]+2*numpy.pi] # Identify regions where H<0 for i in range(len(roots)-1): H_mid = H_func(0.5*(roots[i]+roots[i+1])) if H_mid < 0: regions.append([roots[i],roots[i+1]]) return H, roots, regions else: return H def plot_denHertog(self,ax=None,**kwargs): """ Plots the den Hertog parameter H for all angles of attack Where unstable regions (H<0) exist, these are annotated via shading """ alpha = numpy.linspace(0,2*numpy.pi,61) H, roots, regions = self.calc_denHertog(alpha,find_roots=True,**kwargs) alpha = numpy.rad2deg(alpha) roots = numpy.rad2deg(roots) regions = numpy.rad2deg(regions) if ax is None: fig,ax = plt.subplots() fig.set_size_inches((8,4)) else: fig = ax.get_figure() ax.plot(alpha,H) ax.set_xlim([0,360]) ax.axhline(0.0,color='k',alpha=0.5) [ax.axvline(r,color='r') for r in roots] [ax.axvspan(a,b,color='r', alpha=0.1) for (a,b) in regions] ax.set_title("Den Hertog parameter $H$\n" + r"$ H = dR_L/d\alpha + R_D $") return fig def plot_resistances(self,U=20.0, alpha=None): """ Plots variation in wind resistances with angle of attack *** Optional: * `U`, mean wind speed used for resistances calculation (note: for some sections, e.g. circles, wind resistance is Re-dependent) * `alpha`, specific angle of attack values to evaluate resistance at. By default `alpha` will be plotted in range [0, 2*pi] """ if alpha is None: alpha = numpy.linspace(0,2*numpy.pi,61) alpha_deg = numpy.rad2deg(alpha) R_D = [self.calc_R_D(a,U=U) for a in alpha] R_D_deriv = [self.calc_R_D_derivative(a,U=U) for a in alpha] R_L = [self.calc_R_L(a,U=U) for a in alpha] R_L_deriv = [self.calc_R_L_derivative(a,U=U) for a in alpha] R_M = [self.calc_R_M(a,U=U) for a in alpha] R_M_deriv = [self.calc_R_M_derivative(a,U=U) for a in alpha] fig, axarr = plt.subplots(3,2,sharex=True) fig.set_size_inches((12,8)) fig.subplots_adjust(wspace=0.3) ax = axarr[0,0] ax.plot(alpha_deg,R_D) ax.set_ylabel("$R_D$") ax = axarr[0,1] ax.plot(alpha_deg,R_D_deriv) ax.set_ylabel(r"$dR_D/d\alpha}$") ax = axarr[1,0] ax.plot(alpha_deg,R_L) ax.set_ylabel("$R_L$") ax = axarr[1,1] ax.plot(alpha_deg,R_L_deriv) ax.set_ylabel(r"$dR_L/d\alpha$") ax = axarr[2,0] ax.plot(alpha_deg,R_M) ax.set_ylabel("$R_M$") ax = axarr[2,1] ax.plot(alpha_deg,R_M_deriv) ax.set_ylabel(r"$dR_M/d\alpha$") ax = axarr[2,0] ax.set_xlim([alpha_deg[0],alpha_deg[-1]]) ax.set_xlabel(r"Angle of attack $\alpha$ (degrees)") ax.set_ylabel("$R_M$") if ax.get_xlim()==(0,360): ax.set_xticks(numpy.arange(0,361,60)) fig.suptitle("Variation of wind-aligned wind resistances " + "with angle of attack") #%% class WindSection_Circular(WindSection): """ Derived class to implement WindSection for circular section """ def __init__(self,d,C_d=None,k=None): """ Defines wind resistances for a circular section *** Required: * `d`, outer diameter of section [m] *** Optional: * `C_d`, drag coefficient to be used in conjunction with `d`. If None appropriate drag coefficient will be determined based on mean wind speed and surface roughness `k` (see below) * `k`, surface roughness [m]. Only required if `C_d`=None """ self.d = d self.C_d = C_d if C_d is None and k is None: raise ValueError("Given `C_d` is None, `k` must be provided") self.k = k # ------------------ PROPERTIES ------------------------------------------- # ---------- @property def d(self): """ Outer diameter of section [m] """ return self._d @d.setter def d(self,val): self._d = val # ---------- @property def C_d(self): """ Drag coefficient """ return self._C_d @C_d.setter def C_d(self,val): if (not isinstance(val,float)) and (val is not None): raise ValueError("`C_d` must be either float or None\n" + "C_d : {0}".format(val)) self._C_d = val # --------- @property def k(self): """ Surface roughness [m] """ return self._k @k.setter def k(self,val): if not isinstance(val,float): raise ValueError("`k` must be a float") self._k = val # --------- RE-DIRECT GETTER METHODS -------------------------------------- @property def R_D(self): return self.calc_R_D @property def R_L(self): return self.calc_R_L @property def R_M(self): return self.calc_R_M # ----------------- CLASS METHODS ----------------------------------------- def calc_R_D(self,alpha,U=20.0,**kwargs): """ Calculates wind resistance for drag loading, given angle of attack `alpha` and mean wind speed `U` If `C_d` has not been defined for section explicitly, appropriate drag coefficient will be calculated given `U` and surface roughness `k` for section """ C_d = self.C_d d = self.d if C_d is None: # Calculate C_d given Reynold number and surface roughness k C_d = self.calc_C_d(U) return d*C_d def calc_R_D_derivative(self,alpha,**kwargs): return numpy.zeros_like(alpha) def calc_R_L(self,alpha,**kwargs): """ Calculates wind resistance for lift loading _Always equals 0.0 for circles, due to symmetry_ """ return numpy.zeros_like(alpha) def calc_R_L_derivative(self,alpha,**kwargs): return numpy.zeros_like(alpha) def calc_R_M(self,alpha,**kwargs): """ Calculates wind resistance for moment loading _Always equals 0.0 for circles, due to symmetry_ """ return numpy.zeros_like(alpha) def calc_R_M_derivative(self,alpha,**kwargs): return numpy.zeros_like(alpha) def calc_C_d(self,U): """ Calculates drag coefficient in accordance with Fig 7.28 BS EN 1991-1-4:2005 """ if not isinstance(U,float): raise ValueError("`U` must be a float") k = self.k b = self.d k_b = max(k/b, 1e-5) Re = calc_Re(U,b) # Curve 1 c_f0_1 = 0.11 / (Re/1e6)**1.4 c_f0_1 = min(max(c_f0_1, 0.4),1.2) # Curve 2 c_f0_2 = 1.2 + (0.18*numpy.log10(10*k_b)) / (1+0.4*numpy.log10(Re/1e6)) # Return maximum of curve 1 and 2 return max(c_f0_1,c_f0_2) #%% class WindSection_Custom(WindSection): """ Class to define custom wind section by explicitly defining variation of drag, lift and moment resistance with angle of attack """ def __init__(self,alpha:list,R_D:list,R_L:list=None,R_M:list=None): """ Initialise custom wind section *** Required: * `alpha`, list-like, gives specific values of angle of attack values [radians] * `R_D`, list-like, gives specific values of drag wind resistance [m] at angles of attack corresponding to `alpha` *** Optional: * `R_L`, list-like, gives specific values of lift wind resistance [m] at angles of attack corresponding to `alpha`. If None (default) then zero values assumed for all `alpha` * `R_M`, list-like, gives specific values of moment wind resistance [m2] at angles of attack corresponding to `alpha`. If None (default) then zero values assumed for all `alpha` """ # Check array dimensions N = len(alpha) if len(R_D)!= N: raise ValueError("`len(R_D)` must agree with `len(alpha)`") if R_L is not None and len(R_L)!= N: raise ValueError("`len(R_L)` must agree with `len(alpha)`") if R_M is not None and len(R_M)!= N: raise ValueError("`len(R_M)` must agree with `len(alpha)`") # Check limits if alpha[-1] > 2*numpy.pi or alpha[0]<0: raise ValueError("`alpha` to be in the range [0,2*pi]") # Define cubic splines through passed-in list data settings = {'bc_type':'periodic'} # n.b. must be periodic in alpha interpolation_class = CubicSpline # class to use for interpolation # note use of cubic spline is advantageous as allows derivatives calc R_D_func = interpolation_class(alpha,R_D,**settings) if R_L is not None: R_L_func = interpolation_class(alpha,R_L,**settings) else: R_L_func = lambda x : 0.0 if R_M is not None: R_M_func = interpolation_class(alpha,R_M,**settings) else: R_M_func = lambda x : 0.0 # WindSection init method super().__init__(R_D=R_D_func, R_L=R_L_func, R_M=R_M_func) #%% ------------------ FUNCTIONS ------------------- def calc_Re(U,d,v=v_air): """ Calculates Reynold number given wind speed `U` and characterstic diameter `d`. `v` can be used to specify kinematic viscocity. Default value relates to air """ return U*d/v def _func_or_float(f,x): """ Evaluates `f` at x. If `f` is float, value is returned """ if isinstance(f, float): return f else: return f(x) def _derivative_func(val,alpha,order=1): """ Private function, used to evaluate derivatives (avoids code repetition) """ if isinstance(val, float): return 0.0 # constant R_L thus derivative = 0.0 for all alpha elif isinstance(val,CubicSpline): if order > 2: raise ValueError("Cubic spline cannot be used to evaluate 3rd " + "derivatives or greater") return val(alpha,order) else: raise ValueError("Unexpected type. Cannot evaluate derivative") def test_calc_C_d(): """ Test routine to demonstrate accuracy of `calc_C_d()` method for circles, by re-creating Fig 7.28, BS EN 1991-1-4 """ b=0.1 #arbitrary # List k/b, Re values per figure k_b_vals = numpy.array([1e-2,1e-3,1e-4,1e-5,1e-6]) Re_vals = numpy.logspace(5,7,num=100) # Convert to inputs required k_vals = k_b_vals * b U_vals = Re_vals * v_air / b # Evaluate c_f0 for each k,U pair outer_list = [] for k in k_vals: inner_list = [] for U in U_vals: obj = WindSection_Circular(d=b,k=k) c_f0 = obj.calc_C_d(U) inner_list.append(c_f0) outer_list.append(inner_list) c_f0 = numpy.array(outer_list) # Re-create Fig. 7.28 to test calc_C_d() method fig, ax = plt.subplots() h = ax.plot(Re_vals,c_f0.T) h[-1].set_linestyle('--') ax.set_xscale('log') ax.legend(h,["%.0e" % x for x in k_b_vals],title="$k/b$") ax.set_ylim([0,1.4]) # per Fig 7.28 ax.set_xlim([Re_vals[0],Re_vals[-1]]) # per Fig 7.28 ax.set_xlabel("$Re$") ax.set_ylabel("$c_{f0}$") ax.set_title("Drag coefficients for circles\n" + "according to Fig 7.28, BS EN 1991-1-4:2005") # ---------------- TEST ROUTINES ---------------------------------------------- if __name__ == "__main__": plt.close('all') test_routine = 3 if test_routine == 1: print("Test routine to check drag factor calculation for circles") test_calc_C_d() elif test_routine == 2: d = 1.5 circle = WindSection_Circular(d=d,k=1e-4) circle.plot_resistances(U=10.0) circle.plot_denHertog() elif test_routine == 3: # Define angles of attack to define resistances at alpha = numpy.linspace(0,2*numpy.pi,100) # Define some arbitrary resistances R_D = numpy.sin(alpha) R_L = numpy.cos(alpha)**2 R_M = 0.1*alpha*(2*numpy.pi - alpha)*(numpy.pi - alpha) # Define wind section and plot resistances and their derivatives section = WindSection_Custom(alpha,R_D,R_L,R_M) section.plot_resistances()#alpha=numpy.linspace(-1.5,7.5,100)) section.plot_denHertog() else: raise ValueError("Invalid `testroutine` specified") pass
Module variables
var v_air
Kinematic viscocity of air [m2/s]
Functions
def calc_Re(
U, d, v=1.5e-05)
Calculates Reynold number given wind speed U
and characterstic
diameter d
.
v
can be used to specify kinematic viscocity. Default value relates
to air
def calc_Re(U,d,v=v_air): """ Calculates Reynold number given wind speed `U` and characterstic diameter `d`. `v` can be used to specify kinematic viscocity. Default value relates to air """ return U*d/v
def test_calc_C_d(
)
Test routine to demonstrate accuracy of calc_C_d()
method for circles,
by re-creating Fig 7.28, BS EN 1991-1-4
def test_calc_C_d(): """ Test routine to demonstrate accuracy of `calc_C_d()` method for circles, by re-creating Fig 7.28, BS EN 1991-1-4 """ b=0.1 #arbitrary # List k/b, Re values per figure k_b_vals = numpy.array([1e-2,1e-3,1e-4,1e-5,1e-6]) Re_vals = numpy.logspace(5,7,num=100) # Convert to inputs required k_vals = k_b_vals * b U_vals = Re_vals * v_air / b # Evaluate c_f0 for each k,U pair outer_list = [] for k in k_vals: inner_list = [] for U in U_vals: obj = WindSection_Circular(d=b,k=k) c_f0 = obj.calc_C_d(U) inner_list.append(c_f0) outer_list.append(inner_list) c_f0 = numpy.array(outer_list) # Re-create Fig. 7.28 to test calc_C_d() method fig, ax = plt.subplots() h = ax.plot(Re_vals,c_f0.T) h[-1].set_linestyle('--') ax.set_xscale('log') ax.legend(h,["%.0e" % x for x in k_b_vals],title="$k/b$") ax.set_ylim([0,1.4]) # per Fig 7.28 ax.set_xlim([Re_vals[0],Re_vals[-1]]) # per Fig 7.28 ax.set_xlabel("$Re$") ax.set_ylabel("$c_{f0}$") ax.set_title("Drag coefficients for circles\n" + "according to Fig 7.28, BS EN 1991-1-4:2005")
Classes
class WindSection
Generic cross-section, where (drag, lift, moment) resistances are defined explicitly
Note: this is intended to be an abstract class. Objects cannot be instantiated. Use derived classes instead.
class WindSection(): """ Generic cross-section, where (drag, lift, moment) resistances are defined explicitly _Note: this is intended to be an abstract class. Objects cannot be instantiated. Use derived classes instead._ """ def __init__(self,R_D, R_L=0.0, R_M=0.0): """ Defines general cross-section via functions that define variation in wind resistances with angle of attack **Important note 1**: Resistances are defined in a _wind-aligned_ axis system, which rotates with angle of attack. This is shown in the following figure: ![axes](../dynsys/img/wind_loading.png) In this context: $$ R_{D} = h C_{D} $$ $$ R_{L} = b C_{L} $$ $$ R_{M} = b^{2} C_{M} $$ **Important note 2**: Angle of attack to be specified in _radians_. This is important to ensure accurate calculation of deriviatives. *** Required: * `R_D`, wind resistance in the direction of the wind. Can be _float_ or function in the form `R_D(alpha)`, where `alpha` is the angle of attack Optional: * `R_L`, function to define wind resistance in the lift direction, perpendicular to the wind. Function in the form `R_L(alpha)` required * `R_M`, function to define wind resistance in terms of moment loading. Function in the form `R_M(alpha)` required """ # Prevent direct instatiation of this class if type(self) == WindSection: raise Exception("<WindSection> must be subclassed.") # Evaluate drag at zero angle of attack if not isinstance(R_D,float) and not callable(R_D): raise ValueError("`R_D` must be either a float or a function") self.R_D = R_D """ Wind resistance for calculation of drag load, i.e. load in the direction of the mean wind vector, projected into the section plane """ if not isinstance(R_L,float) and not callable(R_L): raise ValueError("`R_L` must be either a float or a callable") self.R_L = R_L """ Wind resistance for calculation of lift load, i.e. load perpendicular to the mean wind vector, but in the section plane """ if not isinstance(R_M,float) and not callable(R_M): raise ValueError("`R_M` must be either a float or a callable") self.R_M = R_M """ Wind resistance for calculation of moment load. Note: when expressed as a vector moment is about the (-x) section axis. Refer image included in `__init__()` doctring """ def calc_R_D(self,alpha,**kwargs): """ Calculates wind resistance for drag loading, given angle of attack `alpha` and mean wind speed `U` """ return _func_or_float(self.R_D,alpha) def calc_R_D_derivative(self,alpha,order=1,**kwargs): """ Evaluate derivative of drag resistance with respect to angle of attack at the specified angle `alpha` """ return _derivative_func(self.R_D,alpha,order=order) def calc_R_L(self,alpha,**kwargs): """ Calculates wind resistance for lift loading, given angle of attack `alpha` and mean wind speed `U` """ return _func_or_float(self.R_L,alpha) def calc_R_L_derivative(self,alpha,order=1,**kwargs): """ Evaluate derivative of lift resistance with respect to angle of attack at the specified angle `alpha` """ return _derivative_func(self.R_L,alpha,order=order) def calc_R_M(self,alpha,**kwargs): """ Calculates wind resistance for moment loading, given angle of attack `alpha` and mean wind speed `U` """ return _func_or_float(self.R_M,alpha) def calc_R_M_derivative(self,alpha,order=1,**kwargs): """ Evaluate derivative of lift resistance with respect to angle of attack at the specified angle `alpha` """ return _derivative_func(self.R_M,alpha,order=order) def calc_denHertog(self,alpha,find_roots:bool=True,**kwargs): r""" Evaluates the 'den Hertog stability criterion' at angles of attack `alpha`, i.e. the following function: $$ H(\alpha) = dR_L/d\alpha|_{\alpha} + R_D(\alpha) $$ *** **Required:** * `alpha`, array of angle of attack values at which to evaluate H *** **Optional** * `find_roots`: if True, method will seek all roots (where H=0) and return list to define regions of instablity (where H<0 between roots) *** **Returns:** If `find_roots` is False, returns array of H(alpha) values Otherwise returns tuple consisting of the following: * Array of H(alpha) values * List of roots, i.e. alpha values where H(alpha)=0 * List of 2-item lists, defining bounding alpha values for regions where H(alpha) < 0 """ def H_func(alpha): RL_derivative = self.calc_R_L_derivative(alpha,order=1,**kwargs) RD = self.calc_R_D(alpha,**kwargs) return RL_derivative + RD H = H_func(alpha) if find_roots: # Detect zero-crossings first brackets = [] for i in range(len(H)-1): H1 = H[i+1] H0 = H[i] if numpy.sign(H1)!=numpy.sign(H0): # Zero-crossing detected brackets.append([alpha[i],alpha[i+1]]) # Use bisection method to obtain precise zero-crossings roots = [] for (a,b) in brackets: roots.append(scipy.optimize.bisect(H_func,a,b)) # Identify instability regions (with H<0) regions = [] if len(roots)>0: # Wrap list around roots = [roots[-1]-2*numpy.pi] + roots + [roots[0]+2*numpy.pi] # Identify regions where H<0 for i in range(len(roots)-1): H_mid = H_func(0.5*(roots[i]+roots[i+1])) if H_mid < 0: regions.append([roots[i],roots[i+1]]) return H, roots, regions else: return H def plot_denHertog(self,ax=None,**kwargs): """ Plots the den Hertog parameter H for all angles of attack Where unstable regions (H<0) exist, these are annotated via shading """ alpha = numpy.linspace(0,2*numpy.pi,61) H, roots, regions = self.calc_denHertog(alpha,find_roots=True,**kwargs) alpha = numpy.rad2deg(alpha) roots = numpy.rad2deg(roots) regions = numpy.rad2deg(regions) if ax is None: fig,ax = plt.subplots() fig.set_size_inches((8,4)) else: fig = ax.get_figure() ax.plot(alpha,H) ax.set_xlim([0,360]) ax.axhline(0.0,color='k',alpha=0.5) [ax.axvline(r,color='r') for r in roots] [ax.axvspan(a,b,color='r', alpha=0.1) for (a,b) in regions] ax.set_title("Den Hertog parameter $H$\n" + r"$ H = dR_L/d\alpha + R_D $") return fig def plot_resistances(self,U=20.0, alpha=None): """ Plots variation in wind resistances with angle of attack *** Optional: * `U`, mean wind speed used for resistances calculation (note: for some sections, e.g. circles, wind resistance is Re-dependent) * `alpha`, specific angle of attack values to evaluate resistance at. By default `alpha` will be plotted in range [0, 2*pi] """ if alpha is None: alpha = numpy.linspace(0,2*numpy.pi,61) alpha_deg = numpy.rad2deg(alpha) R_D = [self.calc_R_D(a,U=U) for a in alpha] R_D_deriv = [self.calc_R_D_derivative(a,U=U) for a in alpha] R_L = [self.calc_R_L(a,U=U) for a in alpha] R_L_deriv = [self.calc_R_L_derivative(a,U=U) for a in alpha] R_M = [self.calc_R_M(a,U=U) for a in alpha] R_M_deriv = [self.calc_R_M_derivative(a,U=U) for a in alpha] fig, axarr = plt.subplots(3,2,sharex=True) fig.set_size_inches((12,8)) fig.subplots_adjust(wspace=0.3) ax = axarr[0,0] ax.plot(alpha_deg,R_D) ax.set_ylabel("$R_D$") ax = axarr[0,1] ax.plot(alpha_deg,R_D_deriv) ax.set_ylabel(r"$dR_D/d\alpha}$") ax = axarr[1,0] ax.plot(alpha_deg,R_L) ax.set_ylabel("$R_L$") ax = axarr[1,1] ax.plot(alpha_deg,R_L_deriv) ax.set_ylabel(r"$dR_L/d\alpha$") ax = axarr[2,0] ax.plot(alpha_deg,R_M) ax.set_ylabel("$R_M$") ax = axarr[2,1] ax.plot(alpha_deg,R_M_deriv) ax.set_ylabel(r"$dR_M/d\alpha$") ax = axarr[2,0] ax.set_xlim([alpha_deg[0],alpha_deg[-1]]) ax.set_xlabel(r"Angle of attack $\alpha$ (degrees)") ax.set_ylabel("$R_M$") if ax.get_xlim()==(0,360): ax.set_xticks(numpy.arange(0,361,60)) fig.suptitle("Variation of wind-aligned wind resistances " + "with angle of attack")
Ancestors (in MRO)
- WindSection
- builtins.object
Static methods
def __init__(
self, R_D, R_L=0.0, R_M=0.0)
Defines general cross-section via functions that define variation in wind resistances with angle of attack
Important note 1: Resistances are defined in a wind-aligned axis system, which rotates with angle of attack. This is shown in the following figure:
In this context:
$$ R_{D} = h C_{D} $$ $$ R_{L} = b C_{L} $$ $$ R_{M} = b^{2} C_{M} $$
Important note 2: Angle of attack to be specified in radians. This is important to ensure accurate calculation of deriviatives.
Required:
R_D
, wind resistance in the direction of the wind. Can be float or function in the formR_D(alpha)
, wherealpha
is the angle of attack
Optional:
-
R_L
, function to define wind resistance in the lift direction, perpendicular to the wind. Function in the formR_L(alpha)
required -
R_M
, function to define wind resistance in terms of moment loading. Function in the formR_M(alpha)
required
def __init__(self,R_D, R_L=0.0, R_M=0.0): """ Defines general cross-section via functions that define variation in wind resistances with angle of attack **Important note 1**: Resistances are defined in a _wind-aligned_ axis system, which rotates with angle of attack. This is shown in the following figure: ![axes](../dynsys/img/wind_loading.png) In this context: $$ R_{D} = h C_{D} $$ $$ R_{L} = b C_{L} $$ $$ R_{M} = b^{2} C_{M} $$ **Important note 2**: Angle of attack to be specified in _radians_. This is important to ensure accurate calculation of deriviatives. *** Required: * `R_D`, wind resistance in the direction of the wind. Can be _float_ or function in the form `R_D(alpha)`, where `alpha` is the angle of attack Optional: * `R_L`, function to define wind resistance in the lift direction, perpendicular to the wind. Function in the form `R_L(alpha)` required * `R_M`, function to define wind resistance in terms of moment loading. Function in the form `R_M(alpha)` required """ # Prevent direct instatiation of this class if type(self) == WindSection: raise Exception("<WindSection> must be subclassed.") # Evaluate drag at zero angle of attack if not isinstance(R_D,float) and not callable(R_D): raise ValueError("`R_D` must be either a float or a function") self.R_D = R_D """ Wind resistance for calculation of drag load, i.e. load in the direction of the mean wind vector, projected into the section plane """ if not isinstance(R_L,float) and not callable(R_L): raise ValueError("`R_L` must be either a float or a callable") self.R_L = R_L """ Wind resistance for calculation of lift load, i.e. load perpendicular to the mean wind vector, but in the section plane """ if not isinstance(R_M,float) and not callable(R_M): raise ValueError("`R_M` must be either a float or a callable") self.R_M = R_M """ Wind resistance for calculation of moment load. Note: when expressed as a vector moment is about the (-x) section axis. Refer image included in `__init__()` doctring """
def calc_R_D(
self, alpha, **kwargs)
Calculates wind resistance for drag loading, given angle of attack
alpha
and mean wind speed U
def calc_R_D(self,alpha,**kwargs): """ Calculates wind resistance for drag loading, given angle of attack `alpha` and mean wind speed `U` """ return _func_or_float(self.R_D,alpha)
def calc_R_D_derivative(
self, alpha, order=1, **kwargs)
Evaluate derivative of drag resistance with respect to angle of attack
at the specified angle alpha
def calc_R_D_derivative(self,alpha,order=1,**kwargs): """ Evaluate derivative of drag resistance with respect to angle of attack at the specified angle `alpha` """ return _derivative_func(self.R_D,alpha,order=order)
def calc_R_L(
self, alpha, **kwargs)
Calculates wind resistance for lift loading, given angle of attack
alpha
and mean wind speed U
def calc_R_L(self,alpha,**kwargs): """ Calculates wind resistance for lift loading, given angle of attack `alpha` and mean wind speed `U` """ return _func_or_float(self.R_L,alpha)
def calc_R_L_derivative(
self, alpha, order=1, **kwargs)
Evaluate derivative of lift resistance with respect to angle of attack
at the specified angle alpha
def calc_R_L_derivative(self,alpha,order=1,**kwargs): """ Evaluate derivative of lift resistance with respect to angle of attack at the specified angle `alpha` """ return _derivative_func(self.R_L,alpha,order=order)
def calc_R_M(
self, alpha, **kwargs)
Calculates wind resistance for moment loading, given angle of attack
alpha
and mean wind speed U
def calc_R_M(self,alpha,**kwargs): """ Calculates wind resistance for moment loading, given angle of attack `alpha` and mean wind speed `U` """ return _func_or_float(self.R_M,alpha)
def calc_R_M_derivative(
self, alpha, order=1, **kwargs)
Evaluate derivative of lift resistance with respect to angle of attack
at the specified angle alpha
def calc_R_M_derivative(self,alpha,order=1,**kwargs): """ Evaluate derivative of lift resistance with respect to angle of attack at the specified angle `alpha` """ return _derivative_func(self.R_M,alpha,order=order)
def calc_denHertog(
self, alpha, find_roots=True, **kwargs)
Evaluates the 'den Hertog stability criterion' at angles of attack
alpha
, i.e. the following function:
$$ H(\alpha) = dR_L/d\alpha|_{\alpha} + R_D(\alpha) $$
Required:
alpha
, array of angle of attack values at which to evaluate H
Optional
find_roots
: if True, method will seek all roots (where H=0) and return list to define regions of instablity (where H<0 between roots)
Returns:
If find_roots
is False, returns array of H(alpha) values
Otherwise returns tuple consisting of the following:
-
Array of H(alpha) values
-
List of roots, i.e. alpha values where H(alpha)=0
-
List of 2-item lists, defining bounding alpha values for regions where H(alpha) < 0
def calc_denHertog(self,alpha,find_roots:bool=True,**kwargs): r""" Evaluates the 'den Hertog stability criterion' at angles of attack `alpha`, i.e. the following function: $$ H(\alpha) = dR_L/d\alpha|_{\alpha} + R_D(\alpha) $$ *** **Required:** * `alpha`, array of angle of attack values at which to evaluate H *** **Optional** * `find_roots`: if True, method will seek all roots (where H=0) and return list to define regions of instablity (where H<0 between roots) *** **Returns:** If `find_roots` is False, returns array of H(alpha) values Otherwise returns tuple consisting of the following: * Array of H(alpha) values * List of roots, i.e. alpha values where H(alpha)=0 * List of 2-item lists, defining bounding alpha values for regions where H(alpha) < 0 """ def H_func(alpha): RL_derivative = self.calc_R_L_derivative(alpha,order=1,**kwargs) RD = self.calc_R_D(alpha,**kwargs) return RL_derivative + RD H = H_func(alpha) if find_roots: # Detect zero-crossings first brackets = [] for i in range(len(H)-1): H1 = H[i+1] H0 = H[i] if numpy.sign(H1)!=numpy.sign(H0): # Zero-crossing detected brackets.append([alpha[i],alpha[i+1]]) # Use bisection method to obtain precise zero-crossings roots = [] for (a,b) in brackets: roots.append(scipy.optimize.bisect(H_func,a,b)) # Identify instability regions (with H<0) regions = [] if len(roots)>0: # Wrap list around roots = [roots[-1]-2*numpy.pi] + roots + [roots[0]+2*numpy.pi] # Identify regions where H<0 for i in range(len(roots)-1): H_mid = H_func(0.5*(roots[i]+roots[i+1])) if H_mid < 0: regions.append([roots[i],roots[i+1]]) return H, roots, regions else: return H
def plot_denHertog(
self, ax=None, **kwargs)
Plots the den Hertog parameter H for all angles of attack
Where unstable regions (H<0) exist, these are annotated via shading
def plot_denHertog(self,ax=None,**kwargs): """ Plots the den Hertog parameter H for all angles of attack Where unstable regions (H<0) exist, these are annotated via shading """ alpha = numpy.linspace(0,2*numpy.pi,61) H, roots, regions = self.calc_denHertog(alpha,find_roots=True,**kwargs) alpha = numpy.rad2deg(alpha) roots = numpy.rad2deg(roots) regions = numpy.rad2deg(regions) if ax is None: fig,ax = plt.subplots() fig.set_size_inches((8,4)) else: fig = ax.get_figure() ax.plot(alpha,H) ax.set_xlim([0,360]) ax.axhline(0.0,color='k',alpha=0.5) [ax.axvline(r,color='r') for r in roots] [ax.axvspan(a,b,color='r', alpha=0.1) for (a,b) in regions] ax.set_title("Den Hertog parameter $H$\n" + r"$ H = dR_L/d\alpha + R_D $") return fig
def plot_resistances(
self, U=20.0, alpha=None)
Plots variation in wind resistances with angle of attack
Optional:
-
U
, mean wind speed used for resistances calculation (note: for some sections, e.g. circles, wind resistance is Re-dependent) -
alpha
, specific angle of attack values to evaluate resistance at. By defaultalpha
will be plotted in range [0, 2*pi]
def plot_resistances(self,U=20.0, alpha=None): """ Plots variation in wind resistances with angle of attack *** Optional: * `U`, mean wind speed used for resistances calculation (note: for some sections, e.g. circles, wind resistance is Re-dependent) * `alpha`, specific angle of attack values to evaluate resistance at. By default `alpha` will be plotted in range [0, 2*pi] """ if alpha is None: alpha = numpy.linspace(0,2*numpy.pi,61) alpha_deg = numpy.rad2deg(alpha) R_D = [self.calc_R_D(a,U=U) for a in alpha] R_D_deriv = [self.calc_R_D_derivative(a,U=U) for a in alpha] R_L = [self.calc_R_L(a,U=U) for a in alpha] R_L_deriv = [self.calc_R_L_derivative(a,U=U) for a in alpha] R_M = [self.calc_R_M(a,U=U) for a in alpha] R_M_deriv = [self.calc_R_M_derivative(a,U=U) for a in alpha] fig, axarr = plt.subplots(3,2,sharex=True) fig.set_size_inches((12,8)) fig.subplots_adjust(wspace=0.3) ax = axarr[0,0] ax.plot(alpha_deg,R_D) ax.set_ylabel("$R_D$") ax = axarr[0,1] ax.plot(alpha_deg,R_D_deriv) ax.set_ylabel(r"$dR_D/d\alpha}$") ax = axarr[1,0] ax.plot(alpha_deg,R_L) ax.set_ylabel("$R_L$") ax = axarr[1,1] ax.plot(alpha_deg,R_L_deriv) ax.set_ylabel(r"$dR_L/d\alpha$") ax = axarr[2,0] ax.plot(alpha_deg,R_M) ax.set_ylabel("$R_M$") ax = axarr[2,1] ax.plot(alpha_deg,R_M_deriv) ax.set_ylabel(r"$dR_M/d\alpha$") ax = axarr[2,0] ax.set_xlim([alpha_deg[0],alpha_deg[-1]]) ax.set_xlabel(r"Angle of attack $\alpha$ (degrees)") ax.set_ylabel("$R_M$") if ax.get_xlim()==(0,360): ax.set_xticks(numpy.arange(0,361,60)) fig.suptitle("Variation of wind-aligned wind resistances " + "with angle of attack")
Instance variables
var R_D
Wind resistance for calculation of drag load, i.e. load in the direction of the mean wind vector, projected into the section plane
var R_L
Wind resistance for calculation of lift load, i.e. load perpendicular to the mean wind vector, but in the section plane
var R_M
Wind resistance for calculation of moment load. Note: when expressed
as a vector moment is about the (-x) section axis. Refer image included
in __init__()
doctring
class WindSection_Circular
Derived class to implement WindSection for circular section
class WindSection_Circular(WindSection): """ Derived class to implement WindSection for circular section """ def __init__(self,d,C_d=None,k=None): """ Defines wind resistances for a circular section *** Required: * `d`, outer diameter of section [m] *** Optional: * `C_d`, drag coefficient to be used in conjunction with `d`. If None appropriate drag coefficient will be determined based on mean wind speed and surface roughness `k` (see below) * `k`, surface roughness [m]. Only required if `C_d`=None """ self.d = d self.C_d = C_d if C_d is None and k is None: raise ValueError("Given `C_d` is None, `k` must be provided") self.k = k # ------------------ PROPERTIES ------------------------------------------- # ---------- @property def d(self): """ Outer diameter of section [m] """ return self._d @d.setter def d(self,val): self._d = val # ---------- @property def C_d(self): """ Drag coefficient """ return self._C_d @C_d.setter def C_d(self,val): if (not isinstance(val,float)) and (val is not None): raise ValueError("`C_d` must be either float or None\n" + "C_d : {0}".format(val)) self._C_d = val # --------- @property def k(self): """ Surface roughness [m] """ return self._k @k.setter def k(self,val): if not isinstance(val,float): raise ValueError("`k` must be a float") self._k = val # --------- RE-DIRECT GETTER METHODS -------------------------------------- @property def R_D(self): return self.calc_R_D @property def R_L(self): return self.calc_R_L @property def R_M(self): return self.calc_R_M # ----------------- CLASS METHODS ----------------------------------------- def calc_R_D(self,alpha,U=20.0,**kwargs): """ Calculates wind resistance for drag loading, given angle of attack `alpha` and mean wind speed `U` If `C_d` has not been defined for section explicitly, appropriate drag coefficient will be calculated given `U` and surface roughness `k` for section """ C_d = self.C_d d = self.d if C_d is None: # Calculate C_d given Reynold number and surface roughness k C_d = self.calc_C_d(U) return d*C_d def calc_R_D_derivative(self,alpha,**kwargs): return numpy.zeros_like(alpha) def calc_R_L(self,alpha,**kwargs): """ Calculates wind resistance for lift loading _Always equals 0.0 for circles, due to symmetry_ """ return numpy.zeros_like(alpha) def calc_R_L_derivative(self,alpha,**kwargs): return numpy.zeros_like(alpha) def calc_R_M(self,alpha,**kwargs): """ Calculates wind resistance for moment loading _Always equals 0.0 for circles, due to symmetry_ """ return numpy.zeros_like(alpha) def calc_R_M_derivative(self,alpha,**kwargs): return numpy.zeros_like(alpha) def calc_C_d(self,U): """ Calculates drag coefficient in accordance with Fig 7.28 BS EN 1991-1-4:2005 """ if not isinstance(U,float): raise ValueError("`U` must be a float") k = self.k b = self.d k_b = max(k/b, 1e-5) Re = calc_Re(U,b) # Curve 1 c_f0_1 = 0.11 / (Re/1e6)**1.4 c_f0_1 = min(max(c_f0_1, 0.4),1.2) # Curve 2 c_f0_2 = 1.2 + (0.18*numpy.log10(10*k_b)) / (1+0.4*numpy.log10(Re/1e6)) # Return maximum of curve 1 and 2 return max(c_f0_1,c_f0_2)
Ancestors (in MRO)
- WindSection_Circular
- WindSection
- builtins.object
Static methods
def __init__(
self, d, C_d=None, k=None)
Defines wind resistances for a circular section
Required:
d
, outer diameter of section [m]
Optional:
-
C_d
, drag coefficient to be used in conjunction withd
. If None appropriate drag coefficient will be determined based on mean wind speed and surface roughnessk
(see below) -
k
, surface roughness [m]. Only required ifC_d
=None
def __init__(self,d,C_d=None,k=None): """ Defines wind resistances for a circular section *** Required: * `d`, outer diameter of section [m] *** Optional: * `C_d`, drag coefficient to be used in conjunction with `d`. If None appropriate drag coefficient will be determined based on mean wind speed and surface roughness `k` (see below) * `k`, surface roughness [m]. Only required if `C_d`=None """ self.d = d self.C_d = C_d if C_d is None and k is None: raise ValueError("Given `C_d` is None, `k` must be provided") self.k = k
def calc_C_d(
self, U)
Calculates drag coefficient in accordance with Fig 7.28 BS EN 1991-1-4:2005
def calc_C_d(self,U): """ Calculates drag coefficient in accordance with Fig 7.28 BS EN 1991-1-4:2005 """ if not isinstance(U,float): raise ValueError("`U` must be a float") k = self.k b = self.d k_b = max(k/b, 1e-5) Re = calc_Re(U,b) # Curve 1 c_f0_1 = 0.11 / (Re/1e6)**1.4 c_f0_1 = min(max(c_f0_1, 0.4),1.2) # Curve 2 c_f0_2 = 1.2 + (0.18*numpy.log10(10*k_b)) / (1+0.4*numpy.log10(Re/1e6)) # Return maximum of curve 1 and 2 return max(c_f0_1,c_f0_2)
def calc_R_D(
self, alpha, U=20.0, **kwargs)
Calculates wind resistance for drag loading, given angle of attack
alpha
and mean wind speed U
If C_d
has not been defined for section explicitly, appropriate drag
coefficient will be calculated given U
and surface roughness k
for
section
def calc_R_D(self,alpha,U=20.0,**kwargs): """ Calculates wind resistance for drag loading, given angle of attack `alpha` and mean wind speed `U` If `C_d` has not been defined for section explicitly, appropriate drag coefficient will be calculated given `U` and surface roughness `k` for section """ C_d = self.C_d d = self.d if C_d is None: # Calculate C_d given Reynold number and surface roughness k C_d = self.calc_C_d(U) return d*C_d
def calc_R_D_derivative(
self, alpha, **kwargs)
Evaluate derivative of drag resistance with respect to angle of attack
at the specified angle alpha
def calc_R_D_derivative(self,alpha,**kwargs): return numpy.zeros_like(alpha)
def calc_R_L(
self, alpha, **kwargs)
Calculates wind resistance for lift loading
Always equals 0.0 for circles, due to symmetry
def calc_R_L(self,alpha,**kwargs): """ Calculates wind resistance for lift loading _Always equals 0.0 for circles, due to symmetry_ """ return numpy.zeros_like(alpha)
def calc_R_L_derivative(
self, alpha, **kwargs)
Evaluate derivative of lift resistance with respect to angle of attack
at the specified angle alpha
def calc_R_L_derivative(self,alpha,**kwargs): return numpy.zeros_like(alpha)
def calc_R_M(
self, alpha, **kwargs)
Calculates wind resistance for moment loading
Always equals 0.0 for circles, due to symmetry
def calc_R_M(self,alpha,**kwargs): """ Calculates wind resistance for moment loading _Always equals 0.0 for circles, due to symmetry_ """ return numpy.zeros_like(alpha)
def calc_R_M_derivative(
self, alpha, **kwargs)
Evaluate derivative of lift resistance with respect to angle of attack
at the specified angle alpha
def calc_R_M_derivative(self,alpha,**kwargs): return numpy.zeros_like(alpha)
def calc_denHertog(
self, alpha, find_roots=True, **kwargs)
Evaluates the 'den Hertog stability criterion' at angles of attack
alpha
, i.e. the following function:
$$ H(\alpha) = dR_L/d\alpha|_{\alpha} + R_D(\alpha) $$
Required:
alpha
, array of angle of attack values at which to evaluate H
Optional
find_roots
: if True, method will seek all roots (where H=0) and return list to define regions of instablity (where H<0 between roots)
Returns:
If find_roots
is False, returns array of H(alpha) values
Otherwise returns tuple consisting of the following:
-
Array of H(alpha) values
-
List of roots, i.e. alpha values where H(alpha)=0
-
List of 2-item lists, defining bounding alpha values for regions where H(alpha) < 0
def calc_denHertog(self,alpha,find_roots:bool=True,**kwargs): r""" Evaluates the 'den Hertog stability criterion' at angles of attack `alpha`, i.e. the following function: $$ H(\alpha) = dR_L/d\alpha|_{\alpha} + R_D(\alpha) $$ *** **Required:** * `alpha`, array of angle of attack values at which to evaluate H *** **Optional** * `find_roots`: if True, method will seek all roots (where H=0) and return list to define regions of instablity (where H<0 between roots) *** **Returns:** If `find_roots` is False, returns array of H(alpha) values Otherwise returns tuple consisting of the following: * Array of H(alpha) values * List of roots, i.e. alpha values where H(alpha)=0 * List of 2-item lists, defining bounding alpha values for regions where H(alpha) < 0 """ def H_func(alpha): RL_derivative = self.calc_R_L_derivative(alpha,order=1,**kwargs) RD = self.calc_R_D(alpha,**kwargs) return RL_derivative + RD H = H_func(alpha) if find_roots: # Detect zero-crossings first brackets = [] for i in range(len(H)-1): H1 = H[i+1] H0 = H[i] if numpy.sign(H1)!=numpy.sign(H0): # Zero-crossing detected brackets.append([alpha[i],alpha[i+1]]) # Use bisection method to obtain precise zero-crossings roots = [] for (a,b) in brackets: roots.append(scipy.optimize.bisect(H_func,a,b)) # Identify instability regions (with H<0) regions = [] if len(roots)>0: # Wrap list around roots = [roots[-1]-2*numpy.pi] + roots + [roots[0]+2*numpy.pi] # Identify regions where H<0 for i in range(len(roots)-1): H_mid = H_func(0.5*(roots[i]+roots[i+1])) if H_mid < 0: regions.append([roots[i],roots[i+1]]) return H, roots, regions else: return H
def plot_denHertog(
self, ax=None, **kwargs)
Plots the den Hertog parameter H for all angles of attack
Where unstable regions (H<0) exist, these are annotated via shading
def plot_denHertog(self,ax=None,**kwargs): """ Plots the den Hertog parameter H for all angles of attack Where unstable regions (H<0) exist, these are annotated via shading """ alpha = numpy.linspace(0,2*numpy.pi,61) H, roots, regions = self.calc_denHertog(alpha,find_roots=True,**kwargs) alpha = numpy.rad2deg(alpha) roots = numpy.rad2deg(roots) regions = numpy.rad2deg(regions) if ax is None: fig,ax = plt.subplots() fig.set_size_inches((8,4)) else: fig = ax.get_figure() ax.plot(alpha,H) ax.set_xlim([0,360]) ax.axhline(0.0,color='k',alpha=0.5) [ax.axvline(r,color='r') for r in roots] [ax.axvspan(a,b,color='r', alpha=0.1) for (a,b) in regions] ax.set_title("Den Hertog parameter $H$\n" + r"$ H = dR_L/d\alpha + R_D $") return fig
def plot_resistances(
self, U=20.0, alpha=None)
Plots variation in wind resistances with angle of attack
Optional:
-
U
, mean wind speed used for resistances calculation (note: for some sections, e.g. circles, wind resistance is Re-dependent) -
alpha
, specific angle of attack values to evaluate resistance at. By defaultalpha
will be plotted in range [0, 2*pi]
def plot_resistances(self,U=20.0, alpha=None): """ Plots variation in wind resistances with angle of attack *** Optional: * `U`, mean wind speed used for resistances calculation (note: for some sections, e.g. circles, wind resistance is Re-dependent) * `alpha`, specific angle of attack values to evaluate resistance at. By default `alpha` will be plotted in range [0, 2*pi] """ if alpha is None: alpha = numpy.linspace(0,2*numpy.pi,61) alpha_deg = numpy.rad2deg(alpha) R_D = [self.calc_R_D(a,U=U) for a in alpha] R_D_deriv = [self.calc_R_D_derivative(a,U=U) for a in alpha] R_L = [self.calc_R_L(a,U=U) for a in alpha] R_L_deriv = [self.calc_R_L_derivative(a,U=U) for a in alpha] R_M = [self.calc_R_M(a,U=U) for a in alpha] R_M_deriv = [self.calc_R_M_derivative(a,U=U) for a in alpha] fig, axarr = plt.subplots(3,2,sharex=True) fig.set_size_inches((12,8)) fig.subplots_adjust(wspace=0.3) ax = axarr[0,0] ax.plot(alpha_deg,R_D) ax.set_ylabel("$R_D$") ax = axarr[0,1] ax.plot(alpha_deg,R_D_deriv) ax.set_ylabel(r"$dR_D/d\alpha}$") ax = axarr[1,0] ax.plot(alpha_deg,R_L) ax.set_ylabel("$R_L$") ax = axarr[1,1] ax.plot(alpha_deg,R_L_deriv) ax.set_ylabel(r"$dR_L/d\alpha$") ax = axarr[2,0] ax.plot(alpha_deg,R_M) ax.set_ylabel("$R_M$") ax = axarr[2,1] ax.plot(alpha_deg,R_M_deriv) ax.set_ylabel(r"$dR_M/d\alpha$") ax = axarr[2,0] ax.set_xlim([alpha_deg[0],alpha_deg[-1]]) ax.set_xlabel(r"Angle of attack $\alpha$ (degrees)") ax.set_ylabel("$R_M$") if ax.get_xlim()==(0,360): ax.set_xticks(numpy.arange(0,361,60)) fig.suptitle("Variation of wind-aligned wind resistances " + "with angle of attack")
Instance variables
var C_d
var R_D
var R_L
var R_M
var d
var k
class WindSection_Custom
Class to define custom wind section by explicitly defining variation of drag, lift and moment resistance with angle of attack
class WindSection_Custom(WindSection): """ Class to define custom wind section by explicitly defining variation of drag, lift and moment resistance with angle of attack """ def __init__(self,alpha:list,R_D:list,R_L:list=None,R_M:list=None): """ Initialise custom wind section *** Required: * `alpha`, list-like, gives specific values of angle of attack values [radians] * `R_D`, list-like, gives specific values of drag wind resistance [m] at angles of attack corresponding to `alpha` *** Optional: * `R_L`, list-like, gives specific values of lift wind resistance [m] at angles of attack corresponding to `alpha`. If None (default) then zero values assumed for all `alpha` * `R_M`, list-like, gives specific values of moment wind resistance [m2] at angles of attack corresponding to `alpha`. If None (default) then zero values assumed for all `alpha` """ # Check array dimensions N = len(alpha) if len(R_D)!= N: raise ValueError("`len(R_D)` must agree with `len(alpha)`") if R_L is not None and len(R_L)!= N: raise ValueError("`len(R_L)` must agree with `len(alpha)`") if R_M is not None and len(R_M)!= N: raise ValueError("`len(R_M)` must agree with `len(alpha)`") # Check limits if alpha[-1] > 2*numpy.pi or alpha[0]<0: raise ValueError("`alpha` to be in the range [0,2*pi]") # Define cubic splines through passed-in list data settings = {'bc_type':'periodic'} # n.b. must be periodic in alpha interpolation_class = CubicSpline # class to use for interpolation # note use of cubic spline is advantageous as allows derivatives calc R_D_func = interpolation_class(alpha,R_D,**settings) if R_L is not None: R_L_func = interpolation_class(alpha,R_L,**settings) else: R_L_func = lambda x : 0.0 if R_M is not None: R_M_func = interpolation_class(alpha,R_M,**settings) else: R_M_func = lambda x : 0.0 # WindSection init method super().__init__(R_D=R_D_func, R_L=R_L_func, R_M=R_M_func)
Ancestors (in MRO)
- WindSection_Custom
- WindSection
- builtins.object
Static methods
def __init__(
self, alpha, R_D, R_L=None, R_M=None)
Inheritance:
WindSection
.__init__
Initialise custom wind section
Required:
-
alpha
, list-like, gives specific values of angle of attack values [radians] -
R_D
, list-like, gives specific values of drag wind resistance [m] at angles of attack corresponding toalpha
Optional:
-
R_L
, list-like, gives specific values of lift wind resistance [m] at angles of attack corresponding toalpha
. If None (default) then zero values assumed for allalpha
-
R_M
, list-like, gives specific values of moment wind resistance [m2] at angles of attack corresponding toalpha
. If None (default) then zero values assumed for allalpha
def __init__(self,alpha:list,R_D:list,R_L:list=None,R_M:list=None): """ Initialise custom wind section *** Required: * `alpha`, list-like, gives specific values of angle of attack values [radians] * `R_D`, list-like, gives specific values of drag wind resistance [m] at angles of attack corresponding to `alpha` *** Optional: * `R_L`, list-like, gives specific values of lift wind resistance [m] at angles of attack corresponding to `alpha`. If None (default) then zero values assumed for all `alpha` * `R_M`, list-like, gives specific values of moment wind resistance [m2] at angles of attack corresponding to `alpha`. If None (default) then zero values assumed for all `alpha` """ # Check array dimensions N = len(alpha) if len(R_D)!= N: raise ValueError("`len(R_D)` must agree with `len(alpha)`") if R_L is not None and len(R_L)!= N: raise ValueError("`len(R_L)` must agree with `len(alpha)`") if R_M is not None and len(R_M)!= N: raise ValueError("`len(R_M)` must agree with `len(alpha)`") # Check limits if alpha[-1] > 2*numpy.pi or alpha[0]<0: raise ValueError("`alpha` to be in the range [0,2*pi]") # Define cubic splines through passed-in list data settings = {'bc_type':'periodic'} # n.b. must be periodic in alpha interpolation_class = CubicSpline # class to use for interpolation # note use of cubic spline is advantageous as allows derivatives calc R_D_func = interpolation_class(alpha,R_D,**settings) if R_L is not None: R_L_func = interpolation_class(alpha,R_L,**settings) else: R_L_func = lambda x : 0.0 if R_M is not None: R_M_func = interpolation_class(alpha,R_M,**settings) else: R_M_func = lambda x : 0.0 # WindSection init method super().__init__(R_D=R_D_func, R_L=R_L_func, R_M=R_M_func)
def calc_R_D(
self, alpha, **kwargs)
Calculates wind resistance for drag loading, given angle of attack
alpha
and mean wind speed U
def calc_R_D(self,alpha,**kwargs): """ Calculates wind resistance for drag loading, given angle of attack `alpha` and mean wind speed `U` """ return _func_or_float(self.R_D,alpha)
def calc_R_D_derivative(
self, alpha, order=1, **kwargs)
Evaluate derivative of drag resistance with respect to angle of attack
at the specified angle alpha
def calc_R_D_derivative(self,alpha,order=1,**kwargs): """ Evaluate derivative of drag resistance with respect to angle of attack at the specified angle `alpha` """ return _derivative_func(self.R_D,alpha,order=order)
def calc_R_L(
self, alpha, **kwargs)
Calculates wind resistance for lift loading, given angle of attack
alpha
and mean wind speed U
def calc_R_L(self,alpha,**kwargs): """ Calculates wind resistance for lift loading, given angle of attack `alpha` and mean wind speed `U` """ return _func_or_float(self.R_L,alpha)
def calc_R_L_derivative(
self, alpha, order=1, **kwargs)
Evaluate derivative of lift resistance with respect to angle of attack
at the specified angle alpha
def calc_R_L_derivative(self,alpha,order=1,**kwargs): """ Evaluate derivative of lift resistance with respect to angle of attack at the specified angle `alpha` """ return _derivative_func(self.R_L,alpha,order=order)
def calc_R_M(
self, alpha, **kwargs)
Calculates wind resistance for moment loading, given angle of attack
alpha
and mean wind speed U
def calc_R_M(self,alpha,**kwargs): """ Calculates wind resistance for moment loading, given angle of attack `alpha` and mean wind speed `U` """ return _func_or_float(self.R_M,alpha)
def calc_R_M_derivative(
self, alpha, order=1, **kwargs)
Evaluate derivative of lift resistance with respect to angle of attack
at the specified angle alpha
def calc_R_M_derivative(self,alpha,order=1,**kwargs): """ Evaluate derivative of lift resistance with respect to angle of attack at the specified angle `alpha` """ return _derivative_func(self.R_M,alpha,order=order)
def calc_denHertog(
self, alpha, find_roots=True, **kwargs)
Evaluates the 'den Hertog stability criterion' at angles of attack
alpha
, i.e. the following function:
$$ H(\alpha) = dR_L/d\alpha|_{\alpha} + R_D(\alpha) $$
Required:
alpha
, array of angle of attack values at which to evaluate H
Optional
find_roots
: if True, method will seek all roots (where H=0) and return list to define regions of instablity (where H<0 between roots)
Returns:
If find_roots
is False, returns array of H(alpha) values
Otherwise returns tuple consisting of the following:
-
Array of H(alpha) values
-
List of roots, i.e. alpha values where H(alpha)=0
-
List of 2-item lists, defining bounding alpha values for regions where H(alpha) < 0
def calc_denHertog(self,alpha,find_roots:bool=True,**kwargs): r""" Evaluates the 'den Hertog stability criterion' at angles of attack `alpha`, i.e. the following function: $$ H(\alpha) = dR_L/d\alpha|_{\alpha} + R_D(\alpha) $$ *** **Required:** * `alpha`, array of angle of attack values at which to evaluate H *** **Optional** * `find_roots`: if True, method will seek all roots (where H=0) and return list to define regions of instablity (where H<0 between roots) *** **Returns:** If `find_roots` is False, returns array of H(alpha) values Otherwise returns tuple consisting of the following: * Array of H(alpha) values * List of roots, i.e. alpha values where H(alpha)=0 * List of 2-item lists, defining bounding alpha values for regions where H(alpha) < 0 """ def H_func(alpha): RL_derivative = self.calc_R_L_derivative(alpha,order=1,**kwargs) RD = self.calc_R_D(alpha,**kwargs) return RL_derivative + RD H = H_func(alpha) if find_roots: # Detect zero-crossings first brackets = [] for i in range(len(H)-1): H1 = H[i+1] H0 = H[i] if numpy.sign(H1)!=numpy.sign(H0): # Zero-crossing detected brackets.append([alpha[i],alpha[i+1]]) # Use bisection method to obtain precise zero-crossings roots = [] for (a,b) in brackets: roots.append(scipy.optimize.bisect(H_func,a,b)) # Identify instability regions (with H<0) regions = [] if len(roots)>0: # Wrap list around roots = [roots[-1]-2*numpy.pi] + roots + [roots[0]+2*numpy.pi] # Identify regions where H<0 for i in range(len(roots)-1): H_mid = H_func(0.5*(roots[i]+roots[i+1])) if H_mid < 0: regions.append([roots[i],roots[i+1]]) return H, roots, regions else: return H
def plot_denHertog(
self, ax=None, **kwargs)
Plots the den Hertog parameter H for all angles of attack
Where unstable regions (H<0) exist, these are annotated via shading
def plot_denHertog(self,ax=None,**kwargs): """ Plots the den Hertog parameter H for all angles of attack Where unstable regions (H<0) exist, these are annotated via shading """ alpha = numpy.linspace(0,2*numpy.pi,61) H, roots, regions = self.calc_denHertog(alpha,find_roots=True,**kwargs) alpha = numpy.rad2deg(alpha) roots = numpy.rad2deg(roots) regions = numpy.rad2deg(regions) if ax is None: fig,ax = plt.subplots() fig.set_size_inches((8,4)) else: fig = ax.get_figure() ax.plot(alpha,H) ax.set_xlim([0,360]) ax.axhline(0.0,color='k',alpha=0.5) [ax.axvline(r,color='r') for r in roots] [ax.axvspan(a,b,color='r', alpha=0.1) for (a,b) in regions] ax.set_title("Den Hertog parameter $H$\n" + r"$ H = dR_L/d\alpha + R_D $") return fig
def plot_resistances(
self, U=20.0, alpha=None)
Plots variation in wind resistances with angle of attack
Optional:
-
U
, mean wind speed used for resistances calculation (note: for some sections, e.g. circles, wind resistance is Re-dependent) -
alpha
, specific angle of attack values to evaluate resistance at. By defaultalpha
will be plotted in range [0, 2*pi]
def plot_resistances(self,U=20.0, alpha=None): """ Plots variation in wind resistances with angle of attack *** Optional: * `U`, mean wind speed used for resistances calculation (note: for some sections, e.g. circles, wind resistance is Re-dependent) * `alpha`, specific angle of attack values to evaluate resistance at. By default `alpha` will be plotted in range [0, 2*pi] """ if alpha is None: alpha = numpy.linspace(0,2*numpy.pi,61) alpha_deg = numpy.rad2deg(alpha) R_D = [self.calc_R_D(a,U=U) for a in alpha] R_D_deriv = [self.calc_R_D_derivative(a,U=U) for a in alpha] R_L = [self.calc_R_L(a,U=U) for a in alpha] R_L_deriv = [self.calc_R_L_derivative(a,U=U) for a in alpha] R_M = [self.calc_R_M(a,U=U) for a in alpha] R_M_deriv = [self.calc_R_M_derivative(a,U=U) for a in alpha] fig, axarr = plt.subplots(3,2,sharex=True) fig.set_size_inches((12,8)) fig.subplots_adjust(wspace=0.3) ax = axarr[0,0] ax.plot(alpha_deg,R_D) ax.set_ylabel("$R_D$") ax = axarr[0,1] ax.plot(alpha_deg,R_D_deriv) ax.set_ylabel(r"$dR_D/d\alpha}$") ax = axarr[1,0] ax.plot(alpha_deg,R_L) ax.set_ylabel("$R_L$") ax = axarr[1,1] ax.plot(alpha_deg,R_L_deriv) ax.set_ylabel(r"$dR_L/d\alpha$") ax = axarr[2,0] ax.plot(alpha_deg,R_M) ax.set_ylabel("$R_M$") ax = axarr[2,1] ax.plot(alpha_deg,R_M_deriv) ax.set_ylabel(r"$dR_M/d\alpha$") ax = axarr[2,0] ax.set_xlim([alpha_deg[0],alpha_deg[-1]]) ax.set_xlabel(r"Angle of attack $\alpha$ (degrees)") ax.set_ylabel("$R_M$") if ax.get_xlim()==(0,360): ax.set_xticks(numpy.arange(0,361,60)) fig.suptitle("Variation of wind-aligned wind resistances " + "with angle of attack")


This release focuses on minor bug fixes in libdataset. All functions which returned an error string only now return True for success and False otherwise. The error string can be retreived with dataset.error_message()
.
Build Notes:
Some tests fail on Windows 10 for libdataset. These will be addressed in future releases.


--- layout: default title: Our Approach to Service description: "Leaders in outdoor maintenance. Terracare Associates is a leading commercial landscape maintenance and public infrastructure management company in the Western United States." parent: About Us sidebar: Timely Performance with Technical Competence class: about banner: milpitas-team.jpg banner-heading: "Leaders in Outdoor Maintenance" banner-sub-heading: "" banner-cta: "" ---
Best Value and Superior Service Quality
We understand everyone is on a budget and are committed to maximizing quality while spending your money wisely. Our teams are always sensitive to your budget needs and our customizable maintenance contracts also allow customers the flexibility to adapt to changing budgets.
Communication:
Account and Project Managers are the eyes and ears of your property - trained to provide reliable and responsive communication on a continual basis. Whether you need tailored reporting on a weekly, monthly basis or quarterly site walk-throughs, Terracare Associates-TCA will provide you with email, text or radio access 24/7. In addition, all of our account managers and foreman speak English as a first language, so correspondence is simple and clear.
Customer Service:
We know reliable and punctual communication is of utmost importance. We have set internal goals and incentives to ensure prompt response times, as well as dependable and consistent communication.
Experience:
Our team members are certified, experienced, dedicated and professional.
Safety:
Safety is about people. Keeping employees safe every day is priority number one. Extensive safety training before working in the field and mandatory weekly meetings to review specific safety practices are standard.
Responsibility/Sustainability: Good Stewards of our Communities.
Being responsible to the environment and our community is part of our core values; We strive to be good corporate citizens every day and on every job.


University Event Manager
View Events
Create Event
RSOs
Super Admin
Logout
Super Admin Management
University Profile
UNIVERSITY NAME
ADDRESS
CITY
STATE
ZIP CODE
UNIVERSITY DESCRIPTION
Number of Students
University Logo URL
University Logo Preview
Pending Events
Event ID
Event Name
Event Type
Event Category
Event Description
Event Start Time
Event End Time
Event Date
Contact Phone
Contact Email
Location
Approve?
Decline?


{% extends "shared/layout.html" %} {% block contents %}
The link you've entered is not known to this shortener service.


--- layout: project title: WebGL Particle Demo date: July, 2014 excerpt: A small demo showing some particle effects in WebGL. categories: javascript webgl ---
I created this demo when I was messing around trying to learn some WebGL basics. I think it looks pretty cool, so I figured I'd leave it here. :)
Here is the demo: link


Monnaie
Create Account
Sign Up
Sign In
Forgot your password?
Sign In
Welcome Back!
Sign-in to view your budget summary.
Sign In
Hey There!
Not a Monnaie member? Sign-Up!
Sign Up
Budget
Checklist
Estimate


Launch Demo
Store our infrastructure as code
Auditability
Consistency
We can automate the test and deployment our infrastructure
Which can lead to more confidence in the infrastructure
Make changes to a template in your favourite text editor/IDE
Check in template into Git
Let your favourite CI Pipeline system take the template and using AWS' CLI or PowerShell Modules...
Push the new template to AWS CFN
Watch your changes take place
Have your (non prod) infrastructure tear down every night
Have your CI system spin up a new set of infrastructure in the morning
Deploy your applications to the fresh infrastructure
Run your integration tests against them
Be filled with confidence as the board lights up green!
Essentially alot of text and squiggly brackets
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "",
"Metadata" : {},
"Parameters" : {},
"Mappings" : {},
"Conditions" : {},
"Resources" : {},
"Outputs" : {}
}
(AWS Resources)
aws cloudformation create-stack
--stack-name xConfDemo
--template-body file://CFN//demo.template
New-CFNStack `
-Capability "CAPABILITY_IAM" `
-StackName "xConfDemo" `
-TemplateURL "URL to template uploaded into S3" `
-Parameters "@(@{ParameterKey="Key1"; ParameterValue="Value1"},@{ParameterKey="Key2"; ParameterValue="Value2"})" `
-AccessKey "Your Access Key" `
-SecretKey "Your Secret Key" `
-Region "ap-southeast-2"


Club Championship 2017 Event 4
| Kib 25 |
23 April 17 |
|
25 |
miles |
| Name |
Position |
Road bike |
Actual Time |
Avg. mph |
| |
|
|
|
|
| Phil
Rayner |
1 |
|
00:59:30 |
25.21 |
| Matt
Plews |
2 |
|
00:59:45 |
25.10 |
| Julian
Twynham |
3 |
|
01:01:24 |
24.43 |
| Matt
Crabtree |
4 |
|
01:02:31 |
23.99 |
| Jonathan
Durnin |
5 |
|
01:03:53 |
23.48 |
| Richard
Mortimer |
6 |
|
01:04:31 |
23.25 |
| Bill
Barrie |
7 |
|
01:06:00 |
22.73 |
| Adrian
Killworth |
8 |
|
01:06:32 |
22.55 |
| Linda
Hubbard |
9 |
|
01:06:58 |
22.40 |
| Calum
Foster |
10 |
|
01:08:54 |
21.77 |
| Dan High |
11 |
|
01:10:30 |
21.28 |
| Steven
Welch |
12 |
1 |
01:13:10 |
20.50 |
| David
Reay |
13 |
|
01:15:09 |
19.96 |
| Tom
Evans |
14 |
|
01:16:15 |
19.67 |
| Jennifer
Clegg |
15 |
|
01:18:58 |
19.00 |
| Stewart
Holland |
16 |
2 |
01:19:40 |
18.83 |
| Paul
Barker |
17 |
3 |
01:24:08 |
17.83 |
| Andrew
Weatherby |
18 |
4 |
01:26:26 |
17.35 |
|
|
|
|
|


Returns:
g = create_simple_test_graph()
bfw = SampledHeterogeneousBreadthFirstWalk(g)
nodes = [0] // this is an isolated user node with no self loop
n = 1
Returns:
g = create_test_graph(self_loop=True)
bfw = SampledHeterogeneousBreadthFirstWalk(g)
nodes = [0] // this is an isolated user node with no self loop
n = 1


Polina Makar is a brave 6-year-old girl who is now battling spinal cord cancer.
requires a surgical intervention to remove the tumors located in the brain and back which are deteriorating all her vitality and life expectancy.
Polina and her family live in the city of Kharkiv Ukraine, her parents are unemployed due to the difficult situation of the global pandemic of COVID 19.
The surgery to which Polina must do has a value of $ 55,000 dollars and her parents do not have the financial resources to face the high costs of this surgery.
Polina and her family cannot fight cancer alone, she wants to play, paint, dance, laugh and above all Live; Together we can become heroes by helping Polina to win the battle against cancer so that she can heal and smile again.
Your donation is important to save Polina's life.
Thank you for giving your time and to put your heart and your donation.


|
GuardMyPi
Protecting your berries from unauthorised tampering!
|
Analyses video feed by using background subtraction with a running average to detect motion changes. More...
#include <guardmypi.h>
Public Member Functions | |
| Mat | ProcessContours (Mat camerafeed) |
| Takes the incoming frame and performs background subtraction using previous frames. More... | |
Public Attributes | |
| Mat | avg |
| Running average of the camerafeed. | |
| int | flag = 0 |
| Flag variable to invoke ObjectDetector thread t2. | |
Protected Attributes | |
| Mat | frame_diff |
| Difference output between frames. | |
| Mat | grayscale |
| Grayscaled version of the camera frame. | |
| Mat | frame_thresh |
| Threshold frame. | |
| Mat | scaled_avg |
| 8-bit Absolute value frame | |
| vector< vector< Point > > | cnts |
| Vector of points of detected contours. | |
| Rect | rect |
| Up-right rectangle to highlight detected contours. | |
| Point | pt1 |
| Start point/coordinate for the contour rectangle. | |
| Point | pt2 |
| End point/coordinate for the contour rectangle. | |
Analyses video feed by using background subtraction with a running average to detect motion changes.
| Mat MotionDetector::ProcessContours | ( | Mat | camerafeed | ) |
Takes the incoming frame and performs background subtraction using previous frames.
Performs background subtraction to detect changes in the frame i.e. motion. Subsequently, alters the flag variable equal to 1 if motion is detected to invoke the object detector in a new thread
| camerafeed | frame captured from PiCamera or Webcam |


| Terms | Definitions |
|---|---|
| Bitcoin | It is by far the most well-known digital currency. It announced blockchain technology to the world. It has a feature whereby new bitcoins are generated and added to the system, having an inflationary effect. It’s distributed structure of the system coupled with its cryptographic functionality make it incredibly robust. It’s blockchain uses resource-intensive algorithms. |
| Block | Bundle of new recorded transactions which is added as the latest link on a long 'chain' of historic transactions forming a blockchain. |
| Blockchain | Decentralised, encrypted and self-executing technology enabling the recording of lists of transactions. Transactions are only accepted if all the users agree that it is legitimate. Its best-known use is for digital currencies such as Bitcoin. By embedding code in the blockchain, transactions can be executed automatically in response to certain conditions being met, providing a 'guarantee of execution’. Self-executing smart contracts based upon this functionality are developing rapidly. |
| Decentralisation | In working progress… |
| Encrypt | In working progress… |
| End-to-end encryption | In working progress… |
| Hashing | Feature of the blockchain technology. It is a process through which a document is transformed into a fixed length code which is described as a digital fingerprint. |
| Ledger | In working progress… |
| Middleman | Intermediary which is trusted by all users, who has total control over the system and is responsible for mediating every transaction on a ledger (for example banks, governments, etc.). |
| Mining | Process in which the transaction is packaged into a 'block' of transactions, and added, to the ever-growing list of blocks that form the blockchain ledger. |
| Nakamoto, Satoshi | It is the pseudonym for the mysterious and elusive publisher(s) of an article describing how cryptography, combined with a distributed public ledger, could be used to implement a digital currency without a central authority to authenticate payments. His article is the fundamental on which Satoshi Nakamoto launched the Bitcoin. |
| Ownership history | Record of digital property which enables the blockchain to protect consumers and creators of digital works of all kinds. It enables customers to ensure that they were buying legitimate goods rather than illegitimate copies, and could also enable rights holders to enforce their rights. |
| Peer-to-peer | In working progress… |
| Permissioned blockchain-based voting | Electoral authority system, maintaining control over the distribution of pseudonyms to guarantee anonymity and affirming their role as the ultimate authority and central mediator through which all votes must pass. |
| Pseudonymity | Feature of the blockchain technology. The fact that all transactions are transparent, but they are not explicitly connected to real-world individuals or organisations, shielding the identity of parties along the supply chain without compromising the integrity of the record. |
| Scarcity | In working progress… |
| Smart contract | Computerised transaction protocol that executes the terms of a contract. Self-executing transactions in response to certain conditions being met, providing a 'guarantee of execution'. |
| Token | Certificate of identity for unique digital goods that can be transferred with the blockchain technology. |
| Watchdog | In working progress… |


PRIVACY POLICY
|
|
By using this site, you agree to the terms of the Spaghetti Book Club Privacy Policy. We may make changes to this policy at any time, so please check this page periodically.
Spaghetti Book Club has created this privacy statement to show you that we are committed to the privacy of every adult and child who visits or posts reviews on the site. This statement explains what information we collect from participating teachers and children, why we ask for the information and how we use the information.
|
| What personal information we ask for and why |
| Children's information |
|
This policy complies with the Children's Online Privacy Protection Act (COPPA), which prohibits us from collecting information from children under 13 on our Web site without parental consent. No information is collected from children through our site.
Book Reviews
- The only information about children that the Spaghetti Book Club collects is through a written parental consent form. When a parent or guardian signs the Spaghetti Book Club consent form we ask for certain information. We ask only for the child's first name, last name, and birth date.
- A child's name is used to properly give credit to each student work. Only a child's first name and the first initial of his/her last name are displayed on the site. For additional privacy, a parent may provide an alias instead of the child's real name.
- A child's birth date is used to calculate age for book reviews and for administration purposes.
- Spaghetti Book Club does not share any of this information with third parties.
Bulletin Board Messages
- In order to post a bulletin board message, a user must enter three initials only. No personally identifiable information is requested. This is to ensure that no personally identifiable information is collected or posted on our Web site without parental approval. Please do not include any personally identifiable information in your bulletin board message.
- Spaghetti Book Club reviews each message before it is posted, to delete any personal information that the user might have inadvertently revealed. This information is also deleted from the records of the Spaghetti Book Club.
|
| Adults' information |
- Member teachers are those who join the Spaghetti Book Club by filling out a form and paying a membership fee.
- Teachers fill out a registration form on the Web site in order to join the Spaghetti Book Club. This form requires the teacher's name and e-mail address, the name, address and telephone number of the school, the principal's name, the grade of the class and the number of students.
- The only information from teachers that is displayed on the site is the name of the teacher and the school, the city and state where the school is located, and the grade of the class. This information is used to properly give credit to student works.
|
| Cookies |
|
"Cookies" are pieces of information that are put on a computer by a Web site and can be used to track the identity and activity of a user on a Web site and which features of the site are most often used.
|
- Spaghetti Book Club does not use cookies at all in the areas of the site that are accessed by children.
- The only place that cookies are used is in the password-protected area where teachers who have joined the Spaghetti Book Club sign in to submit student reviews. Cookies are used so that a teacher does not need to enter his or her password each time a different section of the site is accessed.
- Spaghetti Book Club will never use cookies to retrieve information from a visitor's computer for any other purpose.
|
| Other sites |
- Other Web sites may link to our site, and we do not have control over those other sites. We do not support linking by sites that advertise or seek financial benefit from linking to our site. Also be aware that the Spaghetti Book Club is not responsible for the privacy practices or content of those other sites.
- Spaghetti Book Club may link to other sites on the Internet. Those other sites may have a privacy policy that is different from the Spaghetti Book Club's privacy policy and may use cookies. We are not responsible for the privacy practices or content of those other sites.
|
| Please read the Spaghetti Book Club Terms of Use Policy, which states the terms and conditions for using our site.


this is my bio :
my name is mamoun alshishani, i'm 24 years old, and i live in az zarqa
i graduated from albalqa university with bachelor's degree in management information system (mis)
i am corrently taking software development course as a student in ltuc


Registration for the Percona Live Amsterdam conference community dinner at Booking.com is ongoing. Please note the following:
- By Monday noon the kitchen will make the necessary purchasing. At this time we will have to give them a number, which we will not exceed.
- The number we will give them is $(number of registrants Monday 12:00) + X, X being a constant
- Those X tickets will be available until Tuesday 12:00
- After which the registration is closed. We wish to avoid throwing away food, on one hand, as well as respect those who have reserved place and avoid running out of food, on the other.
Entry to the Booking.com building will be made available via Security personnel to those people who will be listed by the eventbrite registration. We will not be able to have last moment registrants; we will not collect money at the entrance; no credit cards accepted at the doorway.
If you'd like to attend the community dinner, please register now!
FYI Percona has arranged for boats to make the travel from the conference venue to Booking.com (no registration required, but room limited on those boats as well).
Now ain't I being dramatic here. So happy to see everyone here in Amsterdam in a few days!
comments powered by Disqus