def setup(self): options = self.options horiz_tail_name = options['horiz_tail_name'] vert_tail_name = options['vert_tail_name'] wing_name = options['wing_name'] reduced = options['reduced'] # Read the geometry. vsp_file = 'eCRM-001.1_wing_tail.vsp3' vsp.ReadVSPFile(vsp_file) self.wing_id = vsp.FindGeomsWithName(wing_name)[0] self.horiz_tail_id = vsp.FindGeomsWithName(horiz_tail_name)[0] self.vert_tail_id = vsp.FindGeomsWithName(vert_tail_name)[0] self.add_input( 'wing_cord', val=59.05128, ) self.add_input('vert_tail_area', val=2295.) self.add_input('horiz_tail_area', val=6336.) # Shapes are pre-determined. if reduced: self.add_output('wing_mesh', shape=(6, 9, 3), units='inch') self.add_output('vert_tail_mesh', shape=(5, 5, 3), units='inch') self.add_output('horiz_tail_mesh', shape=(5, 5, 3), units='inch') else: # Note: at present, OAS can't handle this size. self.add_output('wing_mesh', shape=(23, 33, 3), units='inch') self.add_output('vert_tail_mesh', shape=(33, 9, 3), units='inch') self.add_output('horiz_tail_mesh', shape=(33, 9, 3), units='inch') self.declare_partials(of='*', wrt='*', method='fd')
def __init__(self, fileName, comm=MPI.COMM_WORLD, scale=1.0, comps=[], projTol=0.01): if comm.rank == 0: print("Initializing DVGeometryVSP") t0 = time.time() super().__init__(fileName=fileName, comm=comm, scale=scale, projTol=projTol) self.exportComps = [] # Clear the vsp model openvsp.ClearVSPModel() t1 = time.time() # read the model openvsp.ReadVSPFile(fileName) t2 = time.time() if self.comm.rank == 0: print("Loading the vsp model took:", (t2 - t1)) # List of all componets returned from VSP. Note that this # order is important. It is the order that we use to map the # actual geom_id by using the geom_names allComps = openvsp.FindGeoms() allNames = [] for c in allComps: allNames.append(openvsp.GetContainerName(c)) if not comps: # no components specified, we use all self.allComps = allComps[:] else: # we get the vsp comp IDs from the comps list self.allComps = [] for c in comps: self.allComps.append(allComps[allNames.index(c)]) # we need the names and bounding boxes of components self.compNames = [] self.bbox = OrderedDict() self.bboxuv = self._getuv() for c in self.allComps: self.compNames.append(openvsp.GetContainerName(c)) self.bbox[c] = self._getBBox(c) # Now, we need to form our own quad meshes for fast projections if comm.rank == 0: print("Building a quad mesh for fast projections.") self._getQuads() if comm.rank == 0: t3 = time.time() print("Initialized DVGeometry VSP in", (t3 - t0), "seconds.")
def __init__(self, horiz_tail_name, vert_tail_name, wing_name): super().__init__() self.horiz_tail_name = horiz_tail_name self.vert_tail_name = vert_tail_name self.wing_name = wing_name # Read the geometry. vsp_file = 'eCRM-001.1_wing_tail.vsp3' vsp.ReadVSPFile(vsp_file) self.wing_id = vsp.FindGeomsWithName(self.wing_name)[0] self.horiz_tail_id = vsp.FindGeomsWithName(self.horiz_tail_name)[0] self.vert_tail_id = vsp.FindGeomsWithName(self.vert_tail_name)[0]
def genX3d(file=None, set=vsp.SET_ALL, dims=[1000, 400], **kwargs): if file is not None: vsp.ClearVSPModel() vsp.ReadVSPFile(file) vsp.Update() with RunManager(**kwargs): vsp.ExportFile("prop.x3d", set, vsp.EXPORT_X3D) with open("prop.x3d", "r") as f: x3d_str = f.read() x3d_str = x3d_str[0:26] + " width=\"{}px\" height=\"{}px\"".format( dims[0], dims[1]) + x3d_str[26:-1] return x3d_str
vsp.SetXSecPnts(file_xsec_id, pnt_vec) geoms = vsp.FindGeoms() print("End of second use case, all geoms in Vehicle.") print(geoms) vsp.WriteVSPFile("apitest2.vsp3") # ==== Use Case 3 ==== # print("Start of third use case, read in first-case file.") # ==== Read Geometry From File ==== # vsp.VSPRenew() errorMgr.PopErrorAndPrint(stdout) vsp.ReadVSPFile(fname) geoms = vsp.FindGeoms() print("All geoms in Vehicle.") print(geoms) # Check for errors num_err = errorMgr.GetNumTotalErrors() for i in range(0, num_err): err = errorMgr.PopLastError() print("error = ", err.m_ErrorString)
def test_2(self, train=False, refDeriv=False): """ Test 2: OpenVSP wing test """ # we skip parallel tests for now if not train and self.N_PROCS > 1: self.skipTest("Skipping the parallel test for now.") def sample_uv(nu, nv): # function to create sample uv from the surface and save these points. u = np.linspace(0, 1, nu + 1) v = np.linspace(0, 1, nv + 1) uu, vv = np.meshgrid(u, v) # print (uu.flatten(), vv.flatten()) uv = np.array((uu.flatten(), vv.flatten())) return uv refFile = os.path.join(self.base_path, "ref/test_DVGeometryVSP_02.ref") with BaseRegTest(refFile, train=train) as handler: handler.root_print("Test 2: OpenVSP NACA 0012 wing") vspFile = os.path.join(self.base_path, "../../input_files/naca0012.vsp3") DVGeo = DVGeometryVSP(vspFile) dh = 1e-6 openvsp.ClearVSPModel() openvsp.ReadVSPFile(vspFile) geoms = openvsp.FindGeoms() DVGeo = DVGeometryVSP(vspFile) comp = "WingGeom" # loop over sections # normally, there are 9 sections so we should loop over range(9) for the full test # to have it run faster, we just pick 2 sections for i in [0, 5]: # Twist DVGeo.addVariable(comp, "XSec_%d" % i, "Twist", lower=-10.0, upper=10.0, scale=1e-2, scaledStep=False, dh=dh) # loop over coefs # normally, there are 7 coeffs so we should loop over range(7) for the full test # to have it run faster, we just pick 2 sections for j in [0, 4]: # CST Airfoil shape variables group = "UpperCoeff_%d" % i var = "Au_%d" % j DVGeo.addVariable(comp, group, var, lower=-0.1, upper=0.5, scale=1e-3, scaledStep=False, dh=dh) group = "LowerCoeff_%d" % i var = "Al_%d" % j DVGeo.addVariable(comp, group, var, lower=-0.5, upper=0.1, scale=1e-3, scaledStep=False, dh=dh) # now lets generate ourselves a quad mesh of these cubes. uv_g = sample_uv(8, 8) # total number of points ntot = uv_g.shape[1] # rank on this proc rank = MPI.COMM_WORLD.rank # first, equally divide nuv = ntot // MPI.COMM_WORLD.size # then, add the remainder if rank < ntot % MPI.COMM_WORLD.size: nuv += 1 # allocate the uv array on this proc uv = np.zeros((2, nuv)) # print how mant points we have MPI.COMM_WORLD.Barrier() # loop over the points and save all that this proc owns ii = 0 for i in range(ntot): if i % MPI.COMM_WORLD.size == rank: uv[:, ii] = uv_g[:, i] ii += 1 # get the coordinates nNodes = len(uv[0, :]) openvsp.CompVecPnt01(geoms[0], 0, uv[0, :], uv[1, :]) # extract node coordinates and save them in a numpy array coor = np.zeros((nNodes, 3)) for i in range(nNodes): pnt = openvsp.CompPnt01(geoms[0], 0, uv[0, i], uv[1, i]) coor[i, :] = (pnt.x(), pnt.y(), pnt.z()) # Add this pointSet to DVGeo DVGeo.addPointSet(coor, "test_points") # We will have nNodes*3 many functions of interest... dIdpt = np.zeros((nNodes * 3, nNodes, 3)) # set the seeds to one in the following fashion: # first function of interest gets the first coordinate of the first point # second func gets the second coord of first point etc.... for i in range(nNodes): for j in range(3): dIdpt[i * 3 + j, i, j] = 1 # first get the dvgeo result funcSens = DVGeo.totalSensitivity(dIdpt.copy(), "test_points") # now perturb the design with finite differences and compute FD gradients DVs = DVGeo.getValues() funcSensFD = {} for x in DVs: # perturb the design xRef = DVs[x].copy() DVs[x] += dh DVGeo.setDesignVars(DVs) # get the new points coorNew = DVGeo.update("test_points") # calculate finite differences funcSensFD[x] = (coorNew.flatten() - coor.flatten()) / dh # set back the DV DVs[x] = xRef.copy() # now loop over the values and compare # when this is run with multiple procs, VSP sometimes has a bug # that leads to different procs having different spanwise # u-v distributions. as a result, the final values can differ up to 1e-5 levels # this issue does not come up if this tests is ran with a single proc biggest_deriv = 1e-16 for x in DVs: err = np.array(funcSens[x].squeeze()) - np.array(funcSensFD[x]) maxderiv = np.max(np.abs(funcSens[x].squeeze())) normalizer = np.median(np.abs(funcSensFD[x].squeeze())) if np.abs(normalizer) < 1: normalizer = np.ones(1) normalized_error = err / normalizer if maxderiv > biggest_deriv: biggest_deriv = maxderiv handler.assert_allclose(normalized_error, 0.0, name=f"{x}_grad_normalized_error", rtol=1e0, atol=5e-5) # make sure that at least one derivative is nonzero self.assertGreater(biggest_deriv, 0.005)