def create_fresh_dvgeo():
# The Plot3D file ffdbox.xyz contains the coordinates of the free-form deformation (FFD) volume
# The "i" direction of the cube consists of 10 points along the x (streamwise) axis
# The "j" direction of the cube is 2 points up and down (y axis direction)
# The "k" direction of the cube is 8 along the span (z axis direction)
FFDfile = "ffdbox.xyz"
# initialize the DVGeometry object with the FFD file
DVGeo = DVGeometry(FFDfile)
stlmesh = mesh.Mesh.from_file("baseline_wing.stl")
# create a pointset. pointsets are of shape npts by 3 (the second dim is xyz coordinate)
# already have the wing mesh as a triangulated surface (stl file)
# each vertex set is its own pointset, so we actually add three pointsets
DVGeo.addPointSet(stlmesh.v0, "mesh_v0")
DVGeo.addPointSet(stlmesh.v1, "mesh_v1")
DVGeo.addPointSet(stlmesh.v2, "mesh_v2")
return DVGeo, stlmesh
def setup_blocks(self, testID, isComplex=False):
# Make tiny FFD
ffd_name = '../inputFiles/tiny_cube_{:02d}.xyz'.format(testID)
file_name = os.path.join(self.base_path, ffd_name)
self.make_cube_ffd(file_name, 1, 1, 1, 1, 1, 1)
tiny = DVGeometry(file_name, child=True, complex=isComplex)
os.remove(file_name)
tiny.addRefAxis('ref', xFraction=0.5, alignIndex='j', rotType=7)
# Make tiny FFD
ffd_name = '../inputFiles/small_cube_{:02d}.xyz'.format(testID)
file_name = os.path.join(self.base_path, ffd_name)
self.make_cube_ffd(file_name, 0, 0, 0, 2, 2, 2)
small = DVGeometry(file_name, child=True, complex=isComplex)
os.remove(file_name)
small.addRefAxis('ref', xFraction=0.5, alignIndex='j')
# Make big FFD
ffd_name = '../inputFiles/big_cube_{:02d}.xyz'.format(testID)
file_name = os.path.join(self.base_path, ffd_name)
self.make_cube_ffd(file_name, 0, 0, 0, 3, 3, 3)
big = DVGeometry(file_name, complex=isComplex)
os.remove(file_name)
big.addRefAxis('ref', xFraction=0.5, alignIndex='i')
big.addChild(small)
small.addChild(tiny)
# Add point set
points = numpy.array([
[0.5, 0.5, 0.5],
[1.25, 1.25, 1.25],
[1.5, 1.5, 1.5],
[2.0, 2.5, 0.5],
])
big.addPointSet(points, 'X')
return big, small, tiny
def test_parent_shape_child_rot(self, train=False, refDeriv=False):
ffd_name = '../../tests/inputFiles/small_cube.xyz'
self.make_cube_ffd(ffd_name, 0.1, 0.1, 0.1, 0.8, 0.8, 0.8)
small = DVGeometry(ffd_name, child=True)
small.addRefAxis('ref', xFraction=0.5, alignIndex='j')
x0 = 0.0
y0 = 0.0
z0 = 0.0
dx = 1.0
dy = 1.0
dz = 1.0
axes = ['k', 'j', 'i']
slices = numpy.array(
# Slice 1
[
[[[x0, y0, z0], [x0 + dx, y0, z0], [x0 + 2 * dx, y0, z0]],
[[x0, y0 + dy, z0], [x0 + dx, y0 + dy, z0],
[x0 + 2 * dx, y0 + dy, z0]]],
# Slice 2
[[[x0, y0, z0 + dz], [x0 + dx, y0, z0 + dz],
[x0 + 2 * dx, y0, z0 + dz]],
[[x0, y0 + dy, z0 + dz], [x0 + dx, y0 + dy, z0 + dz],
[x0 + 2 * dx, y0 + dy, z0 + dz]]]
],
dtype='d')
N0 = [2]
N1 = [2]
N2 = [3]
ffd_name = '../../tests/inputFiles/big_cube.xyz'
geo_utils.write_wing_FFD_file(ffd_name, slices, N0, N1, N2, axes=axes)
big = DVGeometry(ffd_name)
big.addRefAxis('ref', xFraction=0.5, alignIndex='j')
big.addChild(small)
# Add point set
points = numpy.array([[0.5, 0.5, 0.5]])
big.addPointSet(points, 'X')
# Add only translation variables
add_vars(big, 'big', local='z', rotate='y')
add_vars(small, 'small', rotate='y')
ang = 45
ang_r = numpy.deg2rad(ang)
# Modify design variables
x = big.getValues()
# add a local shape change
x['local_z_big'] = numpy.array(
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.5, 0.5])
big.setDesignVars(x)
Xs = big.update('X')
# add a rotation of the child FFD
x['rotate_y_small'] = ang
big.setDesignVars(x)
Xrot_ffd = big.update('X')
# the modification caused by the child FFD should be the same as rotating the deformed point of the parent
# (you would think)
rot_mat = numpy.array([[numpy.cos(ang_r), 0,
numpy.sin(ang_r)], [0, 1, 0],
[-numpy.sin(ang_r), 0,
numpy.cos(ang_r)]])
Xrot = numpy.dot(rot_mat, (Xs - points).T) + points.T
numpy.testing.assert_array_almost_equal(Xrot_ffd.T, Xrot)
#rst Add local dvs
# Comment out one or the other
DVGeo.addGeoDVLocal('local', lower=-0.5, upper=0.5, axis='y', scale=1)
DVGeo.addGeoDVSectionLocal('slocal',
secIndex='k',
axis=1,
lower=-0.5,
upper=0.5,
scale=1)
#rst Embed points
gridFile = 'wing_vol.cgns'
meshOptions = {'gridFile': gridFile}
mesh = USMesh(options=meshOptions)
coords = mesh.getSurfaceCoordinates()
DVGeo.addPointSet(coords, 'coords')
#rst Change dvs
dvDict = DVGeo.getValues()
dvDict['twist'] = numpy.linspace(0, 50, nRefAxPts)[1:]
dvDict['dihedral'] = numpy.linspace(0, 3, nRefAxPts)[1:]
dvDict['taper'] = numpy.array([1.2, 0.5])
dvDict['slocal'][::5] = 0.5
DVGeo.setDesignVars(dvDict)
#rst Update
DVGeo.update('coords')
DVGeo.writePlot3d('ffd_deformed.xyz')
DVGeo.writePointSet('coords', 'surf')
# lowerL = [-1.,-1.,-1.,-1.]
# upperL = [2.0,2.0,2.0,2.0]
# DVGeoChild.addGeoDVGlobal('noseLen', x1, noseLength,
# lower=lowerL, upper=upperL, scale=1.0)
# DVGeo.addGeoDVGlobal('angleVars', z1, angleVars,
# lower=lowerA, upper=upperA, scale=1.0)
# Add the child to the parent
DVGeo.addChild(DVGeoChild)
ptSetName = "allSurfs"
freezeDict = {
} # '0':['jLow'],'1':['jLow'],'2':['jLow']}#'0':['jLow'],'1':['jHigh','jLow']}
DVGeo.addPointSet(coords0, ptSetName, faceFreeze=freezeDict)
xDV = DVGeo.getValues()
# Required design variables
# Rear ramp angle, fixed 200 mm length
# overall length
# nose length
# Ramp shape
# Ground separation
# Lower ramp angle
# Case 1: Rear Ramp angle, fixed length
# Case 2: Upper and lower ramp angles, fixed length
# Case 3: Nose length ( Do with global FFD)
# Case 4: Overall length ( Do with global FFD)
# Case 5: Shape
# Set the chord as well
geo.scale["wing"].coef[-1] = val[3]
coords = hyp.getSurfaceCoordinates()
DVGeo = DVGeometry(ffdFile)
coef = DVGeo.FFD.vols[0].coef.copy()
# First determine the reference chord lengths:
nSpan = coef.shape[2]
ref = numpy.zeros((nSpan, 3))
for k in range(nSpan):
max_x = numpy.max(coef[:, :, k, 0])
min_x = numpy.min(coef[:, :, k, 0])
ref[k, 0] = min_x + 0.25 * (max_x - min_x)
ref[k, 1] = numpy.average(coef[:, :, k, 1])
ref[k, 2] = numpy.average(coef[:, :, k, 2])
c0 = Curve(X=ref, k=2)
DVGeo.addRefAxis("wing", c0)
DVGeo.addGlobalDV("winglet", [0, 0, 0, 1], winglet, lower=-5, upper=5)
DVGeo.addPointSet(coords, "coords")
DVGeo.setDesignVars({"winglet": [1.5, 2.5, -2.0, 0.60]})
hyp.setSurfaceCoordinates(DVGeo.update("coords"))
# Run and write grid
hyp.run()
hyp.writeCGNS(volumeFile)
Xpt[100:, 2] = 1.0
# rst create DVGeo
# The Plot3D file ffdbox.xyz contains the coordinates of the free-form deformation (FFD)volume
# we will be using for this problem. It's a cube with sides of length 1 centered on (0, 0,0.5).
# The "i" direction of the cube consists of 10 points along the x axis
# The "j" direction of the cube is 2 points up and down (y axis direction)
# The "k" direction of the cube is 2 points into the page (z axis direction)
FFDfile = "ffdbox.xyz"
# initialize the DVGeometry object with the FFD file
DVGeo = DVGeometry(FFDfile)
# rst add pointset
# add the cylinder pointset to the FFD under the name 'cylinder'
DVGeo.addPointSet(Xpt.copy(), "cylinder")
DVGeo.writePointSet("cylinder", "pointset")
# rst add shape DV
# Now that we have pointsets added, we should parameterize the geometry.
# Adding local geometric design to make local modifications to FFD box
# This option will perturb all the control points but only the y (up-down) direction
DVGeo.addLocalDV("shape", lower=-0.5, upper=0.5, axis="y", scale=1.0)
# rst getLocalIndex
# The control points of the FFD are the same as the coordinates of the points in the input file
# but they will be in a jumbled order because of the internal spline representation of the volume.
# Let's put them in a sensible order for plotting.
# the raw array of FFD control points (size n_control_pts x 3)
def test_parent_shape_child_rot(self, train=False, refDeriv=False):
ffd_name = "../../input_files/small_cube.xyz"
self.make_cube_ffd(ffd_name, 0.1, 0.1, 0.1, 0.8, 0.8, 0.8)
small = DVGeometry(ffd_name, child=True)
small.addRefAxis("ref", xFraction=0.5, alignIndex="j")
x0 = 0.0
y0 = 0.0
z0 = 0.0
dx = 1.0
dy = 1.0
dz = 1.0
axes = ["k", "j", "i"]
slices = np.array(
# Slice 1
[
[
[[x0, y0, z0], [x0 + dx, y0, z0], [x0 + 2 * dx, y0, z0]],
[[x0, y0 + dy, z0], [x0 + dx, y0 + dy, z0],
[x0 + 2 * dx, y0 + dy, z0]],
],
# Slice 2
[
[[x0, y0, z0 + dz], [x0 + dx, y0, z0 + dz],
[x0 + 2 * dx, y0, z0 + dz]],
[[x0, y0 + dy, z0 + dz], [x0 + dx, y0 + dy, z0 + dz],
[x0 + 2 * dx, y0 + dy, z0 + dz]],
],
],
dtype="d",
)
N0 = [2]
N1 = [2]
N2 = [3]
ffd_name = "../../input_files/big_cube.xyz"
geo_utils.write_wing_FFD_file(ffd_name, slices, N0, N1, N2, axes=axes)
big = DVGeometry(ffd_name)
big.addRefAxis("ref", xFraction=0.5, alignIndex="j")
big.addChild(small)
# Add point set
points = np.array([[0.5, 0.5, 0.5]])
big.addPointSet(points, "X")
# Add only translation variables
add_vars(big, "big", local="z", rotate="y")
add_vars(small, "small", rotate="y")
ang = 45
ang_r = np.deg2rad(ang)
# Modify design variables
x = big.getValues()
# add a local shape change
x["local_z_big"] = np.array(
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.5, 0.5])
big.setDesignVars(x)
Xs = big.update("X")
# add a rotation of the child FFD
x["rotate_y_small"] = ang
big.setDesignVars(x)
Xrot_ffd = big.update("X")
# the modification caused by the child FFD should be the same as rotating the deformed point of the parent
# (you would think)
rot_mat = np.array([[np.cos(ang_r), 0, np.sin(ang_r)], [0, 1, 0],
[-np.sin(ang_r), 0,
np.cos(ang_r)]])
Xrot = np.dot(rot_mat, (Xs - points).T) + points.T
np.testing.assert_array_almost_equal(Xrot_ffd.T, Xrot)
