# --- 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
