rep1/bin/pyScripts/MainWidgets.py

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