# --- DOMAIN domain = Domain.PlanarStraightLineGraphDomain() # --- Wave length wave_length = np.sqrt(9.81 * opts.mwl) * opts.Tp # --- Wave Input wave = wt.NewWave(Tp=opts.Tp, Hs=opts.Hs, mwl=opts.mwl, depth=opts.mwl, waveDir=opts.waveDir, g=np.array([0., -9.805, 0.]), N=opts.N, bandFactor=opts.bandFactor, spectName=opts.spectName, spectral_params=opts.spectral_params, crestFocus=opts.crestFocus, xfocus=np.array([opts.xfocus * wave_length, 0., 0.]), tfocus=opts.tfocus, fast=opts.fast, Nmax=opts.Nmax) # --- Domain tank_dim = (3 * wave_length + opts.structureCrestLevel * opts.structure_slope + opts.deposit_width, opts.tank_height) # --- Tank Outline Geometry vertices = [
("nd", 2, "used in signed distance function"), ("Tend", 60., "total simulation time"), ("fract", 1., "total simulation time/ chosen simulation time"), ("Np", 10., " Output points per period Tp/Np"), ("dt_init", 0.001, "initial time step"), ("refinement_level", 2.5, "to define characteristic element size he, he=radius/refinement_level") ]) ############################# Domain & Waves ################################ # --- Domain domain = Domain.PlanarStraightLineGraphDomain() tank = Tank2D(domain, opts.tank_dim) # --- WAVE input current = wt.SteadyCurrent(U=opts.U, mwl=opts.mwl, rampTime=opts.rampTime) # --- Script on wave length # wave_length=wave.wavelength # --- Sponge tank.setSponge(x_n=opts.left_sponge, x_p=None) # --- Refinement he = opts.radius / opts.refinement_level smoothing = opts.ecH * he dragAlpha = 5 * (2 * np.pi / opts.Tt[1]) / 1e-6 tank.setGenerationZones(x_n=True, waves=current,
K_model = 9 EPS_model = 10 PI_model = 11 else: K_model = None EPS_model = None PI_model = 9 # Domain dimensions nd = 2 # Turbulence and wall functions steady_current = wt.SteadyCurrent(U=np.array([opts.inflow_vel, 0., 0.]), mwl=opts.waterLevel, rampTime=0.8) #I = opts.I #kInflow = 0.5*(opts.inflow_vel*I)**2 #Lturb = opts.Ly/6. #dissipationInflow = (opts.Cmu**0.75) *(kInflow**1.5)/Lturb #Wall functions he = opts.tank_dim_y / opts.refinement Re = opts.inflow_vel * opts.tank_dim_y / opts.nu_0 Y_ = he cf = 0.045 * (Re**(-1. / 4.)) Ut = opts.inflow_vel * sqrt(cf / 2.) Yplus = Y_ * Ut / opts.nu_0 kappaP = (Ut**2) / sqrt(opts.Cmu)
def signalFilter(time,data,minfreq,maxfreq,costapCut = False): dt = (time[-1]-time[0])/(len(time)-1) doInterp = False data1 = np.zeros(data.shape,) for i in range(1,len(time)): dt_temp = time[i]-time[i-1] if dt_temp!=dt: doInterp = True if(doInterp): print "Interpolating series" time_lin = np.linspace(time[0],time[-1],len(time)) try: for ii in range(nprobes): data1[:,ii] = np.interp(time_lin,time,data[:,ii]) time = time_lin data = data1 nprobes = len(data[0,:]) except: data1 = np.interp(time_lin,time,data[:]) time = time_lin data = data1 nprobes = -1 nfft = len(time) dt = (time[-1]-time[0])/(len(time)-1) freq = np.fft.fftfreq(nfft,dt) i1 = np.where(freq > maxfreq)[0] i3 = np.where(freq < -maxfreq)[0] i2a = [] i2b = [] for jj in range(1,len(freq)): if(freq[jj] < minfreq and freq[jj]>0): i2a.append(jj) if(freq[jj] > -minfreq and freq[jj]<0): i2b.append(jj) band1 = min(i1)-max(i2a) band2 = min(i2b) - max(i3) del data1 data1 = np.zeros(data.shape) fft_x = None for ii in range(max(nprobes,1)): if(nprobes == -1): fft_x = np.fft.fft(data[:],nfft) fft_x[i1] = 0. fft_x[i2a] = 0. fft_x[i2b] = 0. fft_x[i3] = 0. if(costapCut): fft_x[max(i2a):min(i1)] *= WT.costap(band1,0.1) fft_x[max(i3):min(i2b)] *= WT.costap(band2,0.1) data1[:] = np.fft.ifft(fft_x) else: fft_x = np.fft.fft(data[:,ii],nfft) fft_x[i1,ii] = 0. fft_x[i2a,ii] = 0. fft_x[i2b,ii] = 0. fft_x[i3,ii] = 0. if(costapCut): fft_x[max(i2a):min(i1),ii] *= WT.costap(band1,0.1) fft_x[max(i3):min(i2b),ii] *= WT.costap(band2,0.1) data1[:,ii] = np.fft.ifft(fft_x) return data1
("nperiod", 10., "Number of time steps to save per period"), ]) # ----- CONTEXT ------ # # general options waterLevel = opts.water_level # waves period = opts.wave_period height = opts.wave_height mwl = opts.water_level depth = opts.depth direction = opts.wave_dir wave = wt.MonochromaticWaves(period, height, mwl, depth, np.array(opts.g), direction) # tank options tank_dim = opts.tank_dim tank_sponge = opts.tank_sponge ########################################## # Discretization Input Options # ########################################## # ----- From Context.Options ----- # refinement_level = opts.refLevel genMesh = opts.gen_mesh useHex = opts.useHex structured = opts.structured
tank = st.CustomShape(domain, vertices=vertices, vertexFlags=vertexFlags, segments=segments, segmentFlags=segmentFlags, regions=regions, regionFlags=regionFlags, boundaryTags=boundaryTags, boundaryOrientations=boundaryOrientations) ############################################################################################################################################################################################################################################################################################################################################################################################# # ----- BOUNDARY CONDITIONS ----- # ############################################################################################################################################################################################################################################################################################################################################################################################# steady_current = wt.SteadyCurrent(U=np.array([opts.U, 0., 0.]), mwl=waterLevel, rampTime=0.1) tank.BC['y-'].setFreeSlip() tank.BC['x-'].setUnsteadyTwoPhaseVelocityInlet(wave=steady_current, smoothing=3 * he, vert_axis=1) tank.BC['y+'].setAtmosphere(orientation=np.array([0, 1, 0])) tank.BC['x+'].setFreeSlip() #tank.BC['y+'].setFreeSlip() tank.BC['x+'].setHydrostaticPressureOutletWithDepth_stressFree( seaLevel=1e10, rhoUp=rho_1, rhoDown=rho_0, nuUp=nu_1, nuDown=nu_0,
tank = st.TankWithObstacles2D(domain=domain, dim=tank_dim, obstacles=weir, special_boundaries=vent) # ----- WAVES ----- # omega = 1. if opts.waves: omega=2*np.pi/2. wave = wt.MonochromaticWaves( period = 2, waveHeight =0.018, mwl = waterLine_z, depth = waterLine_z, g = np.array(g), waveDir = (1.,0.,0.), wavelength = 0.5, meanVelocity = np.array([inflow_velocity, 0., 0.]) ) dragAlpha = 5.*omega/nu_0 tank.setSponge(x_n = opts.tank_sponge[0], x_p = opts.tank_sponge[1]) tank.setAbsorptionZones(x_n=True, dragAlpha = dragAlpha) tank.setAbsorptionZones(x_p=True, dragAlpha = dragAlpha) # ----- VARIABLE REFINEMENT ----- # if opts.variable_refine_borders or opts.variable_refine_levels: refinement_borders = opts.variable_refine_borders refinement_levels = opts.variable_refine_levels
rho_0 = 998.2 nu_0 = 1.004e-6 rho_1 = 1.205 nu_1 = 1.500e-5 sigma_01 = 0.0 g = np.array([0., -9.8, 0.]) gAbs = sqrt(sum(g**2)) # ----- WAVE input ----- # if opts.waveType == 'Linear': waveinput = wt.MonochromaticWaves( period=period, waveHeight=waveHeight, mwl=mwl, depth=waterLevel, g=g, waveDir=waveDir, wavelength=None, # if wave is linear I can use None waveType=opts.waveType) if opts.waveType == 'Fenton': waveinput = wt.MonochromaticWaves( period=period, waveHeight=waveHeight, mwl=mwl, depth=waterLevel, g=g, waveDir=waveDir, wavelength=opts.wavelength, # if wave is linear I can use None waveType=opts.waveType,
("sigma_01", 0., "surface tension"), ('movingDomain', True, "Moving domain and mesh option"), ('scheme', 'Forward_Euler', 'Numerical scheme applied to solve motion calculation (Runge_Kutta or Forward_Euler)' ), ]) # --- Domain domain = Domain.PlanarStraightLineGraphDomain() # --- Wave input wave = wt.MonochromaticWaves(period=opts.T, waveHeight=opts.wave_height, mwl=opts.water_level, depth=opts.depth, g=opts.g, waveDir=opts.waveDir, waveType=opts.waveType, autoFenton=True, Nf=opts.Nf) wave_length = wave.wavelength # --- Tank Setup tank = st.Tank2D(domain, opts.tank_dim) ################### Caisson ################### # --- Caisson2D Geometry / Shapes xc1 = opts.center[0] - 0.5 * opts.dim[0] yc1 = opts.center[1] - 0.5 * opts.dim[1]
#wave generator #windVelocity = Context.opts.windVelocity windVelocity = (0.0, 0.0) inflowHeightMean = 1.0 inflowVelocityMean = (0.0, 0.0) period = 1.94 omega = 2.0 * math.pi / period waveheight = 0.125 amplitude = waveheight / 2.0 wavelength = 5.0 k = 2.0 * math.pi / wavelength waves = WaveTools.RandomWaves(Tp=1.94, Hs=waveheight, d=1.0, fp=1.0 / 1.94, bandFactor=2.0, N=101, mwl=1.0, g=9.8) #shouldn't mwl = d always? waves = WaveTools.MonochromaticWaves(period=1.94, waveHeight=waveheight, seaLevel=1.0, depth=1.0, meanVelocity=0.0, g=9.8) # Discretization -- input options genMesh = True movingDomain = False applyRedistancing = True
# --- Phisical constants rho_0=998.2 nu_0 =1.004e-6 rho_1=1.205 nu_1 =1.500e-5 sigma_01=0.0 g =np.array([0.,-9.8,0.]) gAbs=sqrt(sum(g**2)) waterLevel = opts.water_level # --- WAVE input wave = wt.SteadyCurrent(U=np.array([0.,0.,0.]),mwl=opts.water_level) ####################################################################################################################################################################################################################################################################### # ----- SHAPES ----- # #################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################### L_leftSpo = opts.tank_sponge[0] L_rightSpo = opts.tank_sponge[1] # --- paddle2D dimx = opts.dimx dimy = opts.dimy ctr = opts.center
logEvent("YCOEFFS: "+str(YCoeffs)) with open('Solution.res', 'r') as f: for line in f: if 'Wave period' in line: words = line.split() period = float(words[5])/np.sqrt(9.81/depth) if 'Wave length' in line: words = line.split() wavelength = float(words[5])*depth logEvent("PERIOD: "+str(period)) logEvent("WAVELENGTH: "+str(wavelength)) #getFFT.copyFiles() wave = wt.MonochromaticWaves(period=period, waveHeight=height, mwl=mwl, depth=depth, g=np.array([0., -9.81, 0.]), waveDir=direction, wavelength=wavelength, waveType=opts.wave_type, Ycoeff=YCoeffs, Bcoeff=BCoeffs, Nf=len(BCoeffs), fast=False) wavelength = wave.wavelength # tank options if opts.waves is True: tank_dim = (2*wavelength, opts.water_level*2) tank_sponge = (1*wavelength, 2*wavelength) else: tank_dim = opts.tank_dim tank_sponge = opts.tank_sponge logEvent("TANK SPONGE: "+str(tank_sponge)) logEvent("TANK DIM: "+str(tank_dim))
nnx = (nnx0 - 1) * (2**refinement) + 1 nny = old_div((nnx - 1), 10) + 1 he = old_div(L[0], float(nnx - 1)) triangleOptions = "pAq30Dena%f" % (0.5 * he**2, ) ############################### # Wave tools set up + bath # ############################### h0 = 0.38 # depth / still water level amp = 0.0232 # amplitude of waves / wave height period = 1 # period in seconds wave_dir = (1., 0., 0.) # wave direction g_vec = [0, -9.81, 0] # g vector used for wave tools # define wave here wave = wt.MonochromaticWaves(period, amp, h0, h0, np.array(g_vec), wave_dir, "Fenton") def bathymetry_function(X): slope = 1.0 / 20. x = X[0] bath = 0.5 - 0.2 + 0.0 * x # silly hack because X switches from list to array of # length 3 (x,y,z) when called in initial conditions if (isinstance(X, list)): for counter, value in enumerate(X[0]): if value < 10.0: bath[counter] = np.maximum(slope * value, 0.2) - 0.2 else: if (x <= 10.): bath = np.maximum(slope * x, 0.2) - 0.2
# ____ _ # | _ \ ___ _ __ ___ __ _(_)_ __ # | | | |/ _ \| '_ ` _ \ / _` | | '_ \ # | |_| | (_) | | | | | | (_| | | | | | # |____/ \___/|_| |_| |_|\__,_|_|_| |_| # Domain # All geometrical options go here (but not mesh options) domain = Domain.PiecewiseLinearComplexDomain() SG = st.ShapeSTL(domain, 'Blocks.stl') boundaryTags = SG.boundaryTags current = wt.SteadyCurrent(U=opts.U, mwl=opts.outlet_level, rampTime=opts.rampTime) smoothing = 3. * opts.he nd = domain.nd xTop = max(SG.vertices[:, 1]) SG.BC['Top0'].setAtmosphere(orientation=np.array([0, +1, 0])) SG.BC['Wall0'].setFreeSlip() SG.BC['Bed0'].setFreeSlip() SG.BC['Concrete0'].setFreeSlip() SG.BC['Inlet0'].setUnsteadyTwoPhaseVelocityInlet(wave=current, vert_axis=1, smoothing=3. * opts.he, orientation=np.array(
def test_generation_zones(self): flag = 1 epsFact_solid = 0.5 center = [0.5, 0., 0.] orientation = [1., 0., 0.] dragAlpha = 0.5 / 1.005e-6 dragBeta = 0. porosity = 1. from proteus import WaveTools as wt waves = wt.MonochromaticWaves(period=0.8, waveHeight=0.029, mwl=0.9, depth=0.9, g=np.array([0., -9.81, 0.]), waveDir=np.array([1., 0., 0.])) domain = create_domain2D() # for custom (same principle for rectangle or cuboid) custom = create_custom2D(domain, 'mprans') custom.setGenerationZones(flags=flag, epsFact_solid=epsFact_solid, center=center, orientation=orientation, waves=waves, dragAlpha=dragAlpha, dragBeta=dragBeta, porosity=porosity) npt.assert_equal(custom.auxiliaryVariables['RelaxZones'], custom.zones) zone = custom.zones[flag] npt.assert_equal(zone.zone_type, 'generation') npt.assert_equal(zone.center, center) npt.assert_equal(zone.orientation, orientation) npt.assert_equal(zone.dragAlpha, dragAlpha) npt.assert_equal(zone.dragBeta, dragBeta) npt.assert_equal(zone.porosity, porosity) npt.assert_equal(zone.Shape, custom) # for tanks in 2D tank = create_tank2D(domain, dim=[4., 4.]) tank.setSponge(left=1.5, right=2.) npt.assert_equal(tank.spongeLayers['left'], 1.5) npt.assert_equal(tank.spongeLayers['right'], 2.) tank.setGenerationZones(waves=waves, left=True, right=True) leftzone = tank.zones[tank.regionFlags[ tank.regionIndice['leftSponge']]] rightzone = tank.zones[tank.regionFlags[ tank.regionIndice['rightSponge']]] npt.assert_equal(leftzone.zone_type, 'generation') npt.assert_equal(leftzone.center, [0.75, 2.]) npt.assert_equal(leftzone.orientation, [1., 0.]) npt.assert_equal(leftzone.dragAlpha, dragAlpha) npt.assert_equal(leftzone.dragBeta, dragBeta) npt.assert_equal(leftzone.porosity, porosity) npt.assert_equal(leftzone.Shape, tank) npt.assert_equal(rightzone.zone_type, 'generation') npt.assert_equal(rightzone.center, [3., 2.]) npt.assert_equal(rightzone.orientation, [-1., 0.]) npt.assert_equal(rightzone.dragAlpha, dragAlpha) npt.assert_equal(rightzone.dragBeta, dragBeta) npt.assert_equal(rightzone.porosity, porosity) npt.assert_equal(rightzone.Shape, tank) # for tanks in 3D domain = create_domain3D() tank = create_tank3D(domain, dim=[4., 4., 4.]) tank.setSponge(left=1.5, right=2., front=3., back=0.2) npt.assert_equal(tank.spongeLayers['left'], 1.5) npt.assert_equal(tank.spongeLayers['right'], 2.) npt.assert_equal(tank.spongeLayers['front'], 3) npt.assert_equal(tank.spongeLayers['back'], 0.2) tank.setGenerationZones(waves=waves, left=True, right=True, front=True, back=True) leftzone = tank.zones[tank.regionFlags[tank.regionIndice['left']]] rightzone = tank.zones[tank.regionFlags[tank.regionIndice['right']]] frontzone = tank.zones[tank.regionFlags[tank.regionIndice['front']]] backzone = tank.zones[tank.regionFlags[tank.regionIndice['back']]] npt.assert_equal(leftzone.zone_type, 'generation') npt.assert_equal(leftzone.center, [2., 0.75, 2.]) npt.assert_equal(leftzone.orientation, [0., 1., 0.]) npt.assert_equal(leftzone.dragAlpha, dragAlpha) npt.assert_equal(leftzone.dragBeta, dragBeta) npt.assert_equal(leftzone.porosity, porosity) npt.assert_equal(leftzone.Shape, tank) npt.assert_equal(rightzone.zone_type, 'generation') npt.assert_equal(rightzone.center, [2., 3., 2.]) npt.assert_equal(rightzone.orientation, [0., -1., 0.]) npt.assert_equal(rightzone.dragAlpha, dragAlpha) npt.assert_equal(rightzone.dragBeta, dragBeta) npt.assert_equal(rightzone.porosity, porosity) npt.assert_equal(rightzone.Shape, tank) npt.assert_equal(frontzone.zone_type, 'generation') npt.assert_equal(frontzone.center, [2.5, 2., 2.]) npt.assert_equal(frontzone.orientation, [1., 0., 0.]) npt.assert_equal(frontzone.dragAlpha, dragAlpha) npt.assert_equal(frontzone.dragBeta, dragBeta) npt.assert_equal(frontzone.porosity, porosity) npt.assert_equal(frontzone.Shape, tank) npt.assert_equal(backzone.zone_type, 'generation') npt.assert_equal(np.around(backzone.center, 8), [0.1, 2., 2.]) npt.assert_equal(backzone.orientation, [-1., 0., 0.]) npt.assert_equal(backzone.dragAlpha, dragAlpha) npt.assert_equal(backzone.dragBeta, dragBeta) npt.assert_equal(backzone.porosity, porosity) npt.assert_equal(backzone.Shape, tank)
depth = opts.depth #veg_platform_height + opts.depth inflowHeightMean = depth inflowVelocityMean = (0.0, 0.0, 0.0) period = opts.peak_period omega = 2.0 * math.pi / period waveheight = opts.wave_height amplitude = waveheight / 2.0 wavelength = opts.peak_wavelength k = 2.0 * math.pi / wavelength waveDir = numpy.array([1, 0, 0]) g = numpy.array([0, -9.81, 0]) if opts.wave_type == 'linear': waves = WT.MonochromaticWaves( period=period, # Peak period waveHeight=waveheight, # Height depth=depth, # Depth mwl=inflowHeightMean, # Sea water level waveDir=waveDir, # waveDirection g=g, # Gravity vector, defines the vertical waveType="Linear") elif opts.wave_type == 'Nonlinear': waves = WT.MonochromaticWaves( period=period, # Peak period waveHeight=waveheight, # Height wavelength=wavelength, depth=depth, # Depth mwl=inflowHeightMean, # Sea water level waveDir=waveDir, # waveDirection g=g, # Gravity vector, defines the vertical waveType="Fenton", Ycoeff=[ 0.04160592, #Surface elevation Fourier coefficients for non-dimensionalised solution
# | |_| | (_) | | | | | | (_| | | | | | # |____/ \___/|_| |_| |_|\__,_|_|_| |_| # Domain # All geometrical options go here (but not mesh options) domain = Domain.PiecewiseLinearComplexDomain() # Wave g = np.array([0., -9.81, 0.]) nu_0 = 1.004e-6 period=opts.period wave = wt.MonochromaticWaves(period=period, waveHeight=opts.waveHeight, mwl=opts.mwl, depth=opts.mwl, g=g, waveDir=(1,0,0), waveType='Linear', fast=True) #ShapeSTL SG=st.ShapeSTL(domain,'NWT.stl') boundaryTags= SG.boundaryTags SG.regions=np.array([[-13., 2.5, 0.], [-3., 2.5, 0.], [9., 2.5, 0.]] SG.regionFlags=np.array([1, 2, 3]) dragAlpha = 5*(2*np.pi/period)/nu_0 smoothing = 3. * opts.he nd = domain.nd
nu_1=nu_0#1.500e-5 sigma_01=0.0 g =np.array([0.,-9.8,0.]) gAbs=sqrt(sum(g**2)) # ----- WAVE input ----- # if opts.wave == True: waveinput = wt.MonochromaticWaves(period=period, waveHeight=waveHeight, mwl=mwl, depth=waterLevel, g=g, waveDir=waveDir, wavelength=opts.wavelength, # used by fenton waves waveType=opts.waveType, Ycoeff=np.array(opts.Ycoeff), # used by fenton waves Bcoeff=np.array(opts.Bcoeff), # used by fenton waves Nf=opts.Nf, # used by fenton waves meanVelocity = np.array(opts.meanVelocity), phi0 = opts.phi0, ) #---------Domain Dimension nd = 2. wl=opts.wl #---------MESH SIZE if opts.he == 0.0: he = wl/opts.refinement_level
#wave generator windVelocity = (0.0,0.0) inflowHeightMean = 1.0 inflowVelocityMean = (0.0,0.0) period = 1.94 omega = 2.0*math.pi/period waveheight = 0.1 amplitude = waveheight/ 2.0 wavelength = 5.0 k = 2.0*math.pi/wavelength waves = WaveTools.RandomWaves(Tp = 1.94, Hs = 0.1, d = 1.0, fp = 1.0/1.94, bandFactor = 2.0, N = 101, mwl = 1.0, g = 9.8)#shouldn't mwl = d always? # Discretization -- input options genMesh=True movingDomain=False applyRedistancing=True useOldPETSc=False useSuperlu=False timeDiscretization='be'#'be','vbdf','flcbdf' spaceOrder = 1 useHex = False useRBLES = 0.0 useMetrics = 1.0
np.random.seed(opts.seed) if opts.RandomWaves == True: phi = 2 * np.pi * np.random.rand(opts.N) Tend = opts.Ntotalwaves * opts.Tp / 1.1 wave = wt.RandomWavesFast(Tstart=opts.Tstart, Tend=Tend, x0=opts.x0, Tp=opts.Tp, Hs=opts.Hs, mwl=opts.mwl, depth=opts.depth, waveDir=opts.waveDir, g=opts.g, N=opts.N, bandFactor=opts.bandFactor, spectName=opts.spectName, spectral_params=opts.spectral_params, phi=phi, Lgen=opts.Lgen, Nwaves=opts.Nwaves, Nfreq=opts.Nfreq, checkAcc=True, fast=True) Duration = Tend wave_length = wave.wavelength else: wave = wt.NewWave(Tp=opts.Tp,
windVelocity = (0.0, 0.0) depth = 1.0 inflowHeightMean = 1.0 inflowVelocityMean = (0.0, 0.0) period = 1.33 waveheight = 0.062 amplitude = waveheight / 2.0 wavelength = 2.77 waveDir = numpy.array([1, 0, 0]) g = numpy.array([0, -9.81, 0]) waves = WT.RandomWaves( Tp=period, # Peak period Hs=waveheight, # Height d=depth, # Depth fp=1. / period, #peak Frequency bandFactor=2.0, #fmin=fp/Bandfactor, fmax = Bandfactor * fp N=101, #No of frequencies for signal reconstruction mwl=inflowHeightMean, # Sea water level waveDir=waveDir, # waveDirection g=g, # Gravity vector, defines the vertical gamma=1.0, #Pierson Moskowitz spectum for gamma=1.0 spec_fun=WT.JONSWAP) # Discretization -- input options genMesh = True movingDomain = False applyRedistancing = True useOldPETSc = False useSuperlu = False timeDiscretization = 'be' #'vbdf'#'be','flcbdf' spaceOrder = 1 useHex = False
regionFlags=regionFlags, boundaryTags=boundaryTags, boundaryOrientations=boundaryOrientations) tank.BC['top'].setAtmosphere() #tank.BC['top'].setFreeSlip() tank.BC['bottom'].setFreeSlip() tank.BC['gate'].setFreeSlip() tank.BC['front'].setFreeSlip() tank.BC['back'].setFreeSlip() #tank.BC['left'].setFreeSlip() tank.BC['right'].setFreeSlip() wave = wt.MonochromaticWaves(period=1.0, waveHeight=0.5, mwl=waterLevel, depth=waterLevel, g=g, waveDir=np.array([1.0, 0., 0.])) tank.BC['left'].setUnsteadyTwoPhaseVelocityInlet(wave, smoothing=3. * he) domain.MeshOptions.setParallelPartitioningType('node') domain.boundaryTags = boundaryTags he = opts.he domain.MeshOptions.he = he st.assembleDomain(domain) domain.MeshOptions.triangleOptions = "VApq1.25q12feena%e" % ((he**3) / 6.0, ) domain.writePLY("mesh") #domain.readPoly("SG") domain.writePoly("mesh") domain.writeAsymptote("mesh")
omega = 1. dragAlpha = 5. * omega / nu_0 tank.setSponge(x_n=opts.tank_sponge[0], x_p=opts.tank_sponge[1]) tank.setAbsorptionZones(x_n=True, dragAlpha=dragAlpha) tank.setAbsorptionZones(x_p=True, dragAlpha=dragAlpha) if opts.waves: # TODO: for now this is an actual wave, which we don't want. We want a placid # wave such that our generation and absorption zones enforce a steady flow. omega = 2 * np.pi / 2. dragAlpha = 5. * omega / nu_0 wave = wt.MonochromaticWaves(period=2, waveHeight=0.0, mwl=inflow_level, depth=inflow_level, g=np.array(g), waveDir=(1., 0., 0.), wavelength=0.5, meanVelocity=np.array( [inflow_velocity, 0., 0.])) tank.setSponge(x_n=opts.tank_sponge[0], x_p=opts.tank_sponge[1]) tank.setGenerationZones(x_n=True, waves=wave, dragAlpha=dragAlpha, smoothing=3. * he) tank.setAbsorptionZones(x_p=True, dragAlpha=dragAlpha) # ----- VARIABLE REFINEMENT ----- # if opts.variable_refine_borders or opts.variable_refine_levels: refinement_borders = opts.variable_refine_borders
# ----- CONTEXT ------ # # waves omega = 1. if opts.waves is True: period = opts.wave_period omega = 2 * np.pi / opts.wave_period height = opts.wave_height mwl = depth = opts.water_level direction = opts.wave_dir wave = wt.MonochromaticWaves(period=period, waveHeight=height, mwl=mwl, depth=depth, g=np.array(opts.g), waveDir=direction, wavelength=opts.wave_wavelength, waveType=opts.wave_type, Ycoeff=np.array(opts.Ycoeff), Bcoeff=np.array(opts.Bcoeff), Nf=len(opts.Bcoeff), fast=opts.fast) wavelength = wave.wavelength # tank options waterLevel = opts.water_level tank_dim = opts.tank_dim tank_sponge = opts.tank_sponge # ----- DOMAIN ----- # domain = Domain.PlanarStraightLineGraphDomain()
0.00014869, 0.00002212, -0.00000001), (0.06029399, 0.02131785, 0.00866053, 0.00357527, 0.00145114, 0.00057285, 0.00023282, 0.00006823)] ifo = -1 ## Reading probes into the file for folder in folders: ifo += 1 os.chdir(folder) file_vof = 'column_gauges.csv' wave = wt.MonochromaticWaves(period=period[ifo], waveHeight=height[ifo], mwl=0.4, depth=0.4, g=np.array([0., -9.81, 0.]), waveDir=np.array([1., 0., 0.]), wavelength=wavelength[ifo], waveType="Fenton", Ycoeff=np.array(Ycoeff[ifo]), Bcoeff=np.array(Bcoeff[ifo]), Nf=len(Ycoeff[ifo]), fast=True) def readProbeFile(filename): with open(filename, 'rb') as csvfile: data = np.loadtxt(csvfile, delimiter=",", skiprows=1) time = data[:, 0] data = data[:, 1:] csvfile.seek(0) header = csvfile.readline() header = header.replace("time", "") header = header.replace("[", "")
def test_generation_zones(self): flag = 1 epsFact_solid = 0.5 center = [0.5, 0., 0.] orientation = [1., 0., 0.] dragAlpha = old_div(0.5, 1.005e-6) dragBeta = 0. porosity = 1. from proteus import WaveTools as wt waves = wt.MonochromaticWaves(period=0.8, waveHeight=0.029, mwl=0.9, depth=0.9, g=np.array([0., -9.81, 0.]), waveDir=np.array([1., 0., 0.])) domain = create_domain2D() # for custom (same principle for rectangle or cuboid or STL) custom = create_custom2D(domain, 'mprans') custom.setGenerationZones(flags=flag, epsFact_solid=epsFact_solid, center=center, orientation=orientation, vert_axis=0, waves=waves, dragAlpha=dragAlpha, dragBeta=dragBeta, porosity=porosity) npt.assert_equal(custom.auxiliaryVariables['RelaxZones'], custom.zones) zone = custom.zones[flag] npt.assert_equal(zone.zone_type, 'generation') npt.assert_equal(zone.center[0], center[0]) npt.assert_equal(zone.center[1], center[1]) npt.assert_equal(zone.center[2], center[2]) npt.assert_equal(zone.orientation[0], orientation[0]) npt.assert_equal(zone.orientation[1], orientation[1]) npt.assert_equal(zone.orientation[2], orientation[2]) npt.assert_equal(zone.dragAlpha, dragAlpha) npt.assert_equal(zone.dragBeta, dragBeta) npt.assert_equal(zone.porosity, porosity) npt.assert_equal(zone.Shape, custom) npt.assert_equal(zone.vert_axis, 0) # for tanks in 2D tank = create_tank2D(domain, dim=[4., 4.]) tank.setSponge(x_n=1.5, x_p=2.) npt.assert_equal(tank.spongeLayers['x-'], 1.5) npt.assert_equal(tank.spongeLayers['x+'], 2.) tank.setGenerationZones(dragAlpha, smoothing=0., waves=waves, x_n=True, x_p=True) leftzone = tank.zones[tank.regionFlags[tank.regionIndice['x-']]] rightzone = tank.zones[tank.regionFlags[tank.regionIndice['x+']]] npt.assert_equal(leftzone.zone_type, 'generation') npt.assert_equal(leftzone.center[0], -0.75) npt.assert_equal(leftzone.center[1], 2.) npt.assert_equal(leftzone.orientation[0], 1.) npt.assert_equal(leftzone.orientation[1], 0.) npt.assert_equal(leftzone.dragAlpha, dragAlpha) npt.assert_equal(leftzone.dragBeta, dragBeta) npt.assert_equal(leftzone.porosity, porosity) npt.assert_equal(leftzone.Shape, tank) npt.assert_equal(rightzone.zone_type, 'generation') npt.assert_equal(rightzone.center[0], 5.) npt.assert_equal(rightzone.center[1], 2.) npt.assert_equal(rightzone.orientation[0], -1.) npt.assert_equal(rightzone.orientation[1], 0.) npt.assert_equal(rightzone.dragAlpha, dragAlpha) npt.assert_equal(rightzone.dragBeta, dragBeta) npt.assert_equal(rightzone.porosity, porosity) npt.assert_equal(rightzone.Shape, tank) # test translation tank = create_tank2D(domain, dim=[4., 4.]) tank.setSponge(x_n=1.5, x_p=2.) tr_val = np.array([1.1, 1.2]) tank.translate(tr_val) npt.assert_equal(tank.spongeLayers['x-'], 1.5) npt.assert_equal(tank.spongeLayers['x+'], 2.) tank.setGenerationZones(dragAlpha, smoothing=0., waves=waves, x_n=True, x_p=True) leftzone = tank.zones[tank.regionFlags[tank.regionIndice['x-']]] rightzone = tank.zones[tank.regionFlags[tank.regionIndice['x+']]] npt.assert_equal(leftzone.zone_type, 'generation') npt.assert_equal(leftzone.center[0], -0.75 + tr_val[0]) npt.assert_equal(leftzone.center[1], 2. + tr_val[1]) npt.assert_equal(leftzone.orientation[0], 1.) npt.assert_equal(leftzone.orientation[1], 0.) npt.assert_equal(leftzone.dragAlpha, dragAlpha) npt.assert_equal(leftzone.dragBeta, dragBeta) npt.assert_equal(leftzone.porosity, porosity) npt.assert_equal(leftzone.Shape, tank) npt.assert_equal(rightzone.zone_type, 'generation') npt.assert_equal(rightzone.center[0], 5. + tr_val[0]) npt.assert_equal(rightzone.center[1], 2. + tr_val[1]) npt.assert_equal(rightzone.orientation[0], -1.) npt.assert_equal(rightzone.orientation[1], 0.) npt.assert_equal(rightzone.dragAlpha, dragAlpha) npt.assert_equal(rightzone.dragBeta, dragBeta) npt.assert_equal(rightzone.porosity, porosity) npt.assert_equal(rightzone.Shape, tank) # for tanks in 3D domain = create_domain3D() tank = create_tank3D(domain, dim=[4., 4., 4.]) tank.setSponge(x_n=1.5, x_p=2., y_n=3., y_p=0.2) npt.assert_equal(tank.spongeLayers['x-'], 1.5) npt.assert_equal(tank.spongeLayers['x+'], 2.) npt.assert_equal(tank.spongeLayers['y-'], 3) npt.assert_equal(tank.spongeLayers['y+'], 0.2) tank.setGenerationZones(dragAlpha, smoothing=0., waves=waves, x_n=True, x_p=True, y_n=True, y_p=True) leftzone = tank.zones[tank.regionFlags[tank.regionIndice['x-']]] rightzone = tank.zones[tank.regionFlags[tank.regionIndice['x+']]] frontzone = tank.zones[tank.regionFlags[tank.regionIndice['y-']]] backzone = tank.zones[tank.regionFlags[tank.regionIndice['y+']]] npt.assert_equal(leftzone.zone_type, 'generation') npt.assert_equal(leftzone.center[0], -0.75) npt.assert_equal(leftzone.center[1], 2.) npt.assert_equal(leftzone.center[2], 2.) npt.assert_equal(leftzone.orientation[0], 1.) npt.assert_equal(leftzone.orientation[1], 0.) npt.assert_equal(leftzone.orientation[2], 0.) npt.assert_equal(leftzone.dragAlpha, dragAlpha) npt.assert_equal(leftzone.dragBeta, dragBeta) npt.assert_equal(leftzone.porosity, porosity) npt.assert_equal(leftzone.Shape, tank) npt.assert_equal(rightzone.zone_type, 'generation') npt.assert_equal(rightzone.center[0], 5.) npt.assert_equal(rightzone.center[1], 2.) npt.assert_equal(rightzone.center[2], 2.) npt.assert_equal(rightzone.orientation[0], -1.) npt.assert_equal(rightzone.orientation[1], 0.) npt.assert_equal(rightzone.orientation[2], 0.) npt.assert_equal(rightzone.dragAlpha, dragAlpha) npt.assert_equal(rightzone.dragBeta, dragBeta) npt.assert_equal(rightzone.porosity, porosity) npt.assert_equal(rightzone.Shape, tank) npt.assert_equal(frontzone.zone_type, 'generation') npt.assert_equal(frontzone.center[0], 2.) npt.assert_equal(frontzone.center[1], -1.5) npt.assert_equal(frontzone.center[2], 2.) npt.assert_equal(frontzone.orientation[0], 0.) npt.assert_equal(frontzone.orientation[1], 1.) npt.assert_equal(frontzone.orientation[2], 0.) npt.assert_equal(frontzone.dragAlpha, dragAlpha) npt.assert_equal(frontzone.dragBeta, dragBeta) npt.assert_equal(frontzone.porosity, porosity) npt.assert_equal(frontzone.Shape, tank) npt.assert_equal(backzone.zone_type, 'generation') npt.assert_equal(backzone.center[0], 2.) npt.assert_equal(backzone.center[1], 4.1) npt.assert_equal(backzone.center[2], 2.) npt.assert_equal(backzone.orientation[0], 0.) npt.assert_equal(backzone.orientation[1], -1.) npt.assert_equal(backzone.orientation[2], 0.) npt.assert_equal(backzone.dragAlpha, dragAlpha) npt.assert_equal(backzone.dragBeta, dragBeta) npt.assert_equal(backzone.porosity, porosity) npt.assert_equal(backzone.Shape, tank)
nnx = nny = nnz = None wl = opts.wl a = opts.wave_height k = ((3 * a) / (4 * (opts.wl**3)))**0.5 L = (2 / k) * np.arccosh(0.05**(-0.5)) x0 = (-opts.wl / opts.slope) - (L / 2) + 35 #shifted if opts.waves is True: height = opts.wave_height mwl = depth = opts.wl direction = opts.wave_dir wave = wt.SolitaryWave(waveHeight=height, mwl=wl, depth=depth, g=np.array(opts.g), waveDir=direction, trans=np.array([x0, 0., 0.]), fast=opts.fast) # *************************** # # ***** DOMAIN AND MESH ***** # # ****************** #******* # domain = Domain.PlanarStraightLineGraphDomain() nLevels = 1 nLayersOfOverlapForParallel = 0 boundaries = ['left', 'right', 'bottom', 'slope', 'top'] boundaryOrientations = { 'bottom': np.array([0., -1., 0.]),
# body options fixed = False # wave options water_level = 0.515 wave_period = 0.87 wave_height = 0.05 wave_direction = np.array([1., 0., 0.]) wave_type = 'Fenton' #'Linear' # number of Fourier coefficients Nf = 8 wave = wt.MonochromaticWaves(period=wave_period, waveHeight=wave_height, mwl=water_level, depth=water_level, g=g, waveDir=wave_direction, waveType=wave_type, Nf=8) wavelength = wave.wavelength # ____ _ # | _ \ ___ _ __ ___ __ _(_)_ __ # | | | |/ _ \| '_ ` _ \ / _` | | '_ \ # | |_| | (_) | | | | | | (_| | | | | | # |____/ \___/|_| |_| |_|\__,_|_|_| |_| # Domain # All geometrical options go here (but not mesh options) domain = Domain.PlanarStraightLineGraphDomain()
################ Random Waves Class ################ np.random.seed(opts.seed) phi = 2 * np.pi * np.random.rand(opts.N) Tend = opts.Ntotalwaves * opts.Tp / 1.1 wave = wt.RandomWavesFast(Tstart=opts.Tstart, Tend=Tend, x0=opts.x0, Tp=opts.Tp, Hs=opts.Hs, mwl=opts.mwl, depth=opts.depth, waveDir=opts.waveDir, g=opts.g, N=opts.N, bandFactor=opts.bandFactor, spectName=opts.spectName, spectral_params=opts.spectral_params, phi=phi, Lgen=opts.Lgen, Nwaves=opts.Nwaves, Nfreq=opts.Nfreq, checkAcc=True, fast=True) # Wave length calculation wave_length = wave.wavelength # Tank Dimensions
def signalFilter(time, data, minfreq, maxfreq, costapCut=False): dt = old_div((time[-1] - time[0]), (len(time) - 1)) doInterp = False data1 = np.zeros(data.shape, ) for i in range(1, len(time)): dt_temp = time[i] - time[i - 1] if dt_temp != dt: doInterp = True if (doInterp): print("Interpolating series") time_lin = np.linspace(time[0], time[-1], len(time)) try: for ii in range(nprobes): data1[:, ii] = np.interp(time_lin, time, data[:, ii]) time = time_lin data = data1 nprobes = len(data[0, :]) except: data1 = np.interp(time_lin, time, data[:]) time = time_lin data = data1 nprobes = -1 nfft = len(time) dt = old_div((time[-1] - time[0]), (len(time) - 1)) freq = np.fft.fftfreq(nfft, dt) i1 = np.where(freq > maxfreq)[0] i3 = np.where(freq < -maxfreq)[0] i2a = [] i2b = [] for jj in range(1, len(freq)): if (freq[jj] < minfreq and freq[jj] > 0): i2a.append(jj) if (freq[jj] > -minfreq and freq[jj] < 0): i2b.append(jj) band1 = min(i1) - max(i2a) band2 = min(i2b) - max(i3) del data1 data1 = np.zeros(data.shape) fft_x = None for ii in range(max(nprobes, 1)): if (nprobes == -1): fft_x = np.fft.fft(data[:], nfft) fft_x[i1] = 0. fft_x[i2a] = 0. fft_x[i2b] = 0. fft_x[i3] = 0. if (costapCut): fft_x[max(i2a):min(i1)] *= WT.costap(band1, 0.1) fft_x[max(i3):min(i2b)] *= WT.costap(band2, 0.1) data1[:] = np.fft.ifft(fft_x) else: fft_x = np.fft.fft(data[:, ii], nfft) fft_x[i1, ii] = 0. fft_x[i2a, ii] = 0. fft_x[i2b, ii] = 0. fft_x[i3, ii] = 0. if (costapCut): fft_x[max(i2a):min(i1), ii] *= WT.costap(band1, 0.1) fft_x[max(i3):min(i2b), ii] *= WT.costap(band2, 0.1) data1[:, ii] = np.fft.ifft(fft_x) return data1
("ecH", 3, "Smoothing Coefficient"), #("Nf",8,"Fenton Fourier COmponents"), ("Np", 15, " Output points per period Tp/Np") ]) # Domain tank_dim = opts.tank_dim domain = Domain.PlanarStraightLineGraphDomain() #Generation/ Absorption Lgen = np.array([opts.tank_sponge[0], 0., 0.]) # Wave Input wave = wt.MonochromaticWaves(period=opts.T, waveHeight=opts.wave_height, mwl=opts.mwl, depth=opts.depth, g=opts.g, waveDir=opts.waveDir) tank = st.Tank2D(domain, tank_dim) # Sponge tank_sponge = opts.tank_sponge tank.setSponge(x_n=opts.tank_sponge[0], x_p=None) # Mesh Refinement he = opts.wave_length / opts.refinement_level ecH = opts.ecH smoothing = ecH * he