def createRudder(parentVtpCPACS, parentVtpVAMPzero, myRudder): """ This is the main export method for the wings aileron """ cpacsPath = "/cpacs/vehicles/aircraft/model/wings/wing[" + parentVtpVAMPzero.id + "]" cpacsVtp = getObjfromXpath(parentVtpCPACS, cpacsPath) cpacsComponentSegment = cpacsVtp.get_componentSegments().get_componentSegment()[0] # =========================================================================== # Header # =========================================================================== myName = stringBaseType(None, None, None, "rudder") myDescription = stringBaseType(None, None, None, "rudder from VAMPzero") myParentUID = stringUIDBaseType(None, None, "True", None, "vtp_Cseg") # =========================================================================== # Outer Shape # With the rudder this is pretty simple as it is supposed to cover # the same span as the VTP # =========================================================================== # the inner border eta is determined from the rooYLocation of the Rudder and the vtp span vtpSpan = parentVtpVAMPzero.span.getValue() / 2.0 innerEtaLE = 0.0 outerEtaLE = 1.0 innerXsiLE = myRudder.cRoot.getValue() / parentVtpVAMPzero.cRoot.getValue() outerXsiLE = myRudder.cTip.getValue() / parentVtpVAMPzero.cTip.getValue() # start writing back myleadingEdgeShape = leadingEdgeShapeType( relHeightLE=doubleBaseType(valueOf_=str(0.5)), xsiUpperSkin=doubleBaseType(valueOf_=str(0.85)), xsiLowerSkin=doubleBaseType(valueOf_=str(0.85)), ) innerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(innerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(innerXsiLE)), leadingEdgeShape=myleadingEdgeShape, ) outerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(outerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(outerXsiLE)), leadingEdgeShape=myleadingEdgeShape, ) myOuterShape = controlSurfaceOuterShapeTrailingEdgeType(innerBorder=innerBorder, outerBorder=outerBorder) cpacsRudder = trailingEdgeDeviceType( uID="rudderUID", name=myName, description=myDescription, parentUID=myParentUID, outerShape=myOuterShape ) createPath(cpacsRudder, "rudder") if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_trailingEdgeDevices(trailingEdgeDevicesType()) cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices().add_trailingEdgeDevice(cpacsRudder)
def createStabilizer(parentHtpCPACS, parentHtpVAMPzero, myElevator): ''' This is the main export method for the stabilizer, i.e. the whole htp as control surface ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentHtpVAMPzero.id + ']' cpacsHtp = getObjfromXpath(parentHtpCPACS, cpacsPath) cpacsComponentSegment = cpacsHtp.get_componentSegments( ).get_componentSegment()[0] #=========================================================================== # Header #=========================================================================== myName = stringBaseType(None, None, None, 'stabilizer') myDescription = stringBaseType(None, None, None, 'stabilizer exported from VAMPzero') myParentUID = stringUIDBaseType(None, None, 'True', None, parentHtpVAMPzero.id) #=========================================================================== # Outer Shape #=========================================================================== innerEtaLE = 0. innerXsiLE = 0. outerEtaLE = 1. outerXsiLE = 0. # start writing back #myleadingEdgeShape = leadingEdgeShapeType(relHeightLE=doubleBaseType(valueOf_=str(0.5)), xsiUpperSkin=doubleBaseType(valueOf_=str(0.85)), xsiLowerSkin=doubleBaseType(valueOf_=str(0.85))) innerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(innerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(innerXsiLE))) outerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(outerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(outerXsiLE))) myOuterShape = controlSurfaceOuterShapeTrailingEdgeType( innerBorder=innerBorder, outerBorder=outerBorder) cpacsStabilizer = trailingEdgeDeviceType(uID='stabilizerUID', name=myName, description=myDescription, parentUID=myParentUID, outerShape=myOuterShape) createPath(cpacsStabilizer, 'stabilizer') if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces(). get_trailingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_trailingEdgeDevices( trailingEdgeDevicesType()) cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices( ).add_trailingEdgeDevice(cpacsStabilizer)
def createStabilizer(parentHtpCPACS, parentHtpVAMPzero, myElevator): """ This is the main export method for the stabilizer, i.e. the whole htp as control surface """ cpacsPath = "/cpacs/vehicles/aircraft/model/wings/wing[" + parentHtpVAMPzero.id + "]" cpacsHtp = getObjfromXpath(parentHtpCPACS, cpacsPath) cpacsComponentSegment = cpacsHtp.get_componentSegments().get_componentSegment()[0] # =========================================================================== # Header # =========================================================================== myName = stringBaseType(None, None, None, "stabilizer") myDescription = stringBaseType(None, None, None, "stabilizer exported from VAMPzero") myParentUID = stringUIDBaseType(None, None, "True", None, parentHtpVAMPzero.id) # =========================================================================== # Outer Shape # =========================================================================== innerEtaLE = 0.0 innerXsiLE = 0.0 outerEtaLE = 1.0 outerXsiLE = 0.0 # start writing back # myleadingEdgeShape = leadingEdgeShapeType(relHeightLE=doubleBaseType(valueOf_=str(0.5)), xsiUpperSkin=doubleBaseType(valueOf_=str(0.85)), xsiLowerSkin=doubleBaseType(valueOf_=str(0.85))) innerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(innerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(innerXsiLE)) ) outerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(outerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(outerXsiLE)) ) myOuterShape = controlSurfaceOuterShapeTrailingEdgeType(innerBorder=innerBorder, outerBorder=outerBorder) cpacsStabilizer = trailingEdgeDeviceType( uID="stabilizerUID", name=myName, description=myDescription, parentUID=myParentUID, outerShape=myOuterShape ) createPath(cpacsStabilizer, "stabilizer") if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_trailingEdgeDevices(trailingEdgeDevicesType()) cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices().add_trailingEdgeDevice(cpacsStabilizer)
def createFlapsSBW(parentWingCPACS, parentWingVAMPzero, myFlap): ''' This is the main export method for the wings flaps for the strut braced wing. The SBW does not feature any inner flaps as no kink exists @todo: it is possible that the inner flap overlaps the kink area ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentWingVAMPzero.id + ']' cpacsWing = getObjfromXpath(parentWingCPACS, cpacsPath) cpacsComponentSegment = cpacsWing.get_componentSegments().get_componentSegment()[0] myFlaps = [] # Initialization, i.e. fetching values throughout the code xsis = [] etas = [] for i in range(3,7): try: xsis.append(eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[i].get_xsi().valueOf_)) etas.append(eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[i].get_eta().valueOf_)) except IndexError: pass xsiSpar_interp = scipy.interpolate.interp1d(etas, xsis) yFus = parentWingVAMPzero.yFuselage.getValue() span = parentWingVAMPzero.span.getValue() / 2. etaFus = yFus / span etaKink = parentWingVAMPzero.etaKink.getValue() cRoot = parentWingVAMPzero.cRoot.getValue() cKink = calcChordLengthAtEta(etaKink, parentWingVAMPzero, cpacsWing) innerFlapArea = myFlap.refAreaInnerFlap.getValue() outerFlapArea = myFlap.refAreaOuterFlap.getValue() # OuterFlap sparOffset = 0.08 # maxX is the maximum extension of the flap maxX = cRoot * (1. - (xsis[0] + sparOffset)) /2. newOuterFlapArea = innerFlapArea + outerFlapArea cRootOuterFlap = cRoot * (1. - (xsis[0] + sparOffset)) # Determine the total flap span by iteration calcArea = 0. spanOuterFlap = 0. absSparOffset = sparOffset * cKink # Obtain the maxEtaValue. This is forwarded from the ailerons export routine. maxEta = myFlap.maxEta.getValue() - 0.02 # the tip root length is a function of the span (as the xsi location of the spar changes) while abs(calcArea - newOuterFlapArea) > 0.1: spanOuterFlap += .01 cTipOuterFlap = calcChordLengthAtEta(etaFus + spanOuterFlap / span, parentWingVAMPzero, cpacsWing) * (1 - xsiSpar_interp(etaFus + spanOuterFlap / span)) - absSparOffset oldcalcArea = calcArea calcArea = spanOuterFlap * (cRootOuterFlap + cTipOuterFlap) / 2. if calcArea < oldcalcArea: log.warning('VAMPzero FLAP: Outer Flap Area can not be established decreasing spar offset by 2% chord!') sparOffset = sparOffset - 0.02 calcArea = 0. spanOuterFlap = 0. absSparOffset = sparOffset * cKink break if spanOuterFlap / span + etaFus > maxEta: log.warning('VAMPzero FLAP: Outer Flap overlaps with the aileron decreasing spar offset by 2% chord!') sparOffset = sparOffset - 0.02 calcArea = 0. spanOuterFlap = 0. absSparOffset = sparOffset * cRoot break while abs(calcArea - newOuterFlapArea) > 0.1: spanOuterFlap += .01 cTipOuterFlap = calcChordLengthAtEta(etaFus + spanOuterFlap / span, parentWingVAMPzero, cpacsWing) * (1 - xsiSpar_interp(etaFus + spanOuterFlap / span)) - absSparOffset oldcalcArea = calcArea calcArea = spanOuterFlap * (cRootOuterFlap + cTipOuterFlap) / 2. if calcArea < oldcalcArea: log.warning('VAMPzero FLAP: Outer Flap Area can not be established! Continuing with outerArea = %s' % str(calcArea)) newOuterFlapArea = calcArea break if spanOuterFlap / span + etaFus + 0.06 > maxEta: log.warning('VAMPzero FLAP: Outer Flap overlaps with the aileron! Continuing with outerArea = %s' % str(calcArea)) newOuterFlapArea = calcArea break # Determine the number of flaps # The aspect ratio of a flap should not be higher than 6. nOuterFlaps = spanOuterFlap ** 2. / (newOuterFlapArea * 6.) log.debug('VAMPzero FLAP: Exporting %s Flaps outboard of the engine for an area of %s m2.' % (str(nOuterFlaps), str(newOuterFlapArea))) # 1 Flap if nOuterFlaps <= 1.: # the inner border eta is located at the kink innerEtaLE = etaFus + 0.05 innerXsiLE = xsis[0] + sparOffset # the outer border eta is determined from the span of the outer flap outerEtaLE = etaFus + 0.05 + spanOuterFlap / span outerXsiLE = 1 - (cTipOuterFlap / calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing)) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append(createFlap('outerFlap1', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, appendInnerCruiseRoller=True, type='flap', innerX=innerX, outerX=outerX)) # 2 Flaps elif nOuterFlaps > 1. and nOuterFlaps <= 2.: # the inner border eta is located at the kink innerEtaLE = etaFus + 0.05 innerXsiLE = xsis[2] + sparOffset # the outer border eta is determined from the half span of the total outer flap outerEtaLE = etaFus + 0.05 + spanOuterFlap / (2*span) outerXsiLE = xsiSpar_interp(outerEtaLE) + absSparOffset / calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append(createFlap('outerFlap1', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, type='flap', innerX=innerX, outerX=outerX)) # new inner is the old outer innerEtaLE = outerEtaLE innerXsiLE = outerXsiLE # the outer border eta is determined from the full span of the total outer flap outerEtaLE = etaFus + 0.05 + spanOuterFlap / span outerXsiLE = 1 - (cTipOuterFlap / calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing)) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append(createFlap('outerFlap2', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, appendInnerCruiseRoller=True, type='flap', innerX=innerX, outerX=outerX)) # n Flaps elif nOuterFlaps > 2. : n = int(ceil(nOuterFlaps)) # First Flap # the inner border eta is located at the kink innerEtaLE = etaFus + 0.05 innerXsiLE = xsis[2] + sparOffset # the outer border eta is determined from the half span of the total outer flap outerEtaLE = etaFus + 0.05 + spanOuterFlap / (n*span) outerXsiLE = xsiSpar_interp(outerEtaLE) + absSparOffset / calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append(createFlap('outerFlap1', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, type='flap', innerX=innerX, outerX=outerX)) for i in range(2, n): # nth Flap # new inner is the old outer innerEtaLE = outerEtaLE innerXsiLE = outerXsiLE # the outer border eta is determined from the full span of the total outer flap outerEtaLE = innerEtaLE + spanOuterFlap / n / span outerXsiLE = xsiSpar_interp(outerEtaLE) + absSparOffset / calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append(createFlap('outerFlap' + str(i), parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, appendInnerCruiseRoller=True, type='flap', innerX=innerX, outerX=outerX)) # Last Flap # new inner is the old outer innerEtaLE = outerEtaLE innerXsiLE = outerXsiLE # the outer border eta is determined from the full span of the total outer flap outerEtaLE = etaFus + 0.05 + spanOuterFlap / span outerXsiLE = 1 - (cTipOuterFlap / calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing)) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append(createFlap('outerFlap' + str(n), parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, appendInnerCruiseRoller=True, type='flap', innerX=innerX, outerX=outerX)) # Output to Spoiler # as the spoiler is relying on data of the flaps some basic information is written # back to the the VAMPzero components parentWingVAMPzero.spoiler.outerEta = parameter(parent=parentWingVAMPzero.spoiler, value=outerEtaLE, unit='', status='calc', doc='The outermost eta coordinate of all flaps. This overlaps with the outer eta coordinate of the spoiler') spoilerChord = maxX parentWingVAMPzero.spoiler.chord = parameter(spoilerChord, 'm', 'calc', 'The absolute chord of the spoiler: 5% of the kink chord length + 50% of the innerFlap Chord length', parent=parentWingVAMPzero.spoiler) # Output to CPACS if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_trailingEdgeDevices(trailingEdgeDevicesType()) log.debug('VAMPzero SLAT: Exporting %s Flaps to CPACS.' % (str(len(myFlaps)))) for flap in myFlaps: cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices().add_trailingEdgeDevice(flap)
def createFlapsAdvDoubleTrapezoid(parentWingCPACS, parentWingVAMPzero, myFlap): ''' This is the main export method for the wings flaps @todo: it is possible that the inner flap overlaps the kink area ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentWingVAMPzero.id + ']' cpacsWing = getObjfromXpath(parentWingCPACS, cpacsPath) cpacsComponentSegment = cpacsWing.get_componentSegments().get_componentSegment()[0] myFlaps = [] # Initialization, i.e. fetching values throughout the code xsiSparRoot = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[3].get_xsi().valueOf_) xsiSparFuselage = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[4].get_xsi().valueOf_) xsiSparKink = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[5].get_xsi().valueOf_) xsiSparTip = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[6].get_xsi().valueOf_) etaSparRoot = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[3].get_eta().valueOf_) etaSparFuselage = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[4].get_eta().valueOf_) etaSparKink = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[5].get_eta().valueOf_) etaSparTip = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[6].get_eta().valueOf_) xsiSpar_interp = scipy.interpolate.interp1d([etaSparRoot, etaSparFuselage, etaSparKink, etaSparTip], [xsiSparRoot, xsiSparFuselage, xsiSparKink, xsiSparTip]) yFus = parentWingVAMPzero.yFuselage.getValue() span = parentWingVAMPzero.span.getValue() / 2. etaFus = yFus / span etaKink = parentWingVAMPzero.etaKink.getValue() cRoot = parentWingVAMPzero.cRoot.getValue() cKink = calcChordLengthAtEta(etaKink, parentWingVAMPzero, cpacsWing) phiLE = parentWingVAMPzero.phiLE.getValue() innerFlapArea = myFlap.refAreaInnerFlap.getValue() outerFlapArea = myFlap.refAreaOuterFlap.getValue() # InnerFlap # Determine the number of flaps # The aspect ratio of a flap should not be higher than 9. sparOffset = 0.08 if phiLE > 0.: # if the wing is backward swept the chord of the inner flap equals the chord at kink behind the rear spar + sparOffset cInnerFlap = cKink * (1. - (xsiSparKink + sparOffset)) elif phiLE < 0.: # if the wing is forward swept the chord of the inner flap is similar to the chord of the root section behind the spar + 20% cInnerFlap = cRoot * (1. - (xsiSparFuselage + 0.2)) # maxX is the maximum extension of the flap maxX = cInnerFlap / 2. # The area of the innerFlap is determined by the chord and span # The difference in the area will be substituted by the outerFlap Area spanInnerFlap = (etaKink - etaFus) * span newInnerFlapArea = cInnerFlap * spanInnerFlap deltaArea = innerFlapArea - newInnerFlapArea nInnerFlaps = spanInnerFlap ** 2. / (newInnerFlapArea * 9.) log.debug('VAMPzero FLAP: Exporting %s Flaps inside of the engine for an area of %s m2.' % (str(nInnerFlaps), str(innerFlapArea))) if nInnerFlaps < 1.: # the inner border eta is located at the intersection with the fuselage innerEtaLE = etaFus # the inner border xsi is determined from the wing chord at the fuselage station (which equals CRoot) innerXsiLE = 1. - (cInnerFlap / cRoot) # the outer border eta is determined from the span of the inner flap outerEtaLE = etaKink # the outer xsi location is found from the avg chord and the chord length at that station outerXsiLE = 1. - (cInnerFlap / cKink) myFlaps.append(createFlap('innerFlap', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, type='innerFlap', innerX=maxX, outerX=maxX)) elif nInnerFlaps > 1. and nInnerFlaps <= 2.: # First Flap # the inner border eta is located at the intersection with the fuselage innerEtaLE = etaFus # the inner border xsi is determined from the wing chord at the fuselage station (which equals CRoot) innerXsiLE = 1. - (cInnerFlap / cRoot) # the outer border eta is determined from the span of the inner flap outerEtaLE = etaFus + (etaKink - etaFus) / 2. # the outer xsi location is found from the avg chord and the chord length at that station outerXsiLE = 1. - (cInnerFlap / calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing)) myFlaps.append(createFlap('innerFlap1', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, type='innerFlap', innerX=maxX, outerX=maxX)) # Second Flap # new inner is old outer innerEtaLE = outerEtaLE # new outer is kink outerEtaLE = etaKink # new inner is old outer innerXsiLE = outerXsiLE # new outer is kink outerXsiLE = 1. - (cInnerFlap / cKink) myFlaps.append(createFlap('innerFlap2', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, type='flap', innerX=maxX, outerX=maxX)) # OuterFlap newOuterFlapArea = outerFlapArea + deltaArea cRootOuterFlap = cKink * (1. - (xsiSparKink + sparOffset)) # Determine the total flap span by iteration calcArea = 0. spanOuterFlap = 0. absSparOffset = sparOffset * cKink # Obtain the maxEtaValue. This is forwarded from the ailerons export routine. maxEta = myFlap.maxEta.getValue() - 0.02 # the tip root length is a function of the span (as the xsi location of the spar changes) while abs(calcArea - newOuterFlapArea) > 0.1: spanOuterFlap += .01 cTipOuterFlap = calcChordLengthAtEta(etaKink + spanOuterFlap / span, parentWingVAMPzero, cpacsWing) * (1 - xsiSpar_interp(etaKink + spanOuterFlap / span)) - absSparOffset oldcalcArea = calcArea calcArea = spanOuterFlap * (cRootOuterFlap + cTipOuterFlap) / 2. if calcArea < oldcalcArea: log.warning('VAMPzero FLAP: Outer Flap Area can not be established decreasing spar offset by 2% chord!') sparOffset = sparOffset - 0.02 calcArea = 0. spanOuterFlap = 0. absSparOffset = sparOffset * cKink break if spanOuterFlap / span + etaKink > maxEta: log.warning('VAMPzero FLAP: Outer Flap overlaps with the aileron decreasing spar offset by 2% chord!') sparOffset = sparOffset - 0.02 calcArea = 0. spanOuterFlap = 0. absSparOffset = sparOffset * cKink break while abs(calcArea - newOuterFlapArea) > 0.1: spanOuterFlap += .01 cTipOuterFlap = calcChordLengthAtEta(etaKink + spanOuterFlap / span, parentWingVAMPzero, cpacsWing) * (1 - xsiSpar_interp(etaKink + spanOuterFlap / span)) - absSparOffset oldcalcArea = calcArea calcArea = spanOuterFlap * (cRootOuterFlap + cTipOuterFlap) / 2. if calcArea < oldcalcArea: log.warning('VAMPzero FLAP: Outer Flap Area can not be established! Continuing with outerArea = %s' % str(calcArea)) newOuterFlapArea = calcArea break if spanOuterFlap / span + etaKink > maxEta: log.warning('VAMPzero FLAP: Outer Flap overlaps with the aileron! Continuing with outerArea = %s' % str(calcArea)) newOuterFlapArea = calcArea break # Determine the number of flaps # The aspect ratio of a flap should not be higher than 9. nOuterFlaps = spanOuterFlap ** 2. / (newOuterFlapArea * 9.) log.debug('VAMPzero FLAP: Exporting %s Flaps outboard of the engine for an area of %s m2.' % (str(nOuterFlaps), str(newOuterFlapArea))) # 1 Flap if nOuterFlaps <= 1.: # the inner border eta is located at the kink innerEtaLE = etaKink innerXsiLE = xsiSparKink + sparOffset # the outer border eta is determined from the span of the outer flap outerEtaLE = etaKink + spanOuterFlap / span outerXsiLE = 1 - (cTipOuterFlap / calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing)) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append(createFlap('outerFlap1', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, appendInnerCruiseRoller=True, type='flap', innerX=innerX, outerX=outerX)) # 2 Flaps elif nOuterFlaps > 1. and nOuterFlaps <= 2.: # the inner border eta is located at the kink innerEtaLE = etaKink innerXsiLE = xsiSparKink + sparOffset # the outer border eta is determined from the half span of the total outer flap outerEtaLE = etaKink + spanOuterFlap / (2. * span) outerXsiLE = xsiSpar_interp(outerEtaLE) + absSparOffset / calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append(createFlap('outerFlap1', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, type='flap', innerX=innerX, outerX=outerX)) # new inner is the old outer innerEtaLE = outerEtaLE innerXsiLE = outerXsiLE # the outer border eta is determined from the full span of the total outer flap outerEtaLE = etaKink + spanOuterFlap / span outerXsiLE = 1 - (cTipOuterFlap / calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing)) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append(createFlap('outerFlap2', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, appendInnerCruiseRoller=True, type='flap', innerX=innerX, outerX=outerX)) # n Flaps elif nOuterFlaps > 2. : n = int(ceil(nOuterFlaps)) # First Flap # the inner border eta is located at the kink innerEtaLE = etaKink innerXsiLE = xsiSparKink + sparOffset # the outer border eta is determined from the half span of the total outer flap outerEtaLE = etaKink + spanOuterFlap / n / span outerXsiLE = xsiSpar_interp(outerEtaLE) + absSparOffset / calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append(createFlap('outerFlap1', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, type='flap', innerX=innerX, outerX=outerX)) for i in range(2, n): # nth Flap # new inner is the old outer innerEtaLE = outerEtaLE innerXsiLE = outerXsiLE # the outer border eta is determined from the full span of the total outer flap outerEtaLE = innerEtaLE + spanOuterFlap / n / span outerXsiLE = xsiSpar_interp(outerEtaLE) + absSparOffset / calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append(createFlap('outerFlap' + str(i), parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, appendInnerCruiseRoller=True, type='flap', innerX=innerX, outerX=outerX)) # Last Flap # new inner is the old outer innerEtaLE = outerEtaLE innerXsiLE = outerXsiLE # the outer border eta is determined from the full span of the total outer flap outerEtaLE = etaKink + spanOuterFlap / span outerXsiLE = 1 - (cTipOuterFlap / calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing)) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append(createFlap('outerFlap' + str(n), parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, appendInnerCruiseRoller=True, type='flap', innerX=innerX, outerX=outerX)) # Output to Spoiler # as the spoiler is relying on data of the flaps some basic information is written # back to the the VAMPzero components parentWingVAMPzero.spoiler.outerEta = parameter(outerEtaLE, '', 'calc', 'The outermost eta coordinate of all flaps. This overlaps with the outer eta coordinate of the spoiler', parent=parentWingVAMPzero.spoiler) spoilerChord = 0.05 * cKink + 0.5 * cInnerFlap parentWingVAMPzero.spoiler.chord = parameter(spoilerChord, 'm', 'calc', 'The absolute chord of the spoiler: 5% of the kink chord length + 50% of the innerFlap Chord length', parent=parentWingVAMPzero.spoiler) # Output to CPACS if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_trailingEdgeDevices(trailingEdgeDevicesType()) log.debug('VAMPzero SLAT: Exporting %s Flaps to CPACS.' % (str(len(myFlaps)))) for flap in myFlaps: cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices().add_trailingEdgeDevice(flap)
def createSpoilers(parentWingCPACS, parentWingVAMPzero, mySpoiler): ''' This is the main export method for the wing's spoilers * It assumes a constant absolut chord for all spoilers * Spoiler start outboard and move inboard close behind the rearspar * They are rectangular ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentWingVAMPzero.id + ']' cpacsWing = getObjfromXpath(parentWingCPACS, cpacsPath) cpacsComponentSegment = cpacsWing.get_componentSegments().get_componentSegment()[0] mySpoilers = [] #=========================================================================== # Initialization, i.e. fetching values throughout the code #=========================================================================== span = parentWingVAMPzero.span.getValue() / 2. etaKink = parentWingVAMPzero.etaKink.getValue() yFus = parentWingVAMPzero.yFuselage.getValue() etaFus = yFus / span spoilerArea = mySpoiler.refArea.getValue() spoilerChord = mySpoiler.chord.getValue() spoilerOuterEta = mySpoiler.outerEta.getValue() sparOffset = 0.02 #=========================================================================== # Rear spar locations #=========================================================================== xsiSparRoot = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[3].get_xsi().valueOf_) xsiSparFuselage = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[4].get_xsi().valueOf_) xsiSparKink = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[5].get_xsi().valueOf_) xsiSparTip = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[6].get_xsi().valueOf_) etaSparRoot = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[3].get_eta().valueOf_) etaSparFuselage = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[4].get_eta().valueOf_) etaSparKink = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[5].get_eta().valueOf_) etaSparTip = eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[6].get_eta().valueOf_) xsiSpar_interp = scipy.interpolate.interp1d([etaSparRoot, etaSparFuselage, etaSparKink, etaSparTip], [xsiSparRoot, xsiSparFuselage, xsiSparKink, xsiSparTip]) #=========================================================================== # Outer Spoilers #=========================================================================== outerSpan = (spoilerOuterEta - etaKink) * span outerArea = spoilerChord * outerSpan nOuterSpoiler = outerSpan ** 2 / (outerArea * 2.) log.debug('VAMPzero SPOILER: Exporting %s Spoiler outside of the kink for an area of %s m2.' % (str(nOuterSpoiler), str(outerArea))) #=========================================================================== # 1 Spoiler #=========================================================================== if nOuterSpoiler <= 1.: # The outer eta of the leading Edge is correspondent to the outerEta of the spoiler outerEtaLE = spoilerOuterEta # The inner eta of the leading edge is the outer eta minus the span of the outer spoiler innerEtaLE = spoilerOuterEta - outerSpan / span # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # We do not want the spoiler to overlap the kink as the inner Spoilers will start here if innerEtaTE < etaKink: innerEtaTE = etaKink innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('OuterSpoiler1', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) #=========================================================================== # 2 Spoiler #=========================================================================== elif nOuterSpoiler > 1. and nOuterSpoiler <= 2.: # The outer eta of the leading Edge is correspondent to the outerEta of the spoiler outerEtaLE = spoilerOuterEta # The inner eta of the leading edge is the outer eta minus the span of the outer spoiler innerEtaLE = spoilerOuterEta - outerSpan / span / 2. # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('OuterSpoiler2', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) # old outer is new inner outerEtaLE = innerEtaLE # new inner is min next to kink innerEtaLE = spoilerOuterEta - outerSpan / span # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # We do not want the spoiler to overlap the kink as the inner Spoilers will start here if innerEtaTE < etaKink: innerEtaTE = etaKink innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('OuterSpoiler1', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) #=========================================================================== # n Spoiler #=========================================================================== elif nOuterSpoiler > 2.: n = int(ceil(nOuterSpoiler)) # The outer eta of the leading Edge is correspondent to the outerEta of the spoiler outerEtaLE = spoilerOuterEta # The inner eta of the leading edge is the outer eta minus the span of the outer spoiler innerEtaLE = outerEtaLE - outerSpan / span / n # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('OuterSpoiler' + str(n), parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) for i in range(2, n): # old outer is new inner outerEtaLE = innerEtaLE # new inner is min next to kink innerEtaLE = outerEtaLE - outerSpan / span / n # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('OuterSpoiler' + str(n - i + 1), parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) # old outer is new inner outerEtaLE = innerEtaLE # new inner is min next to kink innerEtaLE = spoilerOuterEta - outerSpan / span # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # We do not want the spoiler to overlap the kink as the inner Spoilers will start here if innerEtaTE < etaKink: innerEtaTE = etaKink innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('OuterSpoiler1', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) #=============================================================================== # Inner Spoilers #=============================================================================== deltaArea = spoilerArea - outerArea noExport = False if deltaArea <= 0.: log.warning('VAMPzero SPOILER: Outboard Spoiler area already exceeds the required spoiler area by: %s' % str(deltaArea)) noExport = True calcArea = 0. maxInnerArea = (etaKink - etaFus) * span * spoilerChord if maxInnerArea >= deltaArea and noExport == False: innerSpan = 0. while True: innerSpan += .01 oldArea = calcArea calcArea = innerSpan * spoilerChord # This is the break condition that should be hit normally if abs(deltaArea - calcArea) < 0.1: break if innerSpan > (etaKink - etaFus) * span: log.warning('VAMPzero SPOILER: The spoiler span of the inner spoiler exceeds the available span betweent fuselage and kink, continuing with calcArea = %s' % str(calcArea)) break if oldArea > calcArea: log.warning('VAMPzero SPOILER: Inner spoiler area apparently reached a maximum, continuing with calcArea = %s' % str(calcArea)) break elif noExport == False: log.warning('VAMPzero SPOILER: There is not sufficient space for the inner spoiler(s) between the kink and the fuselage!') spoilerChord = deltaArea / ((etaKink - etaFus) * span) innerSpan = (etaKink - etaFus) * span calcArea = deltaArea log.warning('VAMPzero SPOILER: The spoilerchord will be enlarged to %s!' % str(spoilerChord)) if noExport == True: nInnerSpoiler = 0 log.debug('VAMPzero SPOILER: Exporting %s Spoiler inside of the kink.' % (str(nInnerSpoiler))) else: nInnerSpoiler = innerSpan ** 2 / (calcArea * 3.) log.debug('VAMPzero SPOILER: Exporting %s Spoiler inside of the kink for an area of %s m2.' % (str(nInnerSpoiler), str(calcArea))) #=========================================================================== # 1 Spoiler #=========================================================================== if nInnerSpoiler == 0: pass elif nInnerSpoiler <= 1: # The outer eta of the leading Edge to the eta of the kink outerEtaLE = etaKink # The inner eta of the leading edge is the outer eta minus the span of the inner spoiler innerEtaLE = outerEtaLE - innerSpan / span # The outer Xsi at the leading Edge is defined by the sparLocation of the Kink outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset # The innner Xsi remains an absolute chord of the spoiler chordInnerSpoiler = (1-outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) innerXsiLE = 1 - chordInnerSpoiler / calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) # Eta Coordinates stay constant # Xsi Coordinates are shifted by spoilerChord outerEtaTE = outerEtaLE outerXsiTE = outerXsiLE + spoilerChord / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('InnerSpoiler1', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) #=========================================================================== # 2 Spoiler #=========================================================================== elif nInnerSpoiler > 1. and nInnerSpoiler <= 2.: # First inner spoiler # The outer eta of the leading Edge to the eta of the kink outerEtaLE = etaKink # The inner eta of the leading edge is the outer eta minus the span of the inner spoiler innerEtaLE = outerEtaLE - innerSpan / span / 2. # The outer Xsi at the leading Edge is defined by the sparLocation of the Kink outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset # The innner Xsi remains an absolute chord of the spoiler chordInnerSpoiler = (1-outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) innerXsiLE = 1 - chordInnerSpoiler / calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) # Eta Coordinates stay constant # Xsi Coordinates are shifted by spoilerChord outerEtaTE = outerEtaLE outerXsiTE = outerXsiLE + spoilerChord / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('InnerSpoiler2', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) # Second inner spoiler # old inner becomes new outer outerEtaLE = innerEtaLE # The inner eta of the leading edge is the outer eta minus the span of the inner spoiler innerEtaLE = outerEtaLE - innerSpan / span / 2. # The outer Xsi at the leading Edge is defined by the sparLocation of the Kink outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset # The innner Xsi remains an absolute chord of the spoiler chordInnerSpoiler = (1-outerXsiLE) * calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) innerXsiLE = 1 - chordInnerSpoiler / calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) # Eta Coordinates stay constant # Xsi Coordinates are shifted by spoilerChord outerEtaTE = outerEtaLE outerXsiTE = outerXsiLE + spoilerChord / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('InnerSpoiler1', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) #=========================================================================== # Output to CPACS #=========================================================================== if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces().get_spoilers()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_spoilers(spoilersType()) log.debug('VAMPzero Spoiler: Exporting %s Spoilers to CPACS.' % (str(len(mySpoilers)))) for spoiler in mySpoilers: cpacsComponentSegment.get_controlSurfaces().get_spoilers().add_spoiler(spoiler)
def createSlats(parentWingCPACS, parentWingVAMPzero, mySlat): ''' This is the main export method for the wing's slats It assumes a constant absolut chord for all slats. At the engine position a 5% span gap is included for the slats Slats end 5% prior to the wing tip ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentWingVAMPzero.id + ']' cpacsWing = getObjfromXpath(parentWingCPACS, cpacsPath) cpacsComponentSegment = cpacsWing.get_componentSegments().get_componentSegment()[0] mySlats = [] # Initialization, i.e. fetching values throughout the code yFus = parentWingVAMPzero.yFuselage.getValue() span = parentWingVAMPzero.span.getValue() / 2. etaFus = yFus / span slatArea = mySlat.refArea.getValue() # The absolut chord of all slats is equal it is determined by the # total slat area over the remaining span # the remaining span is the span minus the fuselage section minus 5% around the engine # and 5% at the tip cSlat = slatArea / ((1.0 - etaFus - 0.1) * span) if cSlat > calcChordLengthAtEta(etaFus, parentWingVAMPzero, cpacsWing) * 0.075: log.warning('VAMPzero SLAT: The slat chord is larger than 7.5% of the wing\'s chord at the fuselage intersection.') # Inner Wing Slats # At first inner wing slats are defined. These do only extend up to the engine # a plus minus 2.5% span are reserved for the slats # Note the calculation is only valid for nEngine == 2 # The aspect ratio of a slat should not be higher than 5.5 etaEngine = parentWingVAMPzero.etaEngine.getValue() innerSpan = span * (etaEngine - 0.025 - etaFus) innerArea = innerSpan * cSlat nInnerSlats = innerSpan ** 2. / (innerArea * 5.5) log.debug('VAMPzero SLAT: Exporting %s Slats inside of the engine for an area of %s m2.' % (str(nInnerSlats), str(innerArea))) # 1 Slat if nInnerSlats <= 1.: # the inner border eta is located at the Fuselage innerEtaTE = etaFus innerXsiTE = cSlat / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # the outer border eta is determined from the span of the outer flap outerEtaTE = etaFus + innerSpan / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('InnerSlat1', parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) # 2 Slats elif nInnerSlats > 1. and nInnerSlats < 2.: # the inner border eta is located at the Fuselage innerEtaTE = etaFus innerXsiTE = cSlat / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # the outer border eta is determined from the span of the outer flap outerEtaTE = etaFus + innerSpan / 2. / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('InnerSlat1', parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) # new inner is the old outer innerEtaLE = outerEtaTE innerXsiLE = outerXsiTE # the outer border eta is determined from the full span of the total outer flap outerEtaLE = etaFus + innerSpan / span outerXsiLE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('InnerSlat2', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, innerX=innerX, outerX=outerX)) else: log.warning('VAMPzero EXPORT: Need more inner slats') # Outer Wing Slats # Determine the number of remaining slats # The aspect ratio of a slat should not be higher than 5.5 slatArea = slatArea - innerArea calcArea = 0. spanSlat = 0. while abs(calcArea - slatArea) > 0.5: spanSlat += .01 calcArea = spanSlat * cSlat # Determine the number of slats # The aspect ratio of a slats should not be higher than 5.5 nSlats = spanSlat ** 2. / (slatArea * 5.5) log.debug('VAMPzero SLAT: Exporting %s Slats outboard of the engine for an area of %s m2.' % (str(nSlats), str(slatArea))) # 1 Slat if nSlats <= 1.: # the inner border eta is located at the Fuselage innerEtaTE = etaEngine + 0.025 innerXsiTE = cSlat / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # the outer border eta is determined from the span of the outer flap outerEtaTE = innerEtaTE + spanSlat / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('OuterSlat1', parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) # 2 Slats elif nSlats > 1. and nSlats < 2.: # the inner border eta is located at the Fuselage innerEtaTE = etaEngine + 0.025 innerXsiTE = cSlat / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # the outer border eta is determined from the span of the outer flap outerEtaTE = innerEtaTE + spanSlat / 2. / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('OuterSlat1', parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) # new inner is the old outer innerEtaTE = outerEtaTE innerXsiTE = outerXsiTE # the outer border eta is determined from the full span of the total outer flap outerEtaTE = innerEtaTE + spanSlat / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('OuterSlat2', parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) # n Slats else: # the inner border eta is located at the Fuselage n = int(ceil(nSlats)) innerEtaTE = etaEngine + 0.025 innerXsiTE = cSlat / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # First Slat # the outer border eta is determined from the span of the outer flap outerEtaTE = innerEtaTE + spanSlat / n / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('OuterSlat1', parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) for i in range(2, n): # new inner is the old outer innerEtaTE = outerEtaTE innerXsiTE = outerXsiTE # the outer border eta is determined from the full span of the total outer flap outerEtaTE = innerEtaTE + spanSlat / n / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('OuterSlat' + str(i), parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) # Last Slat # new inner is the old outer innerEtaTE = outerEtaTE innerXsiTE = outerXsiTE # the outer border eta is determined from the full span of the total outer flap outerEtaTE = innerEtaTE + spanSlat / n / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('OuterSlat' + str(n), parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) # Output to CPACS if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces().get_leadingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_leadingEdgeDevices(leadingEdgeDevicesType()) log.debug('VAMPzero SLAT: Exporting %s Slats to CPACS.' % (str(len(mySlats)))) for slat in mySlats: cpacsComponentSegment.get_controlSurfaces().get_leadingEdgeDevices().add_leadingEdgeDevice(slat)
def createSpoilers(parentWingCPACS, parentWingVAMPzero, mySpoiler): ''' This is the main export method for the wing's spoilers * It assumes a constant absolut chord for all spoilers * Spoiler start outboard and move inboard close behind the rearspar * They are rectangular ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentWingVAMPzero.id + ']' cpacsWing = getObjfromXpath(parentWingCPACS, cpacsPath) cpacsComponentSegment = cpacsWing.get_componentSegments( ).get_componentSegment()[0] mySpoilers = [] #=========================================================================== # Initialization, i.e. fetching values throughout the code #=========================================================================== span = parentWingVAMPzero.span.getValue() / 2. etaKink = parentWingVAMPzero.etaKink.getValue() yFus = parentWingVAMPzero.yFuselage.getValue() etaFus = yFus / span spoilerArea = mySpoiler.refArea.getValue() spoilerChord = mySpoiler.chord.getValue() spoilerOuterEta = mySpoiler.outerEta.getValue() sparOffset = 0.02 #=========================================================================== # Rear spar locations #=========================================================================== xsiSparRoot = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[3].get_xsi().valueOf_) xsiSparFuselage = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[4].get_xsi().valueOf_) xsiSparKink = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[5].get_xsi().valueOf_) xsiSparTip = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[6].get_xsi().valueOf_) etaSparRoot = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[3].get_eta().valueOf_) etaSparFuselage = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[4].get_eta().valueOf_) etaSparKink = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[5].get_eta().valueOf_) etaSparTip = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[6].get_eta().valueOf_) xsiSpar_interp = scipy.interpolate.interp1d( [etaSparRoot, etaSparFuselage, etaSparKink, etaSparTip], [xsiSparRoot, xsiSparFuselage, xsiSparKink, xsiSparTip]) #=========================================================================== # Outer Spoilers #=========================================================================== outerSpan = (spoilerOuterEta - etaKink) * span outerArea = spoilerChord * outerSpan nOuterSpoiler = outerSpan**2 / (outerArea * 2.) log.debug( 'VAMPzero SPOILER: Exporting %s Spoiler outside of the kink for an area of %s m2.' % (str(nOuterSpoiler), str(outerArea))) #=========================================================================== # 1 Spoiler #=========================================================================== if nOuterSpoiler <= 1.: # The outer eta of the leading Edge is correspondent to the outerEta of the spoiler outerEtaLE = spoilerOuterEta # The inner eta of the leading edge is the outer eta minus the span of the outer spoiler innerEtaLE = spoilerOuterEta - outerSpan / span # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta( outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta( innerEtaTE, parentWingVAMPzero, cpacsWing) # We do not want the spoiler to overlap the kink as the inner Spoilers will start here if innerEtaTE < etaKink: innerEtaTE = etaKink innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta( innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append( createSpoiler('OuterSpoiler1', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) #=========================================================================== # 2 Spoiler #=========================================================================== elif nOuterSpoiler > 1. and nOuterSpoiler <= 2.: # The outer eta of the leading Edge is correspondent to the outerEta of the spoiler outerEtaLE = spoilerOuterEta # The inner eta of the leading edge is the outer eta minus the span of the outer spoiler innerEtaLE = spoilerOuterEta - outerSpan / span / 2. # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta( outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta( innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append( createSpoiler('OuterSpoiler2', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) # old outer is new inner outerEtaLE = innerEtaLE # new inner is min next to kink innerEtaLE = spoilerOuterEta - outerSpan / span # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta( outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta( innerEtaTE, parentWingVAMPzero, cpacsWing) # We do not want the spoiler to overlap the kink as the inner Spoilers will start here if innerEtaTE < etaKink: innerEtaTE = etaKink innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta( innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append( createSpoiler('OuterSpoiler1', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) #=========================================================================== # n Spoiler #=========================================================================== elif nOuterSpoiler > 2.: n = int(ceil(nOuterSpoiler)) # The outer eta of the leading Edge is correspondent to the outerEta of the spoiler outerEtaLE = spoilerOuterEta # The inner eta of the leading edge is the outer eta minus the span of the outer spoiler innerEtaLE = outerEtaLE - outerSpan / span / n # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta( outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta( innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append( createSpoiler('OuterSpoiler' + str(n), parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) for i in range(2, n): # old outer is new inner outerEtaLE = innerEtaLE # new inner is min next to kink innerEtaLE = outerEtaLE - outerSpan / span / n # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta( outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta( innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append( createSpoiler('OuterSpoiler' + str(n - i + 1), parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) # old outer is new inner outerEtaLE = innerEtaLE # new inner is min next to kink innerEtaLE = spoilerOuterEta - outerSpan / span # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta( outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta( innerEtaTE, parentWingVAMPzero, cpacsWing) # We do not want the spoiler to overlap the kink as the inner Spoilers will start here if innerEtaTE < etaKink: innerEtaTE = etaKink innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta( innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append( createSpoiler('OuterSpoiler1', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) #=============================================================================== # Inner Spoilers #=============================================================================== deltaArea = spoilerArea - outerArea noExport = False if deltaArea <= 0.: log.warning( 'VAMPzero SPOILER: Outboard Spoiler area already exceeds the required spoiler area by: %s' % str(deltaArea)) noExport = True calcArea = 0. maxInnerArea = (etaKink - etaFus) * span * spoilerChord if maxInnerArea >= deltaArea and noExport == False: innerSpan = 0. while True: innerSpan += .01 oldArea = calcArea calcArea = innerSpan * spoilerChord # This is the break condition that should be hit normally if abs(deltaArea - calcArea) < 0.1: break if innerSpan > (etaKink - etaFus) * span: log.warning( 'VAMPzero SPOILER: The spoiler span of the inner spoiler exceeds the available span betweent fuselage and kink, continuing with calcArea = %s' % str(calcArea)) break if oldArea > calcArea: log.warning( 'VAMPzero SPOILER: Inner spoiler area apparently reached a maximum, continuing with calcArea = %s' % str(calcArea)) break elif noExport == False: log.warning( 'VAMPzero SPOILER: There is not sufficient space for the inner spoiler(s) between the kink and the fuselage!' ) spoilerChord = deltaArea / ((etaKink - etaFus) * span) innerSpan = (etaKink - etaFus) * span calcArea = deltaArea log.warning( 'VAMPzero SPOILER: The spoilerchord will be enlarged to %s!' % str(spoilerChord)) if noExport == True: nInnerSpoiler = 0 log.debug( 'VAMPzero SPOILER: Exporting %s Spoiler inside of the kink.' % (str(nInnerSpoiler))) else: nInnerSpoiler = innerSpan**2 / (calcArea * 3.) log.debug( 'VAMPzero SPOILER: Exporting %s Spoiler inside of the kink for an area of %s m2.' % (str(nInnerSpoiler), str(calcArea))) #=========================================================================== # 1 Spoiler #=========================================================================== if nInnerSpoiler == 0: pass elif nInnerSpoiler <= 1: # The outer eta of the leading Edge to the eta of the kink outerEtaLE = etaKink # The inner eta of the leading edge is the outer eta minus the span of the inner spoiler innerEtaLE = outerEtaLE - innerSpan / span # The outer Xsi at the leading Edge is defined by the sparLocation of the Kink outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset # The innner Xsi remains an absolute chord of the spoiler chordInnerSpoiler = (1 - outerXsiLE) * calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing) innerXsiLE = 1 - chordInnerSpoiler / calcChordLengthAtEta( innerEtaLE, parentWingVAMPzero, cpacsWing) # Eta Coordinates stay constant # Xsi Coordinates are shifted by spoilerChord outerEtaTE = outerEtaLE outerXsiTE = outerXsiLE + spoilerChord / calcChordLengthAtEta( outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta( innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append( createSpoiler('InnerSpoiler1', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) #=========================================================================== # 2 Spoiler #=========================================================================== elif nInnerSpoiler > 1. and nInnerSpoiler <= 2.: # First inner spoiler # The outer eta of the leading Edge to the eta of the kink outerEtaLE = etaKink # The inner eta of the leading edge is the outer eta minus the span of the inner spoiler innerEtaLE = outerEtaLE - innerSpan / span / 2. # The outer Xsi at the leading Edge is defined by the sparLocation of the Kink outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset # The innner Xsi remains an absolute chord of the spoiler chordInnerSpoiler = (1 - outerXsiLE) * calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing) innerXsiLE = 1 - chordInnerSpoiler / calcChordLengthAtEta( innerEtaLE, parentWingVAMPzero, cpacsWing) # Eta Coordinates stay constant # Xsi Coordinates are shifted by spoilerChord outerEtaTE = outerEtaLE outerXsiTE = outerXsiLE + spoilerChord / calcChordLengthAtEta( outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta( innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append( createSpoiler('InnerSpoiler2', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) # Second inner spoiler # old inner becomes new outer outerEtaLE = innerEtaLE # The inner eta of the leading edge is the outer eta minus the span of the inner spoiler innerEtaLE = outerEtaLE - innerSpan / span / 2. # The outer Xsi at the leading Edge is defined by the sparLocation of the Kink outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset # The innner Xsi remains an absolute chord of the spoiler chordInnerSpoiler = (1 - outerXsiLE) * calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing) innerXsiLE = 1 - chordInnerSpoiler / calcChordLengthAtEta( innerEtaLE, parentWingVAMPzero, cpacsWing) # Eta Coordinates stay constant # Xsi Coordinates are shifted by spoilerChord outerEtaTE = outerEtaLE outerXsiTE = outerXsiLE + spoilerChord / calcChordLengthAtEta( outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta( innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append( createSpoiler('InnerSpoiler1', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) #=========================================================================== # Output to CPACS #=========================================================================== if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces().get_spoilers() ) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_spoilers( spoilersType()) log.debug('VAMPzero Spoiler: Exporting %s Spoilers to CPACS.' % (str(len(mySpoilers)))) for spoiler in mySpoilers: cpacsComponentSegment.get_controlSurfaces().get_spoilers().add_spoiler( spoiler)
def createElevator(parentHtpCPACS, parentHtpVAMPzero, myElevator): """ This is the main export method for the htp elevator """ cpacsPath = "/cpacs/vehicles/aircraft/model/wings/wing[" + parentHtpVAMPzero.id + "]" cpacsHtp = getObjfromXpath(parentHtpCPACS, cpacsPath) cpacsComponentSegment = cpacsHtp.get_componentSegments().get_componentSegment()[0] # =========================================================================== # Header # =========================================================================== myName = stringBaseType(None, None, None, "elevator") myDescription = stringBaseType(None, None, None, "elevator from VAMPzero") myParentUID = stringUIDBaseType(None, None, "True", None, parentHtpVAMPzero.id) # =========================================================================== # Outer Shape # =========================================================================== # the inner border eta is determined from the rooYLocation of the Elevator and the htp span htpSpan = parentHtpVAMPzero.span.getValue() / 2.0 innerEtaLE = myElevator.rootYLocation.getValue() / htpSpan # the inner border xsi is determined from the Root Chord and the Chord of the Htp at the location phiLE = parentHtpVAMPzero.phiLE.getValue() phiTE = parentHtpVAMPzero.phiTE.getValue() x1 = tan(phiLE * rad) * htpSpan * innerEtaLE x2 = tan(phiTE * rad) * htpSpan * innerEtaLE cInnerWing = (x2 + parentHtpVAMPzero.cRoot.getValue()) - x1 innerXsiLE = 1 - (myElevator.cRoot.getValue() / cInnerWing) # The outer border eta station is set to the inner eta plus the span of the elevator outerEtaLE = innerEtaLE + myElevator.span.getValue() / htpSpan # The outer border xsi is determined in the same way as the inner border xsi x1 = tan(phiLE * rad) * htpSpan * outerEtaLE x2 = tan(phiTE * rad) * htpSpan * outerEtaLE cOuterWing = (x2 + parentHtpVAMPzero.cRoot.getValue()) - x1 outerXsiLE = 1 - (myElevator.cTip.getValue() / cOuterWing) # start writing back myleadingEdgeShape = leadingEdgeShapeType( relHeightLE=doubleBaseType(valueOf_=str(0.5)), xsiUpperSkin=doubleBaseType(valueOf_=str(0.85)), xsiLowerSkin=doubleBaseType(valueOf_=str(0.85)), ) innerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(innerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(innerXsiLE)), leadingEdgeShape=myleadingEdgeShape, ) outerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(outerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(outerXsiLE)), leadingEdgeShape=myleadingEdgeShape, ) myOuterShape = controlSurfaceOuterShapeTrailingEdgeType(innerBorder=innerBorder, outerBorder=outerBorder) cpacsElevator = trailingEdgeDeviceType( uID="elevatorUID", name=myName, description=myDescription, parentUID=myParentUID, outerShape=myOuterShape ) createPath(cpacsElevator, "elevator") if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_trailingEdgeDevices(trailingEdgeDevicesType()) cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices().add_trailingEdgeDevice(cpacsElevator)
def createAileron(parentWingCPACS, parentWingVAMPzero, myAileron): ''' This is the main export method for the wings aileron ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentWingVAMPzero.id + ']' cpacsWing = getObjfromXpath(parentWingCPACS, cpacsPath) cpacsComponentSegment = cpacsWing.get_componentSegments( ).get_componentSegment()[0] #=========================================================================== # Header #=========================================================================== myName = stringBaseType(None, None, None, 'aileron') myDescription = stringBaseType(None, None, None, 'aileron from VAMPzero') myParentUID = stringUIDBaseType(None, None, 'True', None, 'wing_Cseg') #=========================================================================== # Initialization, i.e. fetching values throughout the code #=========================================================================== xsiSparRoot = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[3].get_xsi().valueOf_) xsiSparFuselage = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[4].get_xsi().valueOf_) xsiSparKink = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[5].get_xsi().valueOf_) xsiSparTip = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[6].get_xsi().valueOf_) etaSparRoot = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[3].get_eta().valueOf_) etaSparFuselage = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[4].get_eta().valueOf_) etaSparKink = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[5].get_eta().valueOf_) etaSparTip = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[6].get_eta().valueOf_) xsiSpar_interp = scipy.interpolate.interp1d( [etaSparRoot, etaSparFuselage, etaSparKink, etaSparTip], [xsiSparRoot, xsiSparFuselage, xsiSparKink, xsiSparTip]) sparOffset = 0.1 wingSpan = parentWingVAMPzero.span.getValue() / 2. #=========================================================================== # Outer Shape #=========================================================================== # The outer border eta station is set to 96 percent outerEtaLE = 0.96 # The outer chord station is determined from the wing's chord at eta = 0.96 # and the rear spar location + the spar offset outerXsiLE = xsiSpar_interp(0.96) + sparOffset outerWingChord = calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) cTip = (1 - outerXsiLE) * outerWingChord # now we need to determine the necessary span for the aileron by gently increasing the span # this is an iterative process as the chord of the aileron is a function of the inbound span aileronArea = parentWingVAMPzero.aileron.refArea.getValue() delta = 0.01 calcArea = 0. while abs(calcArea - aileronArea) > 0.1: if delta > outerEtaLE: parentWingVAMPzero.log.warning( 'VAMPzero EXPORT: Cannot determine the span of the aileron') parentWingVAMPzero.log.warning('VAMPzero EXPORT: aileronArea= ' + str(aileronArea)) parentWingVAMPzero.log.warning( 'VAMPzero EXPORT: Decreasing Spar Offset') sparOffset = sparOffset - 0.02 delta = 0.01 innerEtaLE = outerEtaLE - delta innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset innerWingChord = calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) cRoot = (1 - innerXsiLE) * innerWingChord calcArea = (cTip + cRoot) / 2 * (outerEtaLE - innerEtaLE) * wingSpan delta += 0.005 # start outer shape myleadingEdgeShape = leadingEdgeShapeType( relHeightLE=doubleBaseType(valueOf_=str(0.5)), xsiUpperSkin=doubleBaseType(valueOf_=str(0.85)), xsiLowerSkin=doubleBaseType(valueOf_=str(0.85))) innerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(innerEtaLE)), etaTE=doubleBaseType(valueOf_=str(innerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(innerXsiLE)), leadingEdgeShape=myleadingEdgeShape) outerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(outerEtaLE)), etaTE=doubleBaseType(valueOf_=str(outerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(outerXsiLE)), leadingEdgeShape=myleadingEdgeShape) myOuterShape = controlSurfaceOuterShapeTrailingEdgeType( innerBorder=innerBorder, outerBorder=outerBorder) # structure myStructure = wingComponentSegmentStructureType() cpacsAileron = trailingEdgeDeviceType(uID='aileronUID', name=myName, description=myDescription, parentUID=myParentUID, outerShape=myOuterShape, structure=myStructure) createAileronStructure(cpacsAileron) # Forward information about innerEtaLE to the flap parentWingVAMPzero.flap.maxEta = parameter( value=innerEtaLE, doc= 'This it the inner position of the aileron, the flap may not exceed it' ) # moveables deltaEta = outerEtaLE - innerEtaLE innerParentXsi = xsiSpar_interp(innerEtaLE + 0.3 * deltaEta) + 0.02 outerParentXsi = xsiSpar_interp(innerEtaLE + 0.7 * deltaEta) + 0.02 createPath(cpacsAileron, 'aileron') createTracks(cpacsAileron, 'aileron') createActuators(cpacsAileron, 'aileron', [innerParentXsi, outerParentXsi]) if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces(). get_trailingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_trailingEdgeDevices( trailingEdgeDevicesType()) cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices( ).add_trailingEdgeDevice(cpacsAileron)
def createElevator(parentHtpCPACS, parentHtpVAMPzero, myElevator): ''' This is the main export method for the htp elevator ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentHtpVAMPzero.id + ']' cpacsHtp = getObjfromXpath(parentHtpCPACS, cpacsPath) cpacsComponentSegment = cpacsHtp.get_componentSegments( ).get_componentSegment()[0] #=========================================================================== # Header #=========================================================================== myName = stringBaseType(None, None, None, 'elevator') myDescription = stringBaseType(None, None, None, 'elevator from VAMPzero') myParentUID = stringUIDBaseType(None, None, 'True', None, parentHtpVAMPzero.id) #=========================================================================== # Outer Shape #=========================================================================== # the inner border eta is determined from the rooYLocation of the Elevator and the htp span htpSpan = parentHtpVAMPzero.span.getValue() / 2. innerEtaLE = myElevator.rootYLocation.getValue() / htpSpan # the inner border xsi is determined from the Root Chord and the Chord of the Htp at the location phiLE = parentHtpVAMPzero.phiLE.getValue() phiTE = parentHtpVAMPzero.phiTE.getValue() x1 = tan(phiLE * rad) * htpSpan * innerEtaLE x2 = tan(phiTE * rad) * htpSpan * innerEtaLE cInnerWing = (x2 + parentHtpVAMPzero.cRoot.getValue()) - x1 innerXsiLE = 1 - (myElevator.cRoot.getValue() / cInnerWing) # The outer border eta station is set to the inner eta plus the span of the elevator outerEtaLE = innerEtaLE + myElevator.span.getValue() / htpSpan # The outer border xsi is determined in the same way as the inner border xsi x1 = tan(phiLE * rad) * htpSpan * outerEtaLE x2 = tan(phiTE * rad) * htpSpan * outerEtaLE cOuterWing = (x2 + parentHtpVAMPzero.cRoot.getValue()) - x1 outerXsiLE = 1 - (myElevator.cTip.getValue() / cOuterWing) # start writing back myleadingEdgeShape = leadingEdgeShapeType( relHeightLE=doubleBaseType(valueOf_=str(0.5)), xsiUpperSkin=doubleBaseType(valueOf_=str(0.85)), xsiLowerSkin=doubleBaseType(valueOf_=str(0.85))) innerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(innerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(innerXsiLE)), leadingEdgeShape=myleadingEdgeShape) outerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(outerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(outerXsiLE)), leadingEdgeShape=myleadingEdgeShape) myOuterShape = controlSurfaceOuterShapeTrailingEdgeType( innerBorder=innerBorder, outerBorder=outerBorder) cpacsElevator = trailingEdgeDeviceType(uID='elevatorUID', name=myName, description=myDescription, parentUID=myParentUID, outerShape=myOuterShape) createPath(cpacsElevator, 'elevator') if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces(). get_trailingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_trailingEdgeDevices( trailingEdgeDevicesType()) cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices( ).add_trailingEdgeDevice(cpacsElevator)
def createElevator(parentHtpCPACS, parentHtpVAMPzero, myElevator): ''' This is the main export method for the htp elevator ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentHtpVAMPzero.id + ']' cpacsHtp = getObjfromXpath(parentHtpCPACS, cpacsPath) cpacsComponentSegment = cpacsHtp.get_componentSegments().get_componentSegment()[0] #=========================================================================== # Header #=========================================================================== myName = stringBaseType(None, None, None, 'elevator') myDescription = stringBaseType(None, None, None, 'elevator from VAMPzero') myParentUID = stringUIDBaseType(None, None, 'True', None, parentHtpVAMPzero.id) #=========================================================================== # Outer Shape #=========================================================================== # the inner border eta is determined from the rooYLocation of the Elevator and the htp span htpSpan = parentHtpVAMPzero.span.getValue() / 2. innerEtaLE = myElevator.rootYLocation.getValue() / htpSpan # the inner border xsi is determined from the Root Chord and the Chord of the Htp at the location # the inner border xsi is determined from the Root Chord and the Chord of the Htp at the location cTipHtp = parentHtpVAMPzero.cTip.getValue() cRootHtp = parentHtpVAMPzero.cRoot.getValue() cInnerWing = cRootHtp - (cRootHtp - cTipHtp)*innerEtaLE innerXsiLE = 1 - (myElevator.cRoot.getValue() / cInnerWing) if innerXsiLE < 0.2: parentHtpVAMPzero.log.warning('VAMPzero EXPORT: The Elevator tap inner border is larger than the available chord') parentHtpVAMPzero.log.warning('VAMPzero EXPORT: The Elevator tap inner border is now set to 0.1') innerXsiLE = 0.2 # The outer border eta station is set to the inner eta plus the span of the elevator outerEtaLE = innerEtaLE + myElevator.span.getValue() / htpSpan # The outer border xsi is determined in the same way as the inner border xsi cOuterWing = cRootHtp - (cRootHtp - cTipHtp)*outerEtaLE outerXsiLE = 1 - (myElevator.cTip.getValue() / cOuterWing) if outerXsiLE < 0.2: parentHtpVAMPzero.log.warning('VAMPzero EXPORT: The Elevator tap outer border is larger than the available chord') parentHtpVAMPzero.log.warning('VAMPzero EXPORT: The Elevator tap outer border is now set to 0.1') outerXsiLE = 0.2 # start writing back myleadingEdgeShape = leadingEdgeShapeType(relHeightLE=doubleBaseType(valueOf_=str(0.5)), xsiUpperSkin=doubleBaseType(valueOf_=str(0.85)), xsiLowerSkin=doubleBaseType(valueOf_=str(0.85))) innerBorder = controlSurfaceBorderTrailingEdgeType(etaLE=doubleBaseType(valueOf_=str(innerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(innerXsiLE)), leadingEdgeShape=myleadingEdgeShape) outerBorder = controlSurfaceBorderTrailingEdgeType(etaLE=doubleBaseType(valueOf_=str(outerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(outerXsiLE)), leadingEdgeShape=myleadingEdgeShape) myOuterShape = controlSurfaceOuterShapeTrailingEdgeType(innerBorder=innerBorder, outerBorder=outerBorder) cpacsElevator = trailingEdgeDeviceType(uID='elevatorUID', name=myName, description=myDescription, parentUID=myParentUID, outerShape=myOuterShape) createPath(cpacsElevator, 'elevator') if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_trailingEdgeDevices(trailingEdgeDevicesType()) cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices().add_trailingEdgeDevice(cpacsElevator)
def createSpoilersSBW(parentWingCPACS, parentWingVAMPzero, mySpoiler): ''' This is the main export method for the wing's spoilers * It assumes a constant absolut chord for all spoilers * Spoiler start outboard and move inboard close behind the rearspar * They are rectangular ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentWingVAMPzero.id + ']' cpacsWing = getObjfromXpath(parentWingCPACS, cpacsPath) cpacsComponentSegment = cpacsWing.get_componentSegments().get_componentSegment()[0] mySpoilers = [] # Initialization, i.e. fetching values throughout the code span = parentWingVAMPzero.span.getValue() / 2. yFus = parentWingVAMPzero.yFuselage.getValue() etaFus = yFus / span spoilerArea = mySpoiler.refArea.getValue() spoilerChord = mySpoiler.chord.getValue() spoilerOuterEta = mySpoiler.outerEta.getValue() sparOffset = 0.02 # Rear spar locations xsis = [] etas = [] for i in range(3,7): try: xsis.append(eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[i].get_xsi().valueOf_)) etas.append(eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[i].get_eta().valueOf_)) except IndexError: pass xsiSpar_interp = scipy.interpolate.interp1d(etas, xsis) # Outer Spoilers outerSpan = (spoilerOuterEta - etaFus) * span #outerArea = spoilerChord * outerSpan #nOuterSpoiler = outerSpan ** 2 / (outerArea * 2.) #log.debug('VAMPzero SPOILER: Exporting %s Spoiler outside of the kink for an area of %s m2.' % (str(nOuterSpoiler), str(outerArea))) calcArea = 0. maxInnerArea = (spoilerOuterEta - etaFus) * span * spoilerChord innerSpan = 0. while True: innerSpan += .01 oldArea = calcArea calcArea = innerSpan * spoilerChord # This is the break condition that should be hit normally if abs(spoilerArea - calcArea) < 0.1: break if innerSpan > (spoilerOuterEta - etaFus) * span: log.warning('VAMPzero SPOILER: The spoiler span of the spoiler exceeds the available span between fuselage and kink, continuing with calcArea = %s' % str(calcArea)) break if oldArea > calcArea: log.warning('VAMPzero SPOILER: Spoiler area apparently reached a maximum, continuing with calcArea = %s' % str(calcArea)) break nSpoiler = innerSpan ** 2 / (calcArea * 3.) log.debug('VAMPzero SPOILER: Exporting %s Spoiler inside of the kink for an area of %s m2.' % (str(nSpoiler), str(calcArea))) # 1 Spoiler if nSpoiler <= 1.: # The outer eta of the leading Edge is correspondent to the outerEta of the spoiler outerEtaLE = spoilerOuterEta # The inner eta of the leading edge is the outer eta minus the span of the outer spoiler innerEtaLE = spoilerOuterEta - outerSpan / span # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # We do not want the spoiler to overlap the kink as the inner Spoilers will start here if innerEtaTE < etaFus: innerEtaTE = etaFus innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('Spoiler1', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) # 2 Spoiler elif nSpoiler > 1. and nSpoiler <= 2.: # The outer eta of the leading Edge is correspondent to the outerEta of the spoiler outerEtaLE = spoilerOuterEta # The inner eta of the leading edge is the outer eta minus the span of the outer spoiler innerEtaLE = spoilerOuterEta - outerSpan / span / 2. # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('Spoiler2', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) # old outer is new inner outerEtaLE = innerEtaLE # new inner is min next to kink innerEtaLE = spoilerOuterEta - outerSpan / span # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # We do not want the spoiler to overlap the kink as the inner Spoilers will start here if innerEtaTE < etaFus: innerEtaTE = etaFus innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('Spoiler1', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) # n Spoiler elif nSpoiler > 2.: n = int(ceil(nSpoiler)) # The outer eta of the leading Edge is correspondent to the outerEta of the spoiler outerEtaLE = spoilerOuterEta # The inner eta of the leading edge is the outer eta minus the span of the outer spoiler innerEtaLE = outerEtaLE - outerSpan / span / n # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('Spoiler' + str(n), parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) for i in range(2, n): # old outer is new inner outerEtaLE = innerEtaLE # new inner is min next to kink innerEtaLE = outerEtaLE - outerSpan / span / n # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('Spoiler' + str(n - i + 1), parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) # old outer is new inner outerEtaLE = innerEtaLE # new inner is min next to kink innerEtaLE = spoilerOuterEta - outerSpan / span # The inner and outer Xsi coordinate of the leading edge are defined by the rear spar location and the sparOffset outerXsiLE = xsiSpar_interp(outerEtaLE) + sparOffset innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset spoilerPhi = calcPhiLESpoiler(outerEtaLE, innerEtaLE, outerXsiLE, innerXsiLE, parentWingVAMPzero, cpacsWing) deltaEta = sin(spoilerPhi) * spoilerChord deltaXsi = cos(spoilerPhi) * spoilerChord outerEtaTE = outerEtaLE - deltaEta / span outerXsiTE = outerXsiLE + deltaXsi / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) innerEtaTE = innerEtaLE - deltaEta / span innerXsiTE = innerXsiLE + deltaXsi / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # We do not want the spoiler to overlap the kink as the inner Spoilers will start here if innerEtaTE < etaFus: innerEtaTE = etaFus innerXsiTE = innerXsiLE + spoilerChord / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) mySpoilers.append(createSpoiler('Spoiler1', parentWingVAMPzero.id, innerEtaLE, innerEtaTE, innerXsiLE, innerXsiTE, outerEtaLE, outerEtaTE, outerXsiLE, outerXsiTE)) # Output to CPACS if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces().get_spoilers()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_spoilers(spoilersType()) log.debug('VAMPzero Spoiler: Exporting %s Spoilers to CPACS.' % (str(len(mySpoilers)))) for spoiler in mySpoilers: cpacsComponentSegment.get_controlSurfaces().get_spoilers().add_spoiler(spoiler)
def createAileron(parentWingCPACS, parentWingVAMPzero, myAileron): ''' This is the main export method for the wings aileron ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentWingVAMPzero.id + ']' cpacsWing = getObjfromXpath(parentWingCPACS, cpacsPath) cpacsComponentSegment = cpacsWing.get_componentSegments().get_componentSegment()[0] # Header myName = stringBaseType(None, None, None, 'aileron') myDescription = stringBaseType(None, None, None, 'aileron from VAMPzero') myParentUID = stringUIDBaseType(None, None, 'True', None, 'wing_Cseg') # Initialization, i.e. fetching values throughout the code xsis = [] etas = [] for i in range(3,7): try: xsis.append(eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[i].get_xsi().valueOf_)) etas.append(eval(cpacsComponentSegment.get_structure().get_spars().get_sparPositions().get_sparPosition()[i].get_eta().valueOf_)) except IndexError: pass xsiSpar_interp = scipy.interpolate.interp1d(etas, xsis) sparOffset = 0.1 wingSpan = parentWingVAMPzero.span.getValue() / 2. # Outer Shape # The outer border eta station is set to 96 percent outerEtaLE = 0.96 # The outer chord station is determined from the wing's chord at eta = 0.96 # and the rear spar location + the spar offset outerXsiLE = xsiSpar_interp(0.96) + sparOffset outerWingChord = calcChordLengthAtEta(outerEtaLE, parentWingVAMPzero, cpacsWing) cTip = (1 - outerXsiLE) * outerWingChord # now we need to determine the necessary span for the aileron by gently increasing the span # this is an iterative process as the chord of the aileron is a function of the inbound span aileronArea = parentWingVAMPzero.aileron.refArea.getValue() delta = 0.01 calcArea = 0. while abs(calcArea - aileronArea) > 0.1: if delta > outerEtaLE: parentWingVAMPzero.log.warning('VAMPzero EXPORT: Cannot determine the span of the aileron') parentWingVAMPzero.log.warning('VAMPzero EXPORT: aileronArea= '+str(aileronArea)) parentWingVAMPzero.log.warning('VAMPzero EXPORT: Decreasing Spar Offset') sparOffset = sparOffset - 0.02 delta = 0.01 innerEtaLE = outerEtaLE - delta innerXsiLE = xsiSpar_interp(innerEtaLE) + sparOffset innerWingChord = calcChordLengthAtEta(innerEtaLE, parentWingVAMPzero, cpacsWing) cRoot = (1 - innerXsiLE) * innerWingChord calcArea = (cTip + cRoot) / 2 * (outerEtaLE - innerEtaLE) * wingSpan delta += 0.005 # start outer shape myleadingEdgeShape = leadingEdgeShapeType(relHeightLE=doubleBaseType(valueOf_=str(0.5)), xsiUpperSkin=doubleBaseType(valueOf_=str(0.85)), xsiLowerSkin=doubleBaseType(valueOf_=str(0.85))) innerBorder = controlSurfaceBorderTrailingEdgeType(etaLE=doubleBaseType(valueOf_=str(innerEtaLE)), etaTE=doubleBaseType(valueOf_=str(innerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(innerXsiLE)), leadingEdgeShape=myleadingEdgeShape) outerBorder = controlSurfaceBorderTrailingEdgeType(etaLE=doubleBaseType(valueOf_=str(outerEtaLE)), etaTE=doubleBaseType(valueOf_=str(outerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(outerXsiLE)), leadingEdgeShape=myleadingEdgeShape) myOuterShape = controlSurfaceOuterShapeTrailingEdgeType(innerBorder=innerBorder, outerBorder=outerBorder) # structure myStructure = wingComponentSegmentStructureType() cpacsAileron = trailingEdgeDeviceType(uID='aileronUID', name=myName, description=myDescription, parentUID=myParentUID, outerShape=myOuterShape, structure=myStructure) createAileronStructure(cpacsAileron) # Forward information about innerEtaLE to the flap parentWingVAMPzero.flap.maxEta = parameter(value=innerEtaLE, doc='This it the inner position of the aileron, the flap may not exceed it') # moveables deltaEta = outerEtaLE - innerEtaLE innerParentXsi = xsiSpar_interp(innerEtaLE + 0.3 * deltaEta) + 0.02 outerParentXsi = xsiSpar_interp(innerEtaLE + 0.7 * deltaEta) + 0.02 createPath(cpacsAileron, 'aileron') createTracks(cpacsAileron, 'aileron') createActuators(cpacsAileron, 'aileron', [innerParentXsi, outerParentXsi]) if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_trailingEdgeDevices(trailingEdgeDevicesType()) cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices().add_trailingEdgeDevice(cpacsAileron)
def createSlats(parentWingCPACS, parentWingVAMPzero, mySlat): ''' This is the main export method for the wing's slats It assumes a constant absolut chord for all slats. At the engine position a 5% span gap is included for the slats Slats end 5% prior to the wing tip ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentWingVAMPzero.id + ']' cpacsWing = getObjfromXpath(parentWingCPACS, cpacsPath) cpacsComponentSegment = cpacsWing.get_componentSegments().get_componentSegment()[0] mySlats = [] #=========================================================================== # Initialization, i.e. fetching values throughout the code #=========================================================================== yFus = parentWingVAMPzero.yFuselage.getValue() span = parentWingVAMPzero.span.getValue() / 2. etaFus = yFus / span slatArea = mySlat.refArea.getValue() # The absolut chord of all slats is equal it is determined by the # total slat area over the remaining span # the remaining span is the span minus the fuselage section minus 5% around the engine # and 5% at the tip cSlat = slatArea / ((1.0 - etaFus - 0.1) * span) if cSlat > calcChordLengthAtEta(etaFus, parentWingVAMPzero, cpacsWing) * 0.075: log.warning('VAMPzero SLAT: The slat chord is larger than 7.5% of the wing\'s chord at the fuselage intersection.') #=========================================================================== # Inner Wing Slats # ---------------- # # At first inner wing slats are defined. These do only extend up to the engine # a plus minus 2.5% span are reserved for the slats # Note the calculation is only valid for nEngine == 2 # The aspect ratio of a slat should not be higher than 5.5 #=========================================================================== etaEngine = parentWingVAMPzero.etaEngine.getValue() innerSpan = span * (etaEngine - 0.025 - etaFus) innerArea = innerSpan * cSlat nInnerSlats = innerSpan ** 2. / (innerArea * 5.5) log.debug('VAMPzero SLAT: Exporting %s Slats inside of the engine for an area of %s m2.' % (str(nInnerSlats), str(innerArea))) #=========================================================================== # 1 Slat #=========================================================================== if nInnerSlats <= 1.: # the inner border eta is located at the Fuselage innerEtaTE = etaFus innerXsiTE = cSlat / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # the outer border eta is determined from the span of the outer flap outerEtaTE = etaFus + innerSpan / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('InnerSlat1', parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) #=========================================================================== # 2 Slats #=========================================================================== elif nInnerSlats > 1. and nInnerSlats < 2.: # the inner border eta is located at the Fuselage innerEtaTE = etaFus innerXsiTE = cSlat / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # the outer border eta is determined from the span of the outer flap outerEtaTE = etaFus + innerSpan / 2. / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('InnerSlat1', parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) # new inner is the old outer innerEtaLE = outerEtaTE innerXsiLE = outerXsiTE # the outer border eta is determined from the full span of the total outer flap outerEtaLE = etaFus + innerSpan / span outerXsiLE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('InnerSlat2', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, innerX=innerX, outerX=outerX)) else: log.warning('VAMPzero EXPORT: Need more inner slats') #=========================================================================== # Outer Wing Slats # ---------------- # # Determine the number of remaining slats # The aspect ratio of a slat should not be higher than 5.5 #=========================================================================== slatArea = slatArea - innerArea calcArea = 0. spanSlat = 0. while abs(calcArea - slatArea) > 0.5: spanSlat += .01 calcArea = spanSlat * cSlat #=========================================================================== # Determine the number of slats # The aspect ratio of a slats should not be higher than 5.5 #=========================================================================== nSlats = spanSlat ** 2. / (slatArea * 5.5) log.debug('VAMPzero SLAT: Exporting %s Slats outboard of the engine for an area of %s m2.' % (str(nSlats), str(slatArea))) #=========================================================================== # 1 Slat #=========================================================================== if nSlats <= 1.: # the inner border eta is located at the Fuselage innerEtaTE = etaEngine + 0.025 innerXsiTE = cSlat / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # the outer border eta is determined from the span of the outer flap outerEtaTE = innerEtaTE + spanSlat / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('OuterSlat1', parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) #=========================================================================== # 2 Slats #=========================================================================== elif nSlats > 1. and nSlats < 2.: # the inner border eta is located at the Fuselage innerEtaTE = etaEngine + 0.025 innerXsiTE = cSlat / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # the outer border eta is determined from the span of the outer flap outerEtaTE = innerEtaTE + spanSlat / 2. / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('OuterSlat1', parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) # new inner is the old outer innerEtaTE = outerEtaTE innerXsiTE = outerXsiTE # the outer border eta is determined from the full span of the total outer flap outerEtaTE = innerEtaTE + spanSlat / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('OuterSlat2', parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) else: #=========================================================================== # n Slats #=========================================================================== # the inner border eta is located at the Fuselage n = int(ceil(nSlats)) innerEtaTE = etaEngine + 0.025 innerXsiTE = cSlat / calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) # First Slat # the outer border eta is determined from the span of the outer flap outerEtaTE = innerEtaTE + spanSlat / n / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('OuterSlat1', parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) for i in range(2, n): # new inner is the old outer innerEtaTE = outerEtaTE innerXsiTE = outerXsiTE # the outer border eta is determined from the full span of the total outer flap outerEtaTE = innerEtaTE + spanSlat / n / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('OuterSlat' + str(i), parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) # Last Slat # new inner is the old outer innerEtaTE = outerEtaTE innerXsiTE = outerXsiTE # the outer border eta is determined from the full span of the total outer flap outerEtaTE = innerEtaTE + spanSlat / n / span outerXsiTE = cSlat / calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) #Slats extend 50% of their chord lenght innerX = innerXsiTE * calcChordLengthAtEta(innerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = outerXsiTE * calcChordLengthAtEta(outerEtaTE, parentWingVAMPzero, cpacsWing) * 0.5 mySlats.append(createSlat('OuterSlat' + str(n), parentWingVAMPzero.id, innerEtaTE, innerXsiTE, outerEtaTE, outerXsiTE, innerX=innerX, outerX=outerX)) #=========================================================================== # Output to CPACS #=========================================================================== if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces().get_leadingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_leadingEdgeDevices(leadingEdgeDevicesType()) log.debug('VAMPzero SLAT: Exporting %s Slats to CPACS.' % (str(len(mySlats)))) for slat in mySlats: cpacsComponentSegment.get_controlSurfaces().get_leadingEdgeDevices().add_leadingEdgeDevice(slat)
def createFlapsSBW(parentWingCPACS, parentWingVAMPzero, myFlap): ''' This is the main export method for the wings flaps @todo: it is possible that the inner flap overlaps the kink area ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentWingVAMPzero.id + ']' cpacsWing = getObjfromXpath(parentWingCPACS, cpacsPath) cpacsComponentSegment = cpacsWing.get_componentSegments( ).get_componentSegment()[0] myFlaps = [] #=========================================================================== # Initialization, i.e. fetching values throughout the code #=========================================================================== xsiSparRoot = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[3].get_xsi().valueOf_) xsiSparFuselage = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[4].get_xsi().valueOf_) xsiSparKink = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[5].get_xsi().valueOf_) xsiSparTip = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[6].get_xsi().valueOf_) etaSparRoot = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[3].get_eta().valueOf_) etaSparFuselage = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[4].get_eta().valueOf_) etaSparKink = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[5].get_eta().valueOf_) etaSparTip = eval(cpacsComponentSegment.get_structure().get_spars( ).get_sparPositions().get_sparPosition()[6].get_eta().valueOf_) xsiSpar_interp = scipy.interpolate.interp1d( [etaSparRoot, etaSparFuselage, etaSparKink, etaSparTip], [xsiSparRoot, xsiSparFuselage, xsiSparKink, xsiSparTip]) yFus = parentWingVAMPzero.yFuselage.getValue() span = parentWingVAMPzero.span.getValue() / 2. etaFus = yFus / span etaKink = parentWingVAMPzero.etaKink.getValue() cRoot = parentWingVAMPzero.cRoot.getValue() cKink = calcChordLengthAtEta(etaKink, parentWingVAMPzero, cpacsWing) phiLE = parentWingVAMPzero.phiLE.getValue() innerFlapArea = myFlap.refAreaInnerFlap.getValue() outerFlapArea = myFlap.refAreaOuterFlap.getValue() #=========================================================================== # OuterFlap #=========================================================================== sparOffset = 0.08 # maxX is the maximum extension of the flap maxX = cRoot * (1. - (xsiSparRoot + sparOffset)) / 2. newOuterFlapArea = innerFlapArea + outerFlapArea cRootOuterFlap = cRoot * (1. - (xsiSparRoot + sparOffset)) #=========================================================================== # Determine the total flap span by iteration #=========================================================================== calcArea = 0. spanOuterFlap = 0. absSparOffset = sparOffset * cKink # Obtain the maxEtaValue. This is forwarded from the ailerons export routine. maxEta = myFlap.maxEta.getValue() - 0.02 # the tip root length is a function of the span (as the xsi location of the spar changes) while abs(calcArea - newOuterFlapArea) > 0.1: spanOuterFlap += .01 cTipOuterFlap = calcChordLengthAtEta( etaFus + spanOuterFlap / span, parentWingVAMPzero, cpacsWing ) * (1 - xsiSpar_interp(etaFus + spanOuterFlap / span)) - absSparOffset oldcalcArea = calcArea calcArea = spanOuterFlap * (cRootOuterFlap + cTipOuterFlap) / 2. if calcArea < oldcalcArea: log.warning( 'VAMPzero FLAP: Outer Flap Area can not be established decreasing spar offset by 2% chord!' ) sparOffset = sparOffset - 0.02 calcArea = 0. spanOuterFlap = 0. absSparOffset = sparOffset * cKink break if spanOuterFlap / span + etaFus > maxEta: log.warning( 'VAMPzero FLAP: Outer Flap overlaps with the aileron decreasing spar offset by 2% chord!' ) sparOffset = sparOffset - 0.02 calcArea = 0. spanOuterFlap = 0. absSparOffset = sparOffset * cRoot break while abs(calcArea - newOuterFlapArea) > 0.1: spanOuterFlap += .01 cTipOuterFlap = calcChordLengthAtEta( etaKink + spanOuterFlap / span, parentWingVAMPzero, cpacsWing) * ( 1 - xsiSpar_interp(etaKink + spanOuterFlap / span)) - absSparOffset oldcalcArea = calcArea calcArea = spanOuterFlap * (cRootOuterFlap + cTipOuterFlap) / 2. if calcArea < oldcalcArea: log.warning( 'VAMPzero FLAP: Outer Flap Area can not be established! Continuing with outerArea = %s' % str(calcArea)) newOuterFlapArea = calcArea break if spanOuterFlap / span + etaFus > maxEta: log.warning( 'VAMPzero FLAP: Outer Flap overlaps with the aileron! Continuing with outerArea = %s' % str(calcArea)) newOuterFlapArea = calcArea break #=========================================================================== # Determine the number of flaps # The aspect ratio of a flap should not be higher than 6. #=========================================================================== nOuterFlaps = spanOuterFlap**2. / (newOuterFlapArea * 6.) log.debug( 'VAMPzero FLAP: Exporting %s Flaps outboard of the engine for an area of %s m2.' % (str(nOuterFlaps), str(newOuterFlapArea))) #=========================================================================== # 1 Flap #=========================================================================== if nOuterFlaps <= 1.: # the inner border eta is located at the kink innerEtaLE = etaFus + 0.05 innerXsiLE = xsiSparRoot + sparOffset # the outer border eta is determined from the span of the outer flap outerEtaLE = etaFus + 0.05 + spanOuterFlap / span outerXsiLE = 1 - (cTipOuterFlap / calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing)) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta( innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append( createFlap('outerFlap1', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, appendInnerCruiseRoller=True, type='flap', innerX=innerX, outerX=outerX)) #=========================================================================== # 2 Flaps #=========================================================================== elif nOuterFlaps > 1. and nOuterFlaps <= 2.: # the inner border eta is located at the kink innerEtaLE = etaFus + 0.05 innerXsiLE = xsiSparKink + sparOffset # the outer border eta is determined from the half span of the total outer flap outerEtaLE = etaFus + 0.05 + spanOuterFlap / (2 * span) outerXsiLE = xsiSpar_interp( outerEtaLE) + absSparOffset / calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta( innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append( createFlap('outerFlap1', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, type='flap', innerX=innerX, outerX=outerX)) # new inner is the old outer innerEtaLE = outerEtaLE innerXsiLE = outerXsiLE # the outer border eta is determined from the full span of the total outer flap outerEtaLE = etaFus + 0.05 + spanOuterFlap / span outerXsiLE = 1 - (cTipOuterFlap / calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing)) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta( innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append( createFlap('outerFlap2', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, appendInnerCruiseRoller=True, type='flap', innerX=innerX, outerX=outerX)) #=========================================================================== # n Flaps #=========================================================================== elif nOuterFlaps > 2.: n = int(ceil(nOuterFlaps)) # First Flap # the inner border eta is located at the kink innerEtaLE = etaFus + 0.05 innerXsiLE = xsiSparKink + sparOffset # the outer border eta is determined from the half span of the total outer flap outerEtaLE = etaFus + 0.05 + spanOuterFlap / (n * span) outerXsiLE = xsiSpar_interp( outerEtaLE) + absSparOffset / calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta( innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append( createFlap('outerFlap1', parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, type='flap', innerX=innerX, outerX=outerX)) for i in range(2, n): # nth Flap # new inner is the old outer innerEtaLE = outerEtaLE innerXsiLE = outerXsiLE # the outer border eta is determined from the full span of the total outer flap outerEtaLE = innerEtaLE + spanOuterFlap / n / span outerXsiLE = xsiSpar_interp( outerEtaLE) + absSparOffset / calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta( innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append( createFlap('outerFlap' + str(i), parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, appendInnerCruiseRoller=True, type='flap', innerX=innerX, outerX=outerX)) # Last Flap # new inner is the old outer innerEtaLE = outerEtaLE innerXsiLE = outerXsiLE # the outer border eta is determined from the full span of the total outer flap outerEtaLE = etaFus + 0.05 + spanOuterFlap / span outerXsiLE = 1 - (cTipOuterFlap / calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing)) #Fowler Motion is restricted to 75% of the flap depth innerX = (1. - innerXsiLE) * calcChordLengthAtEta( innerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 outerX = (1. - outerXsiLE) * calcChordLengthAtEta( outerEtaLE, parentWingVAMPzero, cpacsWing) * 0.5 myFlaps.append( createFlap('outerFlap' + str(n), parentWingVAMPzero.id, innerEtaLE, innerXsiLE, outerEtaLE, outerXsiLE, maxX, appendInnerCruiseRoller=True, type='flap', innerX=innerX, outerX=outerX)) #=============================================================================== # Output to Spoiler # as the spoiler is relying on data of the flaps some basic information is written # back to the the VAMPzero components #=============================================================================== parentWingVAMPzero.spoiler.outerEta = parameter( parent=parentWingVAMPzero.spoiler, value=outerEtaLE, unit='', status='calc', doc= 'The outermost eta coordinate of all flaps. This overlaps with the outer eta coordinate of the spoiler' ) spoilerChord = maxX parentWingVAMPzero.spoiler.chord = parameter( spoilerChord, 'm', 'calc', 'The absolute chord of the spoiler: 5% of the kink chord length + 50% of the innerFlap Chord length', parent=parentWingVAMPzero.spoiler) #=========================================================================== # Output to CPACS #=========================================================================== if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces(). get_trailingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_trailingEdgeDevices( trailingEdgeDevicesType()) log.debug('VAMPzero SLAT: Exporting %s Flaps to CPACS.' % (str(len(myFlaps)))) for flap in myFlaps: cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices( ).add_trailingEdgeDevice(flap)
def createRudder(parentVtpCPACS, parentVtpVAMPzero, myRudder): ''' This is the main export method for the wings aileron ''' cpacsPath = '/cpacs/vehicles/aircraft/model/wings/wing[' + parentVtpVAMPzero.id + ']' cpacsVtp = getObjfromXpath(parentVtpCPACS, cpacsPath) cpacsComponentSegment = cpacsVtp.get_componentSegments( ).get_componentSegment()[0] #=========================================================================== # Header #=========================================================================== myName = stringBaseType(None, None, None, 'rudder') myDescription = stringBaseType(None, None, None, 'rudder from VAMPzero') myParentUID = stringUIDBaseType(None, None, 'True', None, 'vtp_Cseg') #=========================================================================== # Outer Shape # With the rudder this is pretty simple as it is supposed to cover # the same span as the VTP #=========================================================================== # the inner border eta is determined from the rooYLocation of the Rudder and the vtp span vtpSpan = parentVtpVAMPzero.span.getValue() / 2. innerEtaLE = 0. outerEtaLE = 1. innerXsiLE = myRudder.cRoot.getValue() / parentVtpVAMPzero.cRoot.getValue() outerXsiLE = myRudder.cTip.getValue() / parentVtpVAMPzero.cTip.getValue() # start writing back myleadingEdgeShape = leadingEdgeShapeType( relHeightLE=doubleBaseType(valueOf_=str(0.5)), xsiUpperSkin=doubleBaseType(valueOf_=str(0.85)), xsiLowerSkin=doubleBaseType(valueOf_=str(0.85))) innerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(innerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(innerXsiLE)), leadingEdgeShape=myleadingEdgeShape) outerBorder = controlSurfaceBorderTrailingEdgeType( etaLE=doubleBaseType(valueOf_=str(outerEtaLE)), xsiLE=doubleBaseType(valueOf_=str(outerXsiLE)), leadingEdgeShape=myleadingEdgeShape) myOuterShape = controlSurfaceOuterShapeTrailingEdgeType( innerBorder=innerBorder, outerBorder=outerBorder) cpacsRudder = trailingEdgeDeviceType(uID='rudderUID', name=myName, description=myDescription, parentUID=myParentUID, outerShape=myOuterShape) createPath(cpacsRudder, 'rudder') if type(cpacsComponentSegment.get_controlSurfaces()) == NoneType: cpacsComponentSegment.set_controlSurfaces(controlSurfacesType()) if type(cpacsComponentSegment.get_controlSurfaces(). get_trailingEdgeDevices()) == NoneType: cpacsComponentSegment.get_controlSurfaces().set_trailingEdgeDevices( trailingEdgeDevicesType()) cpacsComponentSegment.get_controlSurfaces().get_trailingEdgeDevices( ).add_trailingEdgeDevice(cpacsRudder)