847 lines
30 KiB
Python
847 lines
30 KiB
Python
#-------关联C++库---------------
|
|
import ctypes
|
|
import platform
|
|
from ctypes import *
|
|
system = platform.system()
|
|
if system == "Windows":
|
|
pre = "./"
|
|
suff = ".dll"
|
|
else:
|
|
pre = "./lib"
|
|
suff = ".so"
|
|
|
|
libfile = ctypes.cdll.LoadLibrary
|
|
filename = pre+"MainWidgets"+suff
|
|
|
|
mainWidgets = libfile(filename)
|
|
#---------------------------------
|
|
#--------------New_script_FilterClip---------
|
|
|
|
#-------定义函数------------------
|
|
|
|
def clearFEMSweepFreqData():
|
|
mainWidgets.clearFEMSweepFreqData()
|
|
|
|
|
|
def appendFEMSweepFreqData(name, sweepFreqType,sweepFreqUnit, sweepFreqPatternStr):
|
|
sname = bytes(name,encoding='utf-8')
|
|
ssweepFreqUnit = bytes(sweepFreqUnit,encoding='utf-8')
|
|
ssweepFreqPatternStr = bytes(sweepFreqPatternStr,encoding='utf-8')
|
|
mainWidgets.appendFEMSweepFreqData(sname,c_int(sweepFreqType),ssweepFreqUnit,ssweepFreqPatternStr)
|
|
|
|
|
|
class SolveSettingFEM:
|
|
def __init__(self):
|
|
self.m_SolveFreq = 0
|
|
self.m_SolveFreqUnit = "MHz"
|
|
self.m_SolveSweepFreqUnit = "MHz"
|
|
self.m_SolveFreqValue = 0
|
|
self.m_NURFE = 0
|
|
self.m_Order = 0
|
|
self.m_Steps = 0
|
|
self.m_relativeResidual = 0
|
|
self.m_bCalculateRCS = 0
|
|
self.m_bCalculateGain = 0
|
|
self.m_threadCount = 1
|
|
|
|
def setSolveFreq(self, SolveFreq):
|
|
self.m_SolveFreq = SolveFreq
|
|
|
|
def setSolveFreqUnit(self,SolveFreqUnit):
|
|
self.m_SolveFreqUnit = SolveFreqUnit
|
|
|
|
def setSolveSweepFreqUnit(self,SolveSweepFreqUnit):
|
|
self.m_SolveSweepFreqUnit = SolveSweepFreqUnit
|
|
|
|
def setSolveFreqValue(self,SolveFreqValue):
|
|
self.m_SolveFreqValue = SolveFreqValue
|
|
|
|
def setCalculateRCS(self, CalculateRCS):
|
|
self.m_bCalculateRCS = CalculateRCS
|
|
|
|
def setCalculateGain(self, CalculateGain):
|
|
self.m_bCalculateGain = CalculateGain
|
|
|
|
def setNURFE(self, NURFE):
|
|
self.m_NURFE = NURFE
|
|
|
|
def setOrder(self, Order):
|
|
self.m_Order = Order
|
|
|
|
def setSteps(self, Steps):
|
|
self.m_Steps = Steps
|
|
|
|
def setRelativeResidual(self,relativeResidual):
|
|
self.m_relativeResidual = relativeResidual
|
|
|
|
def setThreadCount(self,threadCount):
|
|
self.m_threadCount = threadCount
|
|
|
|
def saveFEMSetting(self):
|
|
mainWidgets.setFEMSetting(c_double(self.m_SolveFreq), bytes(self.m_SolveFreqUnit,encoding='utf-8'),c_double(self.m_SolveFreqValue), c_double(self.m_NURFE),
|
|
c_double(self.m_Order), c_double(self.m_Steps),c_double(self.m_relativeResidual),c_int(self.m_bCalculateRCS),c_int(self.m_bCalculateGain),c_int(self.m_threadCount))
|
|
del self
|
|
|
|
|
|
class SolveSettingMOM:
|
|
def __init__(self):
|
|
self.m_MatrixSolution = ""
|
|
self.m_fastAlgorithm = ""
|
|
self.m_ConvergencePrecision = 0
|
|
self.m_MaxIterations = 0
|
|
self.m_MaxReset = 0
|
|
self.m_GroupSize = 0
|
|
self.m_precondition = ""
|
|
self.m_iterationMethod=""
|
|
self.m_MaxLevels = 0
|
|
self.m_parallelType = 1
|
|
self.m_parallelNum = 1
|
|
|
|
def setMatrixSolution(self, MatrixSolution):
|
|
self.m_MatrixSolution = MatrixSolution
|
|
|
|
def setFastAlgorithm(self, fastAlgorithm):
|
|
self.m_fastAlgorithm = fastAlgorithm
|
|
|
|
def setConvergencePrecision(self, ConvergencePrecision):
|
|
self.m_ConvergencePrecision = ConvergencePrecision
|
|
|
|
def setMaxIterations(self, MaxIterations):
|
|
self.m_MaxIterations = MaxIterations
|
|
|
|
def setMaxReset(self, MaxReset):
|
|
self.m_MaxReset = MaxReset
|
|
|
|
def setGroupSize(self, GroupSize):
|
|
self.m_GroupSize = GroupSize
|
|
|
|
def setPrecondition(self, Precondition):
|
|
self.m_precondition = Precondition
|
|
|
|
def setIterationMethod(self,iterationMethod):
|
|
self.m_iterationMethod=iterationMethod
|
|
|
|
def setMaxLevels(self, MaxLevels):
|
|
self.m_MaxLevels = MaxLevels
|
|
|
|
def setParallelType(self,parallelType):
|
|
self.m_parallelType = parallelType
|
|
|
|
def setParallelNum(self,parallelNum):
|
|
self.m_parallelNum = parallelNum
|
|
|
|
def saveMOMSetting(self):
|
|
_sMatrixSolution = bytes(self.m_MatrixSolution, encoding='utf-8')
|
|
_sFastAlgorithm = bytes(self.m_fastAlgorithm, encoding='utf-8')
|
|
_sPrecondition = bytes(self.m_precondition, encoding='utf-8')
|
|
_sIterationMethod = bytes(self.m_iterationMethod, encoding='utf-8')
|
|
mainWidgets.setMOMSetting(_sMatrixSolution, _sFastAlgorithm,c_double(self.m_ConvergencePrecision), c_double(self.m_MaxIterations),
|
|
c_double(self.m_MaxReset), c_double(self.m_GroupSize), _sPrecondition, _sIterationMethod, c_double(self.m_MaxLevels),c_int(self.m_parallelType),c_int(self.m_parallelNum))
|
|
del self
|
|
|
|
class FrequencySettingsMOM:
|
|
def __init__(self):
|
|
self.m_SolveFreqUnit = "MHz"
|
|
self.m_SolveFreqValue = 0
|
|
self.m_SolveSweepFrequencyUnit = "MHz"
|
|
self.m_startFrequencyValue = 300
|
|
self.m_endFrequencyValue = 600
|
|
self.m_stepFrequencyValue = 100
|
|
self.m_bSweepFrequency = 0
|
|
self.m_sweepMethod = "NONE"
|
|
|
|
def setSweepMethod(self,sweepMethod):
|
|
self.m_sweepMethod = sweepMethod
|
|
|
|
def setSolveFreqUnit(self,SolveFreqUnit):
|
|
self.m_SolveFreqUnit = SolveFreqUnit
|
|
|
|
def setSolveFreqValue(self,SolveFreqValue):
|
|
self.m_SolveFreqValue = SolveFreqValue
|
|
|
|
def setSolveSweepFrequencyUnit(self,SolveSweepFrequencyUnit):
|
|
self.m_SolveSweepFrequencyUnit = SolveSweepFrequencyUnit
|
|
|
|
def setSolveSweepFrequencyParamValue(self,startFrequencyValue,endFrequencyValue,stepFrequencyValue):
|
|
self.m_startFrequencyValue = startFrequencyValue
|
|
self.m_endFrequencyValue = endFrequencyValue
|
|
self.m_stepFrequencyValue = stepFrequencyValue
|
|
|
|
#是否开启扫频
|
|
def setSweepFrequencyEnable(self,sweepFrequency):
|
|
self.m_bSweepFrequency = sweepFrequency
|
|
|
|
def save(self):
|
|
mainWidgets.setFrequencySettingsMOM(bytes(self.m_SolveFreqUnit,encoding='utf-8'),c_double(self.m_SolveFreqValue),c_int(self.m_bSweepFrequency),bytes(self.m_sweepMethod,encoding='utf-8'),bytes(self.m_SolveSweepFrequencyUnit,encoding='utf-8'),c_double(self.m_startFrequencyValue),c_double(self.m_endFrequencyValue),c_double(self.m_stepFrequencyValue))
|
|
del self
|
|
|
|
class SolvingContent:
|
|
def __init__(self):
|
|
self.m_monostaticRCSFlag = 0
|
|
self.m_bistaticRCSFlag = 0
|
|
self.m_gainFlag = 0
|
|
self.m_jSufFlag = 0
|
|
self.m_sparameterFlag = 0
|
|
self.m_RadiationEfficiency = 0
|
|
self.m_ElectricField = 0
|
|
self.m_MagneticField = 0
|
|
|
|
#设置求解单站RCS是否开启
|
|
def setRCSFlag(self,rcsFlag):
|
|
self.m_monostaticRCSFlag = rcsFlag
|
|
|
|
#设置求解双站RCS是否开启
|
|
def setBistaticRCS(self,rcsFlag):
|
|
self.m_bistaticRCSFlag = rcsFlag
|
|
|
|
def setGainFlag(self,gainFlag):
|
|
self.m_gainFlag = gainFlag
|
|
|
|
def setJSufFlag(self,jSufFlag):
|
|
self.m_jSufFlag = jSufFlag
|
|
|
|
#设置网络参数是否开启
|
|
def setSparameterFlag(self,sparameterFlag):
|
|
self.m_sparameterFlag = sparameterFlag
|
|
|
|
#设置天线效率求解是否开启
|
|
def setRadiationEfficiency(self,radiationEfficiency):
|
|
self.m_RadiationEfficiency = radiationEfficiency
|
|
|
|
#设置电场求解是否开启
|
|
def setElectricField(self,electricField):
|
|
self.m_ElectricField = electricField
|
|
|
|
#设置磁场求解是否开启
|
|
def setMagneticField(self,magneticField):
|
|
self.m_MagneticField = magneticField
|
|
|
|
def save(self):
|
|
mainWidgets.setMOMSolvingContent(c_int(self.m_monostaticRCSFlag),c_int(self.m_bistaticRCSFlag),
|
|
c_int(self.m_gainFlag),c_int(self.m_jSufFlag),c_int(self.m_sparameterFlag),c_int(self.m_RadiationEfficiency),c_int(self.m_ElectricField),c_int(self.m_MagneticField))
|
|
del self
|
|
|
|
|
|
class SimulationMOMLumpedPortData:
|
|
def __init__(self):
|
|
self.m_id = 0
|
|
self.m_portType = 1
|
|
self.m_portImpedance = 1.0
|
|
self.m_surfaceType = 0
|
|
self.m_positiveSurfaceData = ""
|
|
self.m_negativeSurfaceData = ""
|
|
self.m_intersectionEdgeData = ""
|
|
self.m_portName = ""
|
|
self.m_vectors = ""
|
|
|
|
def setID(self, id):
|
|
self.m_id = id
|
|
|
|
def setPositiveSurfaceData(self, surfaceData):
|
|
self.m_positiveSurfaceData = surfaceData
|
|
|
|
def setNegativeSurfaceData(self, surfaceData):
|
|
self.m_negativeSurfaceData = surfaceData
|
|
|
|
def setIntersectionEdgeData(self, edgeData):
|
|
self.m_intersectionEdgeData = edgeData
|
|
|
|
def setPortName(self, PortName):
|
|
self.m_portName = PortName
|
|
|
|
def setPortType(self, PortType):
|
|
self.m_portType = PortType
|
|
|
|
def setPortImpedance(self, PortImpedance):
|
|
self.m_portImpedance = PortImpedance
|
|
|
|
def setVectors(self, vectors):
|
|
self.m_vectors = vectors
|
|
|
|
def setSurfaceType(self, surfaceType):
|
|
self.m_surfaceType = surfaceType
|
|
|
|
def save(self):
|
|
sm_positiveSurfaceData = bytes(self.m_positiveSurfaceData, encoding='utf-8')
|
|
sm_negativeSurfaceData = bytes(self.m_negativeSurfaceData, encoding='utf-8')
|
|
sm_intersectionEdgeData = bytes(self.m_intersectionEdgeData, encoding='utf-8')
|
|
sm_portName = bytes(self.m_portName, encoding='utf-8')
|
|
sm_vectors = bytes(self.m_vectors, encoding='utf-8')
|
|
mainWidgets.setSimulationMOMLumpedPortData(c_int(self.m_id), sm_positiveSurfaceData,sm_negativeSurfaceData,sm_intersectionEdgeData, sm_portName, c_int(self.m_portType), c_double(self.m_portImpedance),sm_vectors,c_int(self.m_surfaceType))
|
|
del self
|
|
|
|
class SimulationFEMLumpedPortData:
|
|
def __init__(self):
|
|
self.m_id = 0
|
|
self.m_portName = ""
|
|
self.m_selectedSurfaceData = ""
|
|
self.m_beginPoint = ""
|
|
self.m_endPoint = ""
|
|
self.m_isIntergrationSet = 0
|
|
self.m_planeNormalDirection = ""
|
|
|
|
def setID(self, id):
|
|
self.m_id = id
|
|
|
|
def setPortName(self, PortName):
|
|
self.m_portName = PortName
|
|
|
|
def setSelectedSurfaceData(self, SurfaceDataID):
|
|
self.m_selectedSurfaceData = SurfaceDataID
|
|
|
|
def setBeginPoint(self, beginPoint):
|
|
self.m_beginPoint = beginPoint
|
|
|
|
def setEndPoint(self, endPoint):
|
|
self.m_endPoint = endPoint
|
|
|
|
def setIsIntergrationSet(self, isIntergrationSet):
|
|
self.m_isIntergrationSet = isIntergrationSet
|
|
|
|
def setPlaneNormalDirection(self, planeNormalDirection):
|
|
self.m_planeNormalDirection = planeNormalDirection
|
|
|
|
def save(self):
|
|
sm_portName = bytes(self.m_portName, encoding='utf-8')
|
|
sm_selectedSurfaceData = bytes(self.m_selectedSurfaceData, encoding='utf-8')
|
|
sm_beginPoint = bytes(self.m_beginPoint, encoding='utf-8')
|
|
sm_endPoint = bytes(self.m_endPoint, encoding='utf-8')
|
|
sm_planeNormalDirection = bytes(self.m_planeNormalDirection, encoding='utf-8')
|
|
|
|
mainWidgets.setSimulationFEMLumpedPortData(c_int(self.m_id),sm_portName,sm_selectedSurfaceData,sm_beginPoint,sm_endPoint,c_int(self.m_isIntergrationSet),sm_planeNormalDirection)
|
|
del self
|
|
|
|
class SimulationMOMWavePortData:
|
|
def __init__(self):
|
|
self.m_id = -1
|
|
self.m_portName = ""
|
|
self.m_directionOfPolarization = ""
|
|
self.m_directionOfPropagation = ""
|
|
self.m_surfaceCenter = ""
|
|
self.m_surfaceDataID = ""
|
|
self.m_expansionModel = 0
|
|
self.m_expansionData = ""
|
|
self.m_motivationModel = 0
|
|
self.m_motivationData = ""
|
|
self.m_isOppositeToNormalChecked = False
|
|
self.m_isAutoSetPolarization = False
|
|
self.m_polarizationDegree = 0
|
|
self.m_propogationArrowSize = 80
|
|
self.m_polarizationArrowSize = 80
|
|
self.m_surfaceType = 0
|
|
|
|
def setPortName(self, m_portName):
|
|
self.m_portName = m_portName
|
|
|
|
def setID(self, id):
|
|
self.m_id = id
|
|
|
|
def setSurfaceDataID(self, surfaceId):
|
|
self.m_surfaceDataID = surfaceId
|
|
|
|
def setDirectionOfPolarization(self, polarization):
|
|
self.m_directionOfPolarization = polarization
|
|
|
|
def setDirectionOfPropagation(self,propagation ):
|
|
self.m_directionOfPropagation = propagation
|
|
|
|
def setSurfaceCenter(self,surfaceCenter):
|
|
self.m_surfaceCenter = surfaceCenter
|
|
|
|
def setExpansionModel(self, expansionModel):
|
|
self.m_expansionModel = expansionModel
|
|
|
|
def setExpansionData(self, expansionData):
|
|
self.m_expansionData = expansionData
|
|
|
|
def setMotivationModel(self, motivationModel):
|
|
self.m_motivationModel = motivationModel
|
|
|
|
def setMotivationData(self, motivationData):
|
|
self.m_motivationData = motivationData
|
|
|
|
def setIsOppositeToNormalChecked(self, checked):
|
|
self.m_isOppositeToNormalChecked = checked
|
|
|
|
def setIsAutoSetPolarization(self, isAuto):
|
|
self.m_isAutoSetPolarization = isAuto
|
|
|
|
def setPolarizationDegree(self, degree):
|
|
self.m_polarizationDegree = degree
|
|
|
|
def setPropogationArrowSize(self, propogationArrowSize):
|
|
self.m_propogationArrowSize = propogationArrowSize
|
|
|
|
def setPolarizationArrowSize(self, polarizationArrowSize):
|
|
self.m_polarizationArrowSize = polarizationArrowSize
|
|
|
|
def setSurfaceType(self, surfaceType):
|
|
self.m_surfaceType = surfaceType
|
|
|
|
def save(self):
|
|
sm_surfaceDataID = bytes(self.m_surfaceDataID, encoding='utf-8')
|
|
sm_directionOfPolarization = bytes(self.m_directionOfPolarization, encoding='utf-8')
|
|
sm_directionOfPropagation = bytes(self.m_directionOfPropagation, encoding='utf-8')
|
|
sm_surfaceCenter = bytes(self.m_surfaceCenter, encoding='utf-8')
|
|
sm_expansionData = bytes(self.m_expansionData, encoding='utf-8')
|
|
sm_motivationData = bytes(self.m_motivationData, encoding='utf-8')
|
|
sm_portName = bytes(self.m_portName, encoding='utf-8')
|
|
mainWidgets.setSimulationMOMWavePortData(c_int(self.m_id), sm_surfaceDataID,c_int(self.m_surfaceType), sm_portName,sm_directionOfPolarization, sm_directionOfPropagation, sm_surfaceCenter, self.m_expansionModel,sm_expansionData,self.m_motivationModel,sm_motivationData,
|
|
c_bool(self.m_isOppositeToNormalChecked),c_bool(self.m_isAutoSetPolarization), c_int(self.m_polarizationDegree),c_double(self.m_propogationArrowSize),c_double(self.m_polarizationArrowSize))
|
|
del self
|
|
|
|
|
|
class SimulationFEMWavePortData:
|
|
def __init__(self):
|
|
self.m_id = -1
|
|
self.m_wavePortType = "Circular_waveport"
|
|
self.m_modeCount = 1
|
|
self.m_portName = ""
|
|
self.m_width = 1
|
|
self.m_portImpedance = 1
|
|
self.m_beginPoint = ""
|
|
self.m_endPoint = ""
|
|
self.m_selectedSurfaceData = ""
|
|
self.m_isIntergrationLineSet = False
|
|
self.m_planeNormalDirection = ""
|
|
|
|
def setID(self, id):
|
|
self.m_id = id
|
|
|
|
def setWavePortType(self, wavePortType):
|
|
self.m_wavePortType = wavePortType
|
|
|
|
def setModeCount(self, modeCount):
|
|
self.m_modeCount = modeCount
|
|
|
|
def setPortName(self, portName):
|
|
self.m_portName = portName
|
|
|
|
def setWidth(self, width):
|
|
self.m_width = width
|
|
|
|
def setPortImpedance(self, portImpedance):
|
|
self.m_portImpedance = portImpedance
|
|
|
|
def setBeginPoint(self, beginPoint):
|
|
self.m_beginPoint = beginPoint
|
|
|
|
def setEndPoint(self, endPoint):
|
|
self.m_endPoint = endPoint
|
|
|
|
def setSelectedSurfaceData(self, surfaceData):
|
|
self.m_selectedSurfaceData = surfaceData
|
|
|
|
def setIntergrationLineState(self, state):
|
|
self.m_isIntergrationLineSet = state
|
|
|
|
def setPlaneNormalDirection(self, planeNormalDirection):
|
|
self.m_planeNormalDirection = planeNormalDirection
|
|
|
|
def save(self):
|
|
sm_beginPoint = bytes(self.m_beginPoint, encoding='utf-8')
|
|
sm_endPoint = bytes(self.m_endPoint, encoding='utf-8')
|
|
sm_selectedSurfaceData = bytes(self.m_selectedSurfaceData, encoding='utf-8')
|
|
sm_wavePortType = bytes(self.m_wavePortType, encoding='utf-8')
|
|
sm_portName = bytes(self.m_portName, encoding='utf-8')
|
|
sm_planeNormalDirection = bytes(self.m_planeNormalDirection, encoding='utf-8')
|
|
|
|
mainWidgets.setSimulationFEMWavePortData(c_int(self.m_id), sm_wavePortType, c_int(self.m_modeCount), sm_portName, c_double(self.m_width),
|
|
c_double(self.m_portImpedance), sm_beginPoint, sm_endPoint, sm_selectedSurfaceData, c_bool(self.m_isIntergrationLineSet),sm_planeNormalDirection)
|
|
del self
|
|
|
|
class SimulationFEMVoltageSourceData:
|
|
def __init__(self):
|
|
self.m_id = -1
|
|
self.m_portName = ""
|
|
self.m_portImpedance = 1
|
|
self.m_beginPoint = ""
|
|
self.m_endPoint = ""
|
|
self.m_selectedSurfaceData = ""
|
|
self.m_isIntergrationLineSet = False
|
|
self.m_planeNormal = ""
|
|
|
|
def setID(self, id):
|
|
self.m_id = id
|
|
|
|
def setPortName(self, portName):
|
|
self.m_portName = portName
|
|
|
|
def setPortImpedance(self, portImpedance):
|
|
self.m_portImpedance = portImpedance
|
|
|
|
def setBeginPoint(self, beginPoint):
|
|
self.m_beginPoint = beginPoint
|
|
|
|
def setEndPoint(self, endPoint):
|
|
self.m_endPoint = endPoint
|
|
|
|
def setSelectedSurfaceData(self, surfaceData):
|
|
self.m_selectedSurfaceData = surfaceData
|
|
|
|
def setIntergrationLineState(self, state):
|
|
self.m_isIntergrationLineSet = state
|
|
|
|
def setPlaneNormal(self, planeNormal):
|
|
self.m_planeNormal = planeNormal
|
|
|
|
def save(self):
|
|
sm_beginPoint = bytes(self.m_beginPoint, encoding='utf-8')
|
|
sm_endPoint = bytes(self.m_endPoint, encoding='utf-8')
|
|
sm_selectedSurfaceData = bytes(self.m_selectedSurfaceData, encoding='utf-8')
|
|
sm_planeNormal = bytes(self.m_planeNormal, encoding='utf-8')
|
|
sm_portName = bytes(self.m_portName, encoding='utf-8')
|
|
mainWidgets.setSimulationFEMVoltageSourceData(c_int(self.m_id), sm_portName, c_double(self.m_portImpedance),
|
|
sm_beginPoint, sm_endPoint, sm_selectedSurfaceData, c_bool(self.m_isIntergrationLineSet),sm_planeNormal)
|
|
del self
|
|
|
|
class SimulationFEMPlaneWaveData:
|
|
def __init__(self):
|
|
self.m_id = -1
|
|
self.m_portName = ""
|
|
self.m_position = ""
|
|
self.m_electricFieldDirection = ""
|
|
self.m_spreadDirection = ""
|
|
self.m_coordinateSystem = 0
|
|
self.m_IWavePhiEnd = 0
|
|
self.m_IWavePhiStart = 0
|
|
self.m_IWavePhiStep = 1
|
|
self.m_IWaveThetaEnd = 360
|
|
self.m_IWaveThetaStart = 0
|
|
self.m_IWaveThetaStep = 1
|
|
self.m_phiCoff = 1
|
|
self.m_thetaCoff = 0
|
|
self.m_monostaticRCSSolution = 0
|
|
self.m_interpolationPara = 0
|
|
|
|
def setID(self, id):
|
|
self.m_id = id
|
|
|
|
def setPortName(self, portName):
|
|
self.m_portName = portName
|
|
|
|
def setPosition(self, position):
|
|
self.m_position = position
|
|
|
|
def setElectricFieldDirection(self, electricFieldDirection):
|
|
self.m_electricFieldDirection = electricFieldDirection
|
|
|
|
def setSpreadDirection(self, spreadDirection):
|
|
self.m_spreadDirection = spreadDirection
|
|
|
|
def setCoordinateSystem(self,coordinateSystem):
|
|
self.m_coordinateSystem = coordinateSystem
|
|
|
|
def setIWavePhiEnd(self,IWavePhiEnd):
|
|
self.m_IWavePhiEnd = IWavePhiEnd
|
|
|
|
def setIWavePhiStep(self,IWavePhiStep):
|
|
self.m_IWavePhiStep = IWavePhiStep
|
|
|
|
def setIWavePhiStart(self,IWavePhiStart):
|
|
self.m_IWavePhiStart = IWavePhiStart
|
|
|
|
def setIWaveThetaEnd(self,IWaveThetaEnd):
|
|
self.m_IWaveThetaEnd = IWaveThetaEnd
|
|
|
|
def setIWaveThetaStart(self,IWaveThetaStart):
|
|
self.m_IWaveThetaStart = IWaveThetaStart
|
|
|
|
def setIWaveThetaStep(self,IWaveThetaStep):
|
|
self.m_IWaveThetaStep = IWaveThetaStep
|
|
|
|
def setPhiCoff(self,phiCoff):
|
|
self.m_phiCoff = phiCoff
|
|
|
|
def setThetaCoff(self,thetaCoff):
|
|
self.m_thetaCoff = thetaCoff
|
|
|
|
def setMonostaticRCSSolution(self,monostaticRCSSolution):
|
|
self.m_monostaticRCSSolution = monostaticRCSSolution
|
|
|
|
def setInterpolationPara(self,interpolationPara):
|
|
self.m_interpolationPara = interpolationPara
|
|
|
|
def save(self):
|
|
sm_portName = bytes(self.m_portName, encoding='utf-8')
|
|
sm_position = bytes(self.m_position, encoding='utf-8')
|
|
sm_electricFieldDirection = bytes(self.m_electricFieldDirection, encoding='utf-8')
|
|
sm_spreadDirection = bytes(self.m_spreadDirection, encoding='utf-8')
|
|
mainWidgets.setSimulationFEMPlaneWavaData(c_int(self.m_id),sm_portName,sm_position,sm_electricFieldDirection,sm_spreadDirection,c_int(self.m_coordinateSystem),
|
|
c_int(self.m_IWavePhiEnd),c_int(self.m_IWavePhiStart),c_int(self.m_IWavePhiStep),c_int(self.m_IWaveThetaEnd),c_int(self.m_IWaveThetaStart),c_int(self.m_IWaveThetaStep),
|
|
c_double(self.m_phiCoff),c_double(self.m_thetaCoff),c_double(self.m_monostaticRCSSolution),c_double(self.m_interpolationPara))
|
|
del self
|
|
|
|
class SimulationMOMPlaneWaveData:
|
|
def __init__(self):
|
|
self.m_id = -1
|
|
self.m_portName = ""
|
|
self.m_magnitude = 0
|
|
self.m_phase = 0
|
|
self.m_polarizationAngle = 0
|
|
self.m_incidentWaveType = 0
|
|
self.m_propagationTheta = 0
|
|
self.m_propagationPhi = 0
|
|
self.m_startTheta = 0
|
|
self.m_startPhi = 0
|
|
self.m_endTheta = 0
|
|
self.m_endPhi = 0
|
|
self.m_intervalTheta = 0
|
|
self.m_intervalPhi = 0
|
|
|
|
def setID(self, id):
|
|
self.m_id = id
|
|
|
|
def setPortName(self, portName):
|
|
self.m_portName = portName
|
|
|
|
def setMagnitude(self,magnitude):
|
|
self.m_magnitude = magnitude
|
|
|
|
def setPhase(self,phase):
|
|
self.m_phase = phase
|
|
|
|
def setPolarizationAngle(self,polarizationAngle):
|
|
self.m_polarizationAngle = polarizationAngle
|
|
|
|
def setIncidentWaveType(self,incidentWaveType):
|
|
self.m_incidentWaveType = incidentWaveType
|
|
|
|
def setPropagationTheta(self,propagationTheta):
|
|
self.m_propagationTheta = propagationTheta
|
|
|
|
def setPropagationPhi(self,propagationPhi):
|
|
self.m_propagationPhi = propagationPhi
|
|
|
|
def setStartTheta(self,startTheta):
|
|
self.m_startTheta = startTheta
|
|
|
|
def setStartPhi(self,startPhi):
|
|
self.m_startPhi = startPhi
|
|
|
|
def setEndTheta(self,endTheta):
|
|
self.m_endTheta = endTheta
|
|
|
|
def setEndPhi(self,endPhi):
|
|
self.m_endPhi = endPhi
|
|
|
|
def setIntervalTheta(self,intervalTheta):
|
|
self.m_intervalTheta = intervalTheta
|
|
|
|
def setIntervalPhi(self,intervalPhi):
|
|
self.m_intervalPhi = intervalPhi
|
|
|
|
def save(self):
|
|
sm_portName = bytes(self.m_portName, encoding='utf-8')
|
|
mainWidgets.setSimulationMOMPlaneWavaData(c_int(self.m_id),sm_portName,c_double(self.m_magnitude),c_double(self.m_phase),c_double(self.m_polarizationAngle),c_int(self.m_incidentWaveType),
|
|
c_double(self.m_propagationTheta),c_double(self.m_propagationPhi),c_double(self.m_startTheta),c_double(self.m_startPhi),c_double(self.m_endTheta),c_double(self.m_endPhi),c_double(self.m_intervalTheta),c_double(self.m_intervalPhi))
|
|
del self
|
|
|
|
class SimulationBoundaryConditionData:
|
|
def __init__(self):
|
|
self.m_id = -1
|
|
self.m_boundaryConditionName = ""
|
|
self.m_boundaryConditionType = ""
|
|
self.m_PMLWidth = 1.0
|
|
self.m_resistance = 50
|
|
self.m_reactance = 50
|
|
self.m_bodyData = ""
|
|
self.m_surfaceData = ""
|
|
# master boundary condition
|
|
self.m_masterSurfaceID = ""
|
|
self.m_masterBeginPoint = ""
|
|
self.m_masterEndPoint = ""
|
|
self.m_masterThirdPoint = ""
|
|
self.m_masterNormalDirection = ""
|
|
self.m_masterChosenStatus = ""
|
|
# slave boundary condition
|
|
self.m_slaveSurfaceID = ""
|
|
self.m_slaveBeginPoint = ""
|
|
self.m_slaveEndPoint = ""
|
|
self.m_slaveThirdPoint = ""
|
|
self.m_slaveNormalDirection = ""
|
|
self.m_slaveChosenStatus = ""
|
|
|
|
def setID(self, id):
|
|
self.m_id = id
|
|
|
|
def setBoundaryConditionName(self, name):
|
|
self.m_boundaryConditionName = name
|
|
|
|
def setBoundaryConditionType(self, type):
|
|
self.m_boundaryConditionType = type
|
|
|
|
def setPMLWidth(self, width):
|
|
self.m_PMLWidth = width
|
|
|
|
def setResistance(self, resistance):
|
|
self.m_resistance = resistance
|
|
|
|
def setReactance(self, reactance):
|
|
self.m_reactance = reactance
|
|
|
|
def setSelectedBodyData(self, bodyData):
|
|
self.m_bodyData = bodyData
|
|
|
|
def setSelectedSurfaceData(self, surfaceData):
|
|
self.m_surfaceData = surfaceData
|
|
|
|
# master boundary condition
|
|
def setSelectedMasterSurfaceID(self, surfaceData):
|
|
self.m_masterSurfaceID = surfaceData
|
|
|
|
def setMasterBeginPoint(self, beginPoint):
|
|
self.m_masterBeginPoint = beginPoint
|
|
|
|
def setMasterEndPoint(self, endPoint):
|
|
self.m_masterEndPoint = endPoint
|
|
|
|
def setMasterThirdPoint(self, thirdPoint):
|
|
self.m_masterThirdPoint = thirdPoint
|
|
|
|
def setMasterNormalDirection(self, normalDirection):
|
|
self.m_masterNormalDirection = normalDirection
|
|
|
|
def setMasterChosenStatus(self, status):
|
|
self.m_masterChosenStatus = status
|
|
|
|
# slave boundary condition
|
|
def setSelectedSlaveSurfaceID(self, surfaceData):
|
|
self.m_slaveSurfaceID = surfaceData
|
|
|
|
def setSlaveBeginPoint(self, beginPoint):
|
|
self.m_slaveBeginPoint = beginPoint
|
|
|
|
def setSlaveEndPoint(self, endPoint):
|
|
self.m_slaveEndPoint = endPoint
|
|
|
|
def setSlaveThirdPoint(self, thirdPoint):
|
|
self.m_slaveThirdPoint = thirdPoint
|
|
|
|
def setSlaveNormalDirection(self, normalDirection):
|
|
self.m_slaveNormalDirection = normalDirection
|
|
|
|
def setSlaveChosenStatus(self, status):
|
|
self.m_slaveChosenStatus = status
|
|
|
|
def save(self):
|
|
sm_boundaryConditionName = bytes(self.m_boundaryConditionName, encoding='utf-8')
|
|
sm_boundaryConditionType = bytes(self.m_boundaryConditionType, encoding='utf-8')
|
|
sm_bodyData = bytes(self.m_bodyData, encoding='utf-8')
|
|
sm_surfaceData = bytes(self.m_surfaceData, encoding='utf-8')
|
|
# master boundary condition
|
|
sm_masterSurfaceID = bytes(self.m_masterSurfaceID, encoding='utf-8')
|
|
sm_masterBeginPoint = bytes(self.m_masterBeginPoint, encoding='utf-8')
|
|
sm_masterEndPoint = bytes(self.m_masterEndPoint, encoding='utf-8')
|
|
sm_masterThirdPoint = bytes(self.m_masterThirdPoint, encoding='utf-8')
|
|
sm_masterNormalDirection = bytes(self.m_masterNormalDirection, encoding='utf-8')
|
|
sm_masterChosenStatus = bytes(self.m_masterChosenStatus, encoding='utf-8')
|
|
# slave boundary condition
|
|
sm_slaveSurfaceID = bytes(self.m_slaveSurfaceID, encoding='utf-8')
|
|
sm_slaveBeginPoint = bytes(self.m_slaveBeginPoint, encoding='utf-8')
|
|
sm_slaveEndPoint = bytes(self.m_slaveEndPoint, encoding='utf-8')
|
|
sm_slaveThirdPoint = bytes(self.m_slaveThirdPoint, encoding='utf-8')
|
|
sm_slaveNormalDirection = bytes(self.m_slaveNormalDirection, encoding='utf-8')
|
|
sm_slaveChosenStatus = bytes(self.m_slaveChosenStatus, encoding='utf-8')
|
|
|
|
mainWidgets.setBoundaryConditionData(c_int(self.m_id),sm_boundaryConditionName,sm_boundaryConditionType,c_double(self.m_PMLWidth),c_double(self.m_resistance),c_double(self.m_reactance),sm_bodyData,sm_surfaceData,
|
|
sm_masterSurfaceID, sm_masterBeginPoint, sm_masterEndPoint, sm_masterThirdPoint, sm_masterNormalDirection,sm_masterChosenStatus,
|
|
sm_slaveSurfaceID, sm_slaveBeginPoint, sm_slaveEndPoint, sm_slaveThirdPoint, sm_slaveNormalDirection,sm_slaveChosenStatus)
|
|
del self
|
|
|
|
class SimulationFEMFarFieldCoordinateData():
|
|
def __init__(self):
|
|
self.m_phiStart = 0.0
|
|
self.m_phiEnd = 0.0
|
|
self.m_phiStep = 0.0
|
|
self.m_thetaStart = 0.0
|
|
self.m_thetaEnd = 0.0
|
|
self.m_thetaStep = 0.0
|
|
|
|
def setPhiStart(self,phiStart):
|
|
self.m_phiStart = phiStart
|
|
|
|
def setPhiEnd(self,phiEnd):
|
|
self.m_phiEnd = phiEnd
|
|
|
|
def setPhiStep(self,phiStep):
|
|
self.m_phiStep = phiStep
|
|
|
|
def setThetaStart(self,thetaStart):
|
|
self.m_thetaStart = thetaStart
|
|
|
|
def setThetaEnd(self,thetaEnd):
|
|
self.m_thetaEnd = thetaEnd
|
|
|
|
def setThetaStep(self,thetaStep):
|
|
self.m_thetaStep = thetaStep
|
|
|
|
def save(self):
|
|
mainWidgets.setSimulationFEMFarFieldCoordinateData(c_double(self.m_thetaStart),c_double(self.m_thetaEnd),c_double(self.m_thetaStep),
|
|
c_double(self.m_phiStart),c_double(self.m_phiEnd),c_double(self.m_phiStep))
|
|
del self
|
|
|
|
class SimulationMOMFarFieldCoordinateData():
|
|
def __init__(self):
|
|
self.m_phiStart = 0.0
|
|
self.m_phiEnd = 0.0
|
|
self.m_phiStep = 0.0
|
|
self.m_thetaStart = 0.0
|
|
self.m_thetaEnd = 0.0
|
|
self.m_thetaStep = 0.0
|
|
|
|
def setPhiStart(self,phiStart):
|
|
self.m_phiStart = phiStart
|
|
|
|
def setPhiEnd(self,phiEnd):
|
|
self.m_phiEnd = phiEnd
|
|
|
|
def setPhiStep(self,phiStep):
|
|
self.m_phiStep = phiStep
|
|
|
|
def setThetaStart(self,thetaStart):
|
|
self.m_thetaStart = thetaStart
|
|
|
|
def setThetaEnd(self,thetaEnd):
|
|
self.m_thetaEnd = thetaEnd
|
|
|
|
def setThetaStep(self,thetaStep):
|
|
self.m_thetaStep = thetaStep
|
|
|
|
def save(self):
|
|
mainWidgets.setSimulationMOMFarFieldCoordinateData(c_double(self.m_thetaStart),c_double(self.m_thetaEnd),c_double(self.m_thetaStep),
|
|
c_double(self.m_phiStart),c_double(self.m_phiEnd),c_double(self.m_phiStep))
|
|
del self
|
|
|
|
#近场坐标设置
|
|
class SimulationMOMNearFieldCoordinateData():
|
|
def __init__(self):
|
|
self.m_startX = 0.0
|
|
self.m_startY = 0.0
|
|
self.m_startZ = 0.0
|
|
self.m_endX = 0.0
|
|
self.m_endY = 0.0
|
|
self.m_endZ = 0.0
|
|
self.m_stepX = 0.0
|
|
self.m_stepY = 0.0
|
|
self.m_stepZ = 0.0
|
|
|
|
def setStart(self,x,y,z):
|
|
self.m_startX = x
|
|
self.m_startY = y
|
|
self.m_startZ = z
|
|
|
|
def setEnd(self,x,y,z):
|
|
self.m_endX = x
|
|
self.m_endY = y
|
|
self.m_endZ = z
|
|
|
|
def setStep(self,x,y,z):
|
|
self.m_stepX = x
|
|
self.m_stepY = y
|
|
self.m_stepZ = z
|
|
|
|
def save(self):
|
|
mainWidgets.setSimulationMOMNearFieldCoordinateData(c_double(self.m_startX),c_double(self.m_startY),c_double(self.m_startZ),c_double(self.m_endX),c_double(self.m_endY),c_double(self.m_endZ),c_double(self.m_stepX),c_double(self.m_stepY),c_double(self.m_stepZ))
|
|
del self
|