Пример #1
0
        // 코일에 대한 문자열 라인을 넘겨 받아서 코일 객체를 초기화 한다.
        public bool readObject(List <string> listStringLines)
        {
            CReadFile readFile = new CReadFile();
            string    strTemp;

            string[] arrayString;

            List <string> listInformationLines = new List <string>();
            List <string> listShapeLines       = new List <string>();

            bool bShapeLine = false;

            if (m_kindKey != EMKind.COIL)
            {
                CNotice.printTraceID("YATT7");
                return(false);
            }

            try
            {
                // Shape 라인과 정보 라인을 분리한다.
                foreach (string strLine in listStringLines)
                {
                    if (readFile.isEndLine(strLine) == "Shape")
                    {
                        bShapeLine = false;
                    }

                    if (bShapeLine == true)
                    {
                        listShapeLines.Add(strLine);
                    }
                    else
                    {
                        if (readFile.isBeginLine(strLine) == "Shape")
                        {
                            bShapeLine = true;
                        }
                        else
                        {
                            listInformationLines.Add(strLine);
                        }
                    }
                }

                // 정보 라인을 처리한다.
                foreach (string strLine in listInformationLines)
                {
                    strTemp = strLine.Trim('\t');

                    arrayString = strTemp.Split('=');


                    switch (arrayString[0])
                    {
                    // CNode
                    case "NodeName":
                        NodeName = arrayString[1];
                        break;

                    case "KindKey":
                        m_kindKey = (EMKind)Enum.Parse(typeof(EMKind), arrayString[1]);
                        break;

                    // CParts
                    case "MovingParts":
                        MovingPart = (EMMoving)Enum.Parse(typeof(EMMoving), arrayString[1]);
                        break;

                    // CCoil
                    case "Material":
                        Material = arrayString[1];
                        break;

                    case "CurrentDirection":
                        CurrentDirection = (EMCurrentDirection)Enum.Parse(typeof(EMCurrentDirection), arrayString[1]);
                        break;

                    case "Turns":
                        Turns = Convert.ToInt16(arrayString[1]);
                        break;

                    case "Resistance":
                        Resistance = Convert.ToDouble(arrayString[1]);
                        break;

                    case "Layers":
                        Layers = Convert.ToInt16(arrayString[1]);
                        break;

                    case "TurnsOfOneLayer":
                        TurnsOfOneLayer = Convert.ToInt16(arrayString[1]);
                        break;

                    case "CoilWireGrade":
                        CoilWireGrade = (EMCoilWireGrade)Enum.Parse(typeof(EMCoilWireGrade), arrayString[1]);
                        break;

                    case "InnerDiameter":
                        InnerDiameter = Convert.ToDouble(arrayString[1]);
                        break;

                    case "OuterDiameter":
                        OuterDiameter = Convert.ToDouble(arrayString[1]);
                        break;

                    case "Height":
                        Height = Convert.ToDouble(arrayString[1]);
                        break;

                    case "CopperDiameter":
                        CopperDiameter = Convert.ToDouble(arrayString[1]);
                        break;

                    case "WireDiameter":
                        WireDiameter = Convert.ToDouble(arrayString[1]);
                        break;

                    case "Temperature":
                        Temperature = Convert.ToDouble(arrayString[1]);
                        break;

                    case "HorizontalCoefficient":
                        HorizontalCoefficient = Convert.ToDouble(arrayString[1]);
                        break;

                    case "VerticalCoefficient":
                        VerticalCoefficient = Convert.ToDouble(arrayString[1]);
                        break;

                    case "ResistanceCoefficient":
                        ResistanceCoefficient = Convert.ToDouble(arrayString[1]);
                        break;

                    default:
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
                return(false);
            }

            return(true);
        }
Пример #2
0
        // 코일에 대한 문자열 라인을 넘겨 받아서 코일 객체를 초기화 한다.
        public bool readObject(List <string> listStringLines)
        {
            CReadFile readFile = new CReadFile();
            string    strTemp;

            string[] arrayString;

            List <string> listInformationLines = new List <string>();
            List <string> listShapeLines       = new List <string>();

            bool bShapeLine = false;

            if (m_kindKey != EMKind.STEEL)
            {
                CNotice.printTraceID("YATT6");
                return(false);
            }

            try
            {
                // Shape 라인과 정보 라인을 분리한다.
                foreach (string strLine in listStringLines)
                {
                    if (readFile.isEndLine(strLine) == "Shape")
                    {
                        bShapeLine = false;
                    }

                    if (bShapeLine == true)
                    {
                        listShapeLines.Add(strLine);
                    }
                    else
                    {
                        if (readFile.isBeginLine(strLine) == "Shape")
                        {
                            bShapeLine = true;
                        }
                        else
                        {
                            listInformationLines.Add(strLine);
                        }
                    }
                }

                // 정보 라인을 처리한다.
                foreach (string strLine in listInformationLines)
                {
                    strTemp = strLine.Trim('\t');

                    arrayString = strTemp.Split('=');

                    if (arrayString.Length != 2)
                    {
                        CNotice.noticeWarningID("TIAP5");
                        return(false);
                    }

                    switch (arrayString[0])
                    {
                    // CNode
                    case "NodeName":
                        NodeName = arrayString[1];
                        break;

                    case "KindKey":
                        m_kindKey = (EMKind)Enum.Parse(typeof(EMKind), arrayString[1]);
                        break;

                    // CParts
                    case "MovingParts":
                        MovingPart = (EMMoving)Enum.Parse(typeof(EMMoving), arrayString[1]);
                        break;

                    // CSteel
                    case "Material":
                        Material = arrayString[1];
                        break;

                    default:
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
                return(false);
            }

            return(true);
        }
Пример #3
0
        public static void runScript(string strCmd, string strArgs, bool bWaiting = false, ProgressBar progressBar = null)
        {
            //------------------------------------------------------------
            // runProcess 호출 예제
            //------------------------------------------------------------

            //// Process 의 Arguments 에서 스페이스 문제가 발생한다.
            //// 아래와 같이 묶음처리를 사용한다.
            //string strArguments = " " + m_manageFile.solveDirectoryNameInPC(strRunScriptFileFullNameMaxwell);

            //runScript(strMaxwellFileFullName, strArguments, m_strRunScriptFileFullName, true, progressBarMovement);

            //progressBarMovement.Value = progressBarTime.Maximum;
            //------------------------------------------------------------

            try
            {
                m_process = new System.Diagnostics.Process();
                m_process.StartInfo.FileName  = strCmd;
                m_process.StartInfo.Arguments = strArgs;

                // 자속밀도의 그림이 범례의 문제가 없으려면 Maxwell 이 최대화가 되어야 한다.
                //
                //m_process.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Maximized;
                m_process.Start();

                // 프로세스를 기다리게 설정된 경우만 사용된다.
                if (bWaiting == true)
                {
                    // ProgressBar 동작없이 기다리는 프로세스
                    if (progressBar == null)
                    {
                        // 작업을 마칠때 까지 기다린다
                        m_process.WaitForExit();

                        // 중간 중간에 이벤트를 받을 수 있도록 한다
                        System.Windows.Forms.Application.DoEvents();
                    }
                    // ProgressBar 동작을 하며 기다리는 프로세스
                    else
                    {
                        while (!m_process.HasExited)
                        {
                            progressBar.PerformStep();

                            if (progressBar.Value == progressBar.Maximum)
                            {
                                progressBar.Value = 0;
                            }

                            Thread.Sleep(500);
                        }
                    }
                }

                // 약간의 지연시간이 있어야 창크기의 조절이 가능하다
                //Thread.Sleep(100);
                //MoveWindow(m_process.MainWindowHandle, 300, 300, 1024, 768, true);

                //const int SW_MAXIMIZE = 3;
                //ShowWindow(m_process.MainWindowHandle, SW_MAXIMIZE);
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
            }
        }
Пример #4
0
        public void designCoil()
        {
            if (InnerDiameter <= 0.0f)
            {
                CNotice.noticeWarningID("TIDV");
                return;
            }

            if (OuterDiameter <= 0.0f)
            {
                CNotice.noticeWarningID("TODV");
                return;
            }

            if (OuterDiameter <= InnerDiameter)
            {
                CNotice.noticeWarningID("ODSB");
                return;
            }

            if (Height <= 0.0f)
            {
                CNotice.noticeWarningID("CHVI");
                return;
            }

            if (CopperDiameter <= 0.0f)
            {
                CNotice.noticeWarningID("ETCD");
                return;
            }

            if (HorizontalCoefficient <= 0.0f)
            {
                CNotice.noticeWarningID("ETVF");
                return;
            }

            if (VerticalCoefficient <= 0.0f)
            {
                CNotice.noticeWarningID("ETVF2");
                return;
            }

            if (ResistanceCoefficient <= 0.0f)
            {
                CNotice.noticeWarningID("ETVF1");
                return;
            }

            try
            {
                //*****************************************************************************
                // 수식계산에서 발생하는 예외처리를 하라.
                //*****************************************************************************
                double dCoilAvgDiameter = (InnerDiameter + OuterDiameter) / 2.0f;
                double dWidth           = Math.Abs(OuterDiameter - InnerDiameter) / 2.0f;

                // 동선경을 선택해서 WireDiameter 가 설정이 되지 않는 경우 여기서 자동 계산한다.
                if (WireDiameter == 0.0f)
                {
                    WireDiameter = calculateWireDiameter();
                }

                int iHorizontal_N = (int)((1 / HorizontalCoefficient) * (dWidth / WireDiameter));
                int iVirtical_N   = (int)((1 / VerticalCoefficient) * (Height / WireDiameter));

                // 수평 적층 수가 짝수가 아니면 한층을 뺀다. (짝수 정렬만 가능하다)
                if (iHorizontal_N % 2 != 0)
                {
                    iHorizontal_N -= 1;
                }

                this.Turns           = iHorizontal_N * iVirtical_N;
                this.TurnsOfOneLayer = iVirtical_N;
                this.Layers          = iHorizontal_N;

                double dWireLength = Math.PI * this.Turns * dCoilAvgDiameter;

                // IEC 317, 단위 저항 보간
                double res_a = 0.0, res_b = 0.0, res_c = 0.0;

                // 온도 계수
                double dTemperatureCoefficient = 0.0f;

                if (m_strMaterial == "Copper")
                {
                    // IEC 317, 단위 저항 보간
                    res_a = 0.021771473f;
                    res_b = 0.99730833f;
                    res_c = -1.9999322f;

                    // 온도 계수
                    dTemperatureCoefficient = 0.004041f;
                }
                // 두가지 밖에 없어서 알루미늄의 경우이다.
                else if (m_strMaterial == "Aluminum")
                {
                    // IEC 317, 단위 저항 보간
                    res_a = 0.036438f;
                    res_b = 0.981116f;
                    res_c = -1.995774f;

                    // 온도 계수
                    dTemperatureCoefficient = 0.004308f;
                }
                else
                {
                    CNotice.printTraceID("TIAP1");
                    return;
                }


                double dResistancePerMeter = res_a * (Math.Pow(res_b, CopperDiameter) * Math.Pow(CopperDiameter, res_c));

                dResistancePerMeter = (1 + dTemperatureCoefficient * (this.Temperature - 20.0f)) * dResistancePerMeter;
                this.Resistance     = dResistancePerMeter * dWireLength * ResistanceCoefficient;

                this.Resistance = this.Resistance / 1000.0f;
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
            }
        }
Пример #5
0
        /// <summary>
        /// 형상 입력때나 수정때 형상을 다시 그린다
        ///  - 수정 부품만 빼고 타 부품들은 다시 그리고, 수정 부품은 창에 기록된 값을 그린다.
        /// </summary>
        /// <param name="pointControl">좌표점 PointControl</param>
        /// <param name="bRedraw">형상 수정이 없어도 강제로 ARC 변경때 강제로 수정함</param>
        internal void drawTemporaryFace(CPointControl pointControl, bool bRedraw = false)
        {
            try
            {
                /// [문제]
                ///  - Form 에서는 Parent를 사용할 수 없어 Owner 속성을 사용하지만
                ///    종종 Owner 가 null 로 넘어오는 문제가 발생한다.
                /// [해결]
                ///  - PopupShape 창을 생성하기 전에 Owner 속성을 FormMain 으로 초기화 해 두어야
                ///    확실하게 FormMain 을 얻을 수 있다.
                FormMain formMain = ((FormMain)this.Owner);

                if (formMain == null)
                {
                    CNotice.printTraceID("CNGM");
                    return;
                }

                CScriptFEMM femm = formMain.m_femm;

                CNode nodeParts = formMain.m_design.getNode(m_strPartName);

                /// 0. 해당 좌표점의 수정이 있었는지를 판단한다.
                ///  - 수정이 있는 경우만 다시 그리기 위해서이다.
                bool retCheck = false;

                /// 초기 생성때는 이전 nodeParts 가 없음으로 사용하지 않고, 기존 노드의 수정때만 사용한다.
                if (nodeParts != null)
                {
                    /// 좌표 Control 에 빈칸이 존재하는 지를 확인함
                    for (int i = 0; i < ListPointControl.Count; i++)
                    {
                        /// 해당 좌표점만 비교한다.
                        /// 만약, Parts 의 모든 좌표점을 비교하면 다른 좌표점이 수정되었을때 나머지 좌표점의 수정이 없어도 다시 그리기가 된다.
                        if (ListPointControl[i] == pointControl)
                        {
                            if (((CParts)nodeParts).Face.RelativePointList[i].m_dX != Double.Parse(ListPointControl[i].StrCoordX.Trim()))
                            {
                                retCheck = true;
                            }

                            if (((CParts)nodeParts).Face.RelativePointList[i].m_dY != Double.Parse(ListPointControl[i].StrCoordY.Trim()))
                            {
                                retCheck = true;
                            }
                        }
                    }
                }

                // Arc 관련 이벤트 호출이면 강제로 다시그리기를 한다.
                if (bRedraw == true)
                {
                    retCheck = true;
                }

                if (retCheck == true)
                {
                    femm.deleteAll();

                    /// 1. 혹시 수정중이라면, 현재 작업 중인 Face 를 제외하고 형상 그리기
                    foreach (CNode node in formMain.m_design.NodeList)
                    {
                        if (node.GetType().BaseType.Name == "CParts")
                        {
                            if (node.NodeName != m_strPartName)
                            {
                                ((CParts)node).Face.drawFace(femm);
                            }
                        }
                    }
                }

                /// 2. 현재 수정중이거나 생성중인 Face 의 형상 그리기
                retCheck = true;

                /// 좌표 Control 에 빈칸이 존재하는 지를 확인함
                for (int i = 0; i < ListPointControl.Count; i++)
                {
                    if (ListPointControl[i].StrCoordX.Trim().Length == 0)
                    {
                        retCheck = false;
                    }

                    if (ListPointControl[i].StrCoordY.Trim().Length == 0)
                    {
                        retCheck = false;
                    }
                }

                double dBase_X, dBase_Y;
                dBase_X = dBase_Y = 0;

                dBase_X = Double.Parse(textBoxBaseX.Text.Trim());
                dBase_Y = Double.Parse(textBoxBaseY.Text.Trim());

                CFace face = null;

                // 모든 데이터가 입력된 경우는 폐곡선의 정상적인 Face 를 그린다.
                if (retCheck == true)
                {
                    face = makeFace();

                    if (null != face)
                    {
                        face.drawFace(femm);
                    }
                    else
                    {
                        CNotice.printTraceID("TSWN");
                    }
                }
                // 모든 데이터가 아직 입력되지 않은 상태는 입력중인 데이터만으로 그림을 그린다.
                else
                {
                    double dP1_X, dP1_Y, dP2_X, dP2_Y;

                    bool bArc, bArcDirection;

                    dP1_X = dP1_Y = dP2_X = dP2_Y = 0;
                    bArc  = bArcDirection = false;

                    for (int i = 0; i < ListPointControl.Count; i++)
                    {
                        retCheck = true;

                        if (ListPointControl[i].StrCoordX.Trim().Length == 0)
                        {
                            retCheck = false;
                        }
                        else
                        {
                            dP1_X = Double.Parse(ListPointControl[i].StrCoordX.Trim()) + dBase_X;
                        }

                        if (ListPointControl[i].StrCoordY.Trim().Length == 0)
                        {
                            retCheck = false;
                        }
                        else
                        {
                            dP1_Y = Double.Parse(ListPointControl[i].StrCoordY.Trim()) + dBase_Y;
                        }

                        /// X, Y 값이 모두 입력된 Point Control 인 경우
                        if (retCheck == true)
                        {
                            if (i == 0)
                            {
                                /// 사각형, 다각형 모두 적용된다.
                                femm.drawPoint(dP1_X, dP1_Y);
                            }
                            else
                            {
                                if (this.FaceType == EMFaceType.RECTANGLE)
                                {
                                    CNotice.printTraceID("ATTW");
                                }
                                /// 다각형만 적용된다.
                                /// 만약 사각형의 경우 i = 1 까지 모두 채워지면 모두 입력된 상태로 if 문의 위에처 처리되기 때문이다.
                                bArc          = ListPointControl[i].IsArc;
                                bArcDirection = ListPointControl[i].IsArcDirection;

                                if (bArc == true)
                                {
                                    femm.drawArc(dP2_X, dP2_Y, dP1_X, dP1_Y, bArcDirection);
                                }
                                else
                                {
                                    femm.drawLine(dP2_X, dP2_Y, dP1_X, dP1_Y);
                                }
                            }

                            // 이번 점을 이전 점으로 저장한다.
                            dP2_X = dP1_X;
                            dP2_Y = dP1_Y;
                        }
                        /// 채워지지 않은 좌표값을 발견하면 바로 빠져 나간다
                        else
                        {
                            break;
                        }
                    }
                }

                /// 선택된 좌표점을 붉은 색으로 표시한다.
                ///
                /// Base X, Y 변경 할때나 Leave 이벤트는 제외해야 함으로 null 을 넘겨오도록 되어 있다.
                if (pointControl != null)
                {
                    /// XY 값 모두 들어 있는 경우에만 표시를 한다.
                    if (pointControl.StrCoordX != "" && pointControl.StrCoordY != "")
                    {
                        CPoint selectedPoint = new CPoint();

                        selectedPoint.m_dX = Double.Parse(pointControl.StrCoordX) + dBase_X;
                        selectedPoint.m_dY = Double.Parse(pointControl.StrCoordY) + dBase_Y;

                        femm.clearSelected();

                        femm.selectPoint(selectedPoint);
                    }
                }
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
            }
        }
Пример #6
0
        private bool isInputDataOK()
        {
            bool bCheck;

            try
            {
                // 빈칸 확인으로 null 비교를 사용하지 말라. (.Length == 0 나 "" 를 사용하라)
                if (textBoxDesignName.Text.Length == 0)
                {
                    CNotice.noticeWarningID("PEAN");
                    return(false);
                }

                if (textBoxSTEPFileFullName.Text.Length == 0)
                {
                    if (CSettingData.m_emLanguage == EMLanguage.Korean)
                    {
                        CNotice.noticeWarning("STEP 파일을 선택해 주세요.");
                    }
                    else
                    {
                        CNotice.noticeWarning("You need to select a STEP file.");
                    }

                    return(false);
                }

                // 가능성은 낮지만 선택한 STEP 파일이 없는지를 검사한다.
                bCheck = m_manageFile.isExistFile(this.textBoxSTEPFileFullName.Text);
                if (bCheck == false)
                {
                    CNotice.printTrace("선택한 STEP 파일이 존재하지 않는다.");
                    return(false);
                }

                // 디자인을 무조건 프로그램 작업디렉토리에 생성하는 것으로 한다.
                // 따라서 디자인을 생성할 때의 적용버튼 임으로 작업 디렉토리는 프로그램 작업 디렉토리를 사용하고 있다.
                List <string> listDirectories = m_manageFile.getDirectoryList(CSettingData.m_strWorkingDirName);

                // 소문자로 비교하기 위해서 임시로 사용한다.
                string strOldTempName, strNewTempName;

                foreach (string directoryName in listDirectories)
                {
                    // 디렉토리 경로에 GetFileName 을 사용하면 가장 마지막 디렉토리가 넘어온다.
                    strOldTempName = Path.GetFileName(directoryName).ToLower();
                    strNewTempName = m_strDesignName.ToLower();

                    if (strOldTempName == strNewTempName)
                    {
                        // 기존 디자인이 이미 존재할 때 삭제하고 새롭게 시작할지를 물어 온다
                        DialogResult ret = CNotice.noticeWarningOKCancelID("TSDA", "W");

                        if (ret == DialogResult.OK)
                        {
                            m_manageFile.deleteDirectory(directoryName);
                            return(true);
                        }
                        else
                        {
                            return(false);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
                return(false);
            }

            return(true);
        }
Пример #7
0
        // Base Point 와 상대좌표로 좌표값이 저장되는 Face 가 생성된다.
        public CFace makeFace()
        {
            try
            {
                CFace face = new CFace();

                face.BasePoint.m_dX = Double.Parse(textBoxBaseX.Text);
                face.BasePoint.m_dY = Double.Parse(textBoxBaseY.Text);

                if (FaceType == EMFaceType.RECTANGLE)
                {
                    if (ListPointControl.Count != 2)
                    {
                        CNotice.printTraceID("TATP1");
                        return(null);
                    }

                    double x1, y1, x2, y2;

                    x1 = Double.Parse(ListPointControl[0].StrCoordX);
                    y1 = Double.Parse(ListPointControl[0].StrCoordY);
                    x2 = Double.Parse(ListPointControl[1].StrCoordX);
                    y2 = Double.Parse(ListPointControl[1].StrCoordY);

                    face.setRectanglePoints(x1, y1, x2, y2);
                }
                else
                {
                    if (ListPointControl.Count < 4)
                    {
                        CNotice.printTraceID("TANM");
                        return(null);
                    }

                    List <CPoint> listPoint = new List <CPoint>();

                    foreach (CPointControl pointControl in ListPointControl)
                    {
                        // 매번 신규로 생성을 해야 한다.
                        CPoint point = new CPoint();

                        point.m_dX = Double.Parse(pointControl.StrCoordX);
                        point.m_dY = Double.Parse(pointControl.StrCoordY);

                        if (pointControl.IsArc == true)
                        {
                            point.m_emLineKind = EMLineKind.ARC;
                        }
                        else
                        {
                            point.m_emLineKind = EMLineKind.STRAIGHT;
                        }

                        if (pointControl.IsArcDirection == true)
                        {
                            point.m_emDirectionArc = EMDirectionArc.BACKWARD;
                        }
                        else
                        {
                            point.m_emDirectionArc = EMDirectionArc.FORWARD;
                        }

                        listPoint.Add(point);
                    }

                    face.setPolygonPoints(listPoint);
                }

                return(face);
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
                return(null);
            }
        }
Пример #8
0
        /// <summary>
        /// 재귀호출을 사용해서 FACE 내부점을 찾아낸다.
        /// 재질 블럭점을 찾는 것이기 때문에 절대좌표를 사용해야 한다.
        ///
        /// 참고 사이트 : http://bowbowbow.tistory.com/24
        /// </summary>
        /// <param name="minX">내부점을 찾는 구간의 X 점 최소값</param>
        /// <param name="maxX">내부점을 찾는 구간의 X 점 최대값</param>
        /// <param name="baseY">내부 좌표값을 찾은 Y 위치 </param>
        /// <returns></returns>
        public CPoint findInsidePoint(CFace face, double minX, double maxX, double baseY)
        {
            int nRightIntersection = 0;
            int nLeftIntersection  = 0;

            int nRightPerchedPoint = 0;
            int nLeftPerchedPoint  = 0;

            // 자리수 정리
            minX  = round(minX);
            maxX  = round(maxX);
            baseY = round(baseY);

            double centerX = (minX + maxX) / 2.0f;

            CLine rightLine = new CLine();
            CLine leftLine  = new CLine();

            /// create a right check line
            rightLine.m_startPoint.m_dX = centerX;
            rightLine.m_startPoint.m_dY = baseY;
            rightLine.m_endPoint.m_dX   = maxX + 10.0f;  // 오른 검색선의 끝을 maxX 보다 10 크게 한다.
            rightLine.m_endPoint.m_dY   = baseY;

            /// create a left check line
            leftLine.m_startPoint.m_dX = centerX;
            leftLine.m_startPoint.m_dY = baseY;
            leftLine.m_endPoint.m_dX   = minX - 10.0f;  // 오른 검색선의 끝을 minX 보다 10 작게 한다.
            leftLine.m_endPoint.m_dY   = baseY;

            /// 매번 생성하는 Property 이기 때문에
            /// LineList 는 새로운 List에  담는 동작 한번만 호출하고, 사용은 새로운 List 를 사용한다.
            List <CLine> listAbsoluteLine = new List <CLine>();

            listAbsoluteLine = face.AbsoluteLineList;

            /// Face 의 선과 검색선의 교차점을 찾는다.
            foreach (CLine line in listAbsoluteLine)
            {
                if (true == isIntersected(line, rightLine))
                {
                    nRightIntersection++;
                }

                if (true == isIntersected(line, leftLine))
                {
                    nLeftIntersection++;
                }
            }

            /// 교차를 검사할때 Face 선의 양점은 고려하지 않는다.
            /// 따라서 검색선에 Face 선의 점을 지나치는 경우는 교차점이 인식되지 못한다.
            /// 라인의 양점이 검색선에 올가가는지도 추가로 검색한다.
            ///
            foreach (CLine line in listAbsoluteLine)
            {
                // 만약 시작과 끝이 같이 올라간 경우라면 검색선에 Face 선이 올라간 경우로 검색에서 제외한다.
                // 라인의 한점만 올라간 경우를 Perched Point 로 사용한다.
                if (true == isPerchedOnLine(rightLine, line.m_startPoint) && true == isPerchedOnLine(rightLine, line.m_endPoint))
                {
                    nRightPerchedPoint += 0;
                }
                else if (true == isPerchedOnLine(rightLine, line.m_startPoint))
                {
                    nRightPerchedPoint++;
                }
                else if (true == isPerchedOnLine(rightLine, line.m_endPoint))
                {
                    nRightPerchedPoint++;
                }

                if (true == isPerchedOnLine(leftLine, line.m_startPoint) && true == isPerchedOnLine(leftLine, line.m_endPoint))
                {
                    nLeftPerchedPoint += 0;
                }
                else if (true == isPerchedOnLine(leftLine, line.m_startPoint))
                {
                    nLeftPerchedPoint++;
                }
                else if (true == isPerchedOnLine(leftLine, line.m_endPoint))
                {
                    nLeftPerchedPoint++;
                }
            }

            if ((nRightPerchedPoint % 2 != 0) || (nLeftPerchedPoint % 2 != 0))
            {
                CNotice.printTrace("findInsidePoint 에서 PerchedPoint 값이 홀수가 되었습니다.");
            }

            /// 점이 올라가는 경우 두점이 같이 올라가기 때문에 한번 교차에 두번 카운팅이 된다.
            /// 따라서 1/2 로 처리한다.
            ///
            nRightIntersection += (int)(nRightPerchedPoint / 2.0f);
            nLeftIntersection  += (int)(nLeftPerchedPoint / 2.0f);

            CPoint point = new CPoint();

            /// 양측이 홀수이면 Inside Point 이다.
            if (EMNumberKind.ODD == getNumberKind(nRightIntersection) && EMNumberKind.ODD == getNumberKind(nLeftIntersection))
            {
                point.m_dX = centerX;
                point.m_dY = baseY;

                return(point);
            }
            /// 왼쪽이 짝수이면 X 값의 최소값과 중심값 사이의 중점을 다시 확인한다.
            else if (EMNumberKind.EVEN == getNumberKind(nLeftIntersection))
            {
                return(findInsidePoint(face, minX, centerX, baseY));
            }
            /// 오른쪽이 짝수이면 X 값의 중심값과 최대값 사이의 중점을 다시 확인한다.
            else if (EMNumberKind.EVEN == getNumberKind(nRightIntersection))
            {
                return(findInsidePoint(face, centerX, maxX, baseY));
            }
            else
            {
                /// Block Point 를 찾기 위해서 findInsidePoint() 를 호출할 때
                /// Face 형상의 문제로 오류가 발생하여 Face 바깥의 지점으로 계산이 리턴되면
                /// Block Point 가 추가되지 못해서
                /// FEMM 에서 Block Point 에 재질 인가 할 때 다른 Block Point 에 인가되는 문제가 발생한다.
                ///
                /// 따라서 findInsidePoint() 에서 내부점을 찾지 못할 때는
                /// 중심의 좌표값을 넘기지 않고 null 을 리턴하여 Block Point 재질 설정 동작을 막는다.
                CNotice.noticeWarningID("FTCT");
                return(null);
            }
        }
Пример #9
0
        /// <summary>
        /// Face 의 형상 정보가 있는 경우 호출되는 생성자
        /// </summary>
        public PopupShape(string partName, CFace face, EMKind emKind)
        {
            InitializeComponent();

            m_strPartName = partName;

            m_bCreatePopupWindow = false;

            try
            {
                switch (emKind)
                {
                case EMKind.COIL:
                    labelPartName.Text = "Coil Name :";
                    this.Text          = "Change Coil";
                    break;

                case EMKind.MAGNET:
                    labelPartName.Text = "Magnet Name :";
                    this.Text          = "Change Magnet";
                    break;

                case EMKind.STEEL:
                    labelPartName.Text = "Steel Name :";
                    this.Text          = "Change Steel";
                    break;

                default:
                    CNotice.printTraceID("TPTI");
                    return;
                }

                if (face == null)
                {
                    CNotice.printTraceID("CTPS1");
                    return;
                }

                textBoxBaseX.Text = face.BasePoint.m_dX.ToString();
                textBoxBaseY.Text = face.BasePoint.m_dY.ToString();

                if (face.getPointCount() < MIN_POLYGON_CONTROL_COUNT)
                {
                    CNotice.printTraceID("CTPS");
                    return;
                }

                /// 파트이름을 표시만하고 수정을 하지 못하게 한다.
                textBoxPartName.Text    = partName;
                textBoxPartName.Enabled = false;

                if (face.FaceType == EMFaceType.RECTANGLE)
                {
                    // 설정과 동시에 이벤트가 호출되고
                    // 이벤트함수에서 FaceType 가 지정되면서 Popup 창의 형태와 UserControl 이 초기화 된다.
                    comboBoxFaceType.SelectedItem = EMFaceType.RECTANGLE.ToString();

                    this.ListPointControl[0].StrCoordX = face.RelativePointList[0].m_dX.ToString();
                    this.ListPointControl[0].StrCoordY = face.RelativePointList[0].m_dY.ToString();

                    this.ListPointControl[1].StrCoordX = face.RelativePointList[2].m_dX.ToString();
                    this.ListPointControl[1].StrCoordY = face.RelativePointList[2].m_dY.ToString();
                }
                else if (face.FaceType == EMFaceType.POLYGON)
                {
                    // 설정과 동시에 이벤트가 호출되고
                    // 이벤트함수에서 FaceType 가 지정되면서 Popup 창의 형태와 UserControl 이 초기화 된다.
                    comboBoxFaceType.SelectedItem = EMFaceType.POLYGON.ToString();

                    for (int i = 0; i < face.getPointCount(); i++)
                    {
                        // 기본 생성 Control 수 보다 작을 때는 있는 Control 에 데이터를 담고
                        // 클 때는 Control 를 생성하면서 데이터를 담은다.
                        if (i >= MIN_POLYGON_CONTROL_COUNT)
                        {
                            this.addPointControl(new CPointControl(), true, this.panelPointControl);
                        }

                        this.ListPointControl[i].StrCoordX = face.RelativePointList[i].m_dX.ToString();
                        this.ListPointControl[i].StrCoordY = face.RelativePointList[i].m_dY.ToString();

                        if (face.RelativePointList[i].m_emLineKind == EMLineKind.ARC)
                        {
                            this.ListPointControl[i].IsArc = true;
                        }
                        else
                        {
                            this.ListPointControl[i].IsArc = false;
                        }

                        if (face.RelativePointList[i].m_emDirectionArc == EMDirectionArc.BACKWARD)
                        {
                            this.ListPointControl[i].IsArcDirection = true;
                        }
                        else
                        {
                            this.ListPointControl[i].IsArcDirection = false;
                        }
                    }
                }
                else
                {
                    CNotice.printTraceID("UAWF");
                    return;
                }

                /// 코일의 경우는 코일계산 때문에 Rectangle 로 고정을 해야 한다.
                if (emKind == EMKind.COIL)
                {
                    comboBoxFaceType.Enabled = false;
                }
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
            }
        }
Пример #10
0
        /// <summary>
        /// 좌표입력 컨트롤을 하나 추가한다
        /// </summary>
        /// <param name="pointControl">좌표 객체</param>
        /// <param name="panel">좌표를 추가할 Panel</param>
        private CPointControl addPointControl(CPointControl pointControl, bool showButton, Panel panel)
        {
            pointControl.Dock        = DockStyle.Top;
            pointControl.IsRectangle = showButton;

            try
            {
                #region ------------------------- 이벤트 호출 영역 ------------------------------
                /// 이벤트 호출 영역은 addControlPoint() 안에 있으나 호출 때 동작하는 영역이 아니다.
                /// 단, 함수내에 있는 이유는 addControlPoint() 안에 있어서
                /// 파라메터로 넘어오는 변수를 직접 접근할 수 있어, 이벤트 함수의 변수 접근 문제를 해결했다.
                ///
                pointControl.AddCoordinates += (s, e) =>
                {
                    /// 추가 버튼 클릭했을때 현재 컨트롤 아래 추가
                    /// - 컨트롤 추가
                    ///  * addPointControl() 의 호출 영역을 호출 한다.
                    CPointControl current = this.addPointControl(new CPointControl(), showButton, panel);

                    /// - 컨트롤 정렬
                    List <CPointControl> sortList = new List <CPointControl>();
                    for (int i = 0; i < panel.Controls.Count; i++)
                    {
                        CPointControl c = panel.Controls[i] as CPointControl;
                        if (c.Equals(current))
                        {
                            continue;                    // 현재 추가된 항목은 통과
                        }
                        if (c.Equals(pointControl))
                        {
                            break;                         // 버튼 클릭한 항목을때 그 위쪽은 탐색할 필요 없으므로 루프 종료
                        }
                        sortList.Add(c);
                    }

                    for (int i = sortList.Count - 1; i >= 0; i--)
                    {
                        sortList[i].BringToFront();
                    }

                    this.resetSequence();
                };

                /// addPointControl() 이 호출될 때 실행되지 않고 이벤트가 발생할 때 동작한다.
                pointControl.RemoveCoordinates += (s, e) =>
                {
                    if (this.m_faceType == EMFaceType.RECTANGLE)
                    {
                        if (this.panelPointControl.Controls.Count == RECTANGLE_CONTROL_COUNT)
                        {
                            e.Cancel = true;
                            CNotice.noticeWarningID("RRAL");
                            return;
                        }
                    }
                    else
                    {
                        if (this.panelPointControl.Controls.Count <= MIN_POLYGON_CONTROL_COUNT)
                        {
                            e.Cancel = true;
                            CNotice.noticeWarningID("PRAL");
                            return;
                        }
                    }
                };

                /// addControlPoint() 이 호출될 때 실행되지 않고 이벤트가 발생할 때 동작한다.
                pointControl.RemoveComplete += (s, e) =>
                {
                    this.resetSequence();

                    // 생성창에서만 Add 버튼을 하나로 표시한다
                    if (m_bCreatePopupWindow == true)
                    {
                        /// PointControl 삭제때 Add 버튼 하나만 표시하기
                        ///
                        /// 정렬이 끝난 후에 PointControl Panel 의 가장 아래 PointControl ADD 버튼만 보이게 하여
                        /// PointControl 의 삽입이 항상 아래에서만 이루어지도록 해서 Tab 의 문제를 해결 했다.
                        for (int i = 0; i < panelPointControl.Controls.Count; i++)
                        {
                            if (i == 0)
                            {
                                ((CPointControl)panelPointControl.Controls[i]).showAddButton();
                            }
                            else
                            {
                                ((CPointControl)panelPointControl.Controls[i]).hideAddButton();
                            }
                        }
                    }
                };
                #endregion

                #region ------------------------ 함수 호출 영역 -----------------------------

                panel.Controls.Add(pointControl);
                pointControl.BringToFront();

                this.resetSequence();

                // 생성창에서만 Add 버튼을 하나로 표시한다
                if (m_bCreatePopupWindow == true)
                {
                    /// 2. PointControl 추가때 Add 버튼 하나만 표시하기
                    ///
                    /// 정렬이 끝난 후에 PointControl Panel 의 가장 아래 PointControl ADD 버튼만 보이게 하여
                    /// PointControl 의 삽입이 항상 아래에서만 이루어지도록 해서 Tab 의 문제를 해결 했다.
                    for (int i = 0; i < panelPointControl.Controls.Count; i++)
                    {
                        if (i == 0)
                        {
                            ((CPointControl)panelPointControl.Controls[i]).showAddButton();
                        }
                        else
                        {
                            ((CPointControl)panelPointControl.Controls[i]).hideAddButton();
                        }
                    }
                }

                return(pointControl);

                #endregion
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
                return(null);
            }
        }
Пример #11
0
        private bool isInputDataOK()
        {
            try
            {
                // 빈칸 확인으로 null 비교를 사용하지 말라. (.Length == 0 나 "" 를 사용하라)
                if (textBoxName.Text.Length == 0)
                {
                    CNotice.noticeWarningID("PEAN");
                    return(false);
                }

                /// Design 생성이다.
                if (m_strNewKind == "Design")
                {
                    // 디자인을 무조건 프로그램 작업디렉토리에 생성하는 것으로 한다.
                    // 따라서 디자인을 생성할 때의 적용버튼 임으로 작업 디렉토리는 프로그램 작업 디렉토리를 사용하고 있다.
                    List <string> listDirectories = m_manageFile.getDirectoryList(CSettingData.m_strWorkingDirName);

                    // 소문자로 비교하기 위해서 임시로 사용한다.
                    string strOldTempName, strNewTempName;

                    foreach (string directoryName in listDirectories)
                    {
                        // 디렉토리 경로에 GetFileName 을 사용하면 가장 마지막 디렉토리가 넘어온다.
                        strOldTempName = Path.GetFileName(directoryName).ToLower();
                        strNewTempName = m_strName.ToLower();

                        if (strOldTempName == strNewTempName)
                        {
                            // 기존 디자인이 이미 존재할 때 삭제하고 새롭게 시작할지를 물어 온다
                            DialogResult ret = CNotice.noticeWarningOKCancelID("TSDA", "W");

                            if (ret == DialogResult.OK)
                            {
                                m_manageFile.deleteDirectory(directoryName);
                                return(true);
                            }
                            else
                            {
                                return(false);
                            }
                        }
                    }
                }
                /// Experiment 들의 생성이다.
                else
                {
                    /// 호출할 때 Owner 를 FormMain 으로 초기화 해야 확실하게 얻을 수 있다.
                    FormMain formMain = ((FormMain)this.Owner);

                    if (formMain == null)
                    {
                        CNotice.printTraceID("CNGM");
                        return(false);
                    }

                    if (true == formMain.m_design.isExistNode(textBoxName.Text))
                    {
                        CNotice.noticeWarningID("IIAE");
                        return(false);
                    }
                }
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
                return(false);
            }

            return(true);
        }
Пример #12
0
        // 코일에 대한 문자열 라인을 넘겨 받아서 코일 객체를 초기화 한다.
        public bool readObject(List <string> listStringLines)
        {
            string strTemp;

            string[] arrayString;

            //if (KindKey != EMKind.FORCE_EXPERIMENT)
            //{
            //    CNotice.printTrace("다른 객체를 ForceExperiment 로 읽으려고 하고 있습니다.");
            //    return false;
            //}

            try
            {
                foreach (string strLine in listStringLines)
                {
                    strTemp = strLine.Trim('\t');

                    arrayString = strTemp.Split('=');

                    if (arrayString.Length != 2)
                    {
                        CNotice.noticeWarningID("TIAP3");
                        return(false);
                    }

                    switch (arrayString[0])
                    {
                    // CNode
                    case "NodeName":
                        NodeName = arrayString[1];
                        break;

                    case "KindKey":
                        m_kindKey = (EMKind)Enum.Parse(typeof(EMKind), arrayString[1]);
                        break;

                    // CExperiment
                    case "MeshSizePercent":
                        MeshSizePercent = Convert.ToDouble(arrayString[1]);
                        break;

                    // CForceExperiment
                    case "Voltage":
                        Voltage = Convert.ToDouble(arrayString[1]);
                        break;

                    case "Current":
                        Current = Convert.ToDouble(arrayString[1]);
                        break;

                    case "MovingStroke":
                        MovingStroke = Convert.ToDouble(arrayString[1]);
                        break;

                    default:
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
                return(false);
            }

            return(true);
        }
Пример #13
0
        protected bool readShapeInformation(List <string> listShapeLines)
        {
            string strTemp;

            string[] arrayString;

            try
            {
                // Shape 정보가 있는 경우만 m_face 를 생성하고 읽기 작업을 진행한다.
                if (listShapeLines.Count > 0)
                {
                    m_face = new CFace();
                }
                else
                {
                    return(false);
                }

                CPoint point = null;

                // 형상 라인을 처리한다.
                foreach (string strLine in listShapeLines)
                {
                    strTemp = strLine.Trim('\t');

                    arrayString = strTemp.Split('=');

                    /// 각 줄의 String 배열은 항상 2개이여야 한다.
                    if (arrayString.Length != 2)
                    {
                        CNotice.noticeWarningID("TIAP5");
                        return(false);
                    }

                    if (m_face == null)
                    {
                        CNotice.printTraceID("IIAT");
                        return(false);
                    }

                    switch (arrayString[0])
                    {
                    case "BasePointX":
                        m_face.BasePoint.m_dX = Double.Parse(arrayString[1]);
                        break;

                    case "BasePointY":
                        m_face.BasePoint.m_dY = Double.Parse(arrayString[1]);
                        break;

                    case "FaceType":
                        m_face.FaceType = (EMFaceType)Enum.Parse(typeof(EMFaceType), arrayString[1]);
                        break;

                    case "PointX":
                        // PointX 키워드를 만날때 새로운 CPoint 생성하고,
                        // ArcDriction 키워드를 만날때 생성된 CPoint 를 Face 에 추가한다.
                        // 따라서 저장될때 X, Y, LineKind, ArcDriction 의 순서로 꼭 저장 되어야 한다.
                        point      = new CPoint();
                        point.m_dX = Double.Parse(arrayString[1]);
                        break;

                    case "PointY":
                        if (point != null)
                        {
                            point.m_dY = Double.Parse(arrayString[1]);
                        }
                        else
                        {
                            CNotice.noticeWarningID("YCWX");
                            return(false);
                        }
                        break;

                    case "LineKind":
                        if (point != null)
                        {
                            point.m_emLineKind = (EMLineKind)Enum.Parse(typeof(EMLineKind), arrayString[1]);
                        }
                        else
                        {
                            CNotice.noticeWarningID("TIAP9");
                            return(false);
                        }
                        break;

                    case "ArcDriction":
                        if (point != null)
                        {
                            point.m_emDirectionArc = (EMDirectionArc)Enum.Parse(typeof(EMDirectionArc), arrayString[1]);
                        }
                        else
                        {
                            CNotice.noticeWarningID("TIAP10");
                            return(false);
                        }

                        // ArcDriction 에서 point 을 저장한다.
                        m_face.addPoint(point);
                        break;

                    default:
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
                return(false);
            }

            return(true);
        }
Пример #14
0
        public bool attachDefault(string strExperimentFullName, CPoint pointBoundaryBlock)
        {
            CReadFile   readFile   = new CReadFile();
            CManageFile manageFile = new CManageFile();

            List <string> listString = new List <string>();
            string        strLine    = string.Empty;

            char[]   separators = { ' ', '\t' };
            string[] strArray;

            string strFileName         = Path.GetFileNameWithoutExtension(strExperimentFullName);
            string strTempFileFullName = Path.Combine(Path.GetDirectoryName(strExperimentFullName), strFileName + "_temp.fem");

            if (manageFile.isExistFile(strExperimentFullName) == false)
            {
                CNotice.printTraceID("NFFF");
                return(false);
            }
            else
            {
                File.Move(strExperimentFullName, strTempFileFullName);
            }

            StreamWriter writeFile    = new StreamWriter(strExperimentFullName);
            int          iNumBlock    = 0;
            int          nCountBlock  = 0;
            bool         bBlockLabels = false;

            try
            {
                readFile.getAllLines(strTempFileFullName, ref listString);

                for (int i = 0; i < listString.Count; i++)
                {
                    strLine = listString[i];

                    strArray = strLine.Split(separators, StringSplitOptions.None);

                    if (strArray[0] == "[NumBlockLabels]")
                    {
                        iNumBlock    = Int32.Parse(strArray[2]);
                        nCountBlock  = 0;
                        bBlockLabels = true;

                        writeFile.WriteLine(strLine);

                        /// 구분 Label 행은 건너 뛴다.
                        continue;
                    }

                    if (bBlockLabels == true)
                    {
                        if (pointBoundaryBlock.m_dX == Double.Parse(strArray[0]) && pointBoundaryBlock.m_dY == Double.Parse(strArray[1]))
                        {
                            if (strArray.Length != 9)
                            {
                                CNotice.printTraceID("TWAP2");
                                return(false);
                            }

                            /// dettach block setting
                            strArray[8] = "2";
                            strLine     = string.Empty;

                            foreach (string str in strArray)
                            {
                                strLine += str + '\t';
                            }
                        }

                        nCountBlock++;

                        if (nCountBlock >= iNumBlock)
                        {
                            bBlockLabels = false;
                        }
                    }

                    writeFile.WriteLine(strLine);
                }

                File.Delete(strTempFileFullName);
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
                writeFile.Close();
                return(false);
            }

            writeFile.Close();
            return(true);
        }
Пример #15
0
        public void buttonDraw_Click(object sender, EventArgs e)
        {
            try
            {
                /// 완벽한 입력인 상태에서만 Draw 가 가능한다.
                bool retOK = isInputDataOK();

                if (retOK == false)
                {
                    return;
                }

                /// [문제]
                ///  - Form 에서는 Parent를 사용할 수 없어 Owner 속성을 사용하지만
                ///    종종 Owner 가 null 로 넘어오는 문제가 발생한다.
                /// [해결]
                ///  - PopupShape 창을 생성하기 전에 Owner 속성을 FormMain 으로 초기화 해 두어야
                ///    확실하게 FormMain 을 얻을 수 있다.
                FormMain formMain = ((FormMain)this.Owner);

                if (formMain == null)
                {
                    CNotice.printTraceID("CNGM");
                    return;
                }

                /// 형상 유효성 확인
                ///
                CFace face = makeFace();

                if (face == null)
                {
                    CNotice.noticeWarningID("TWAP1");
                    return;
                }

                if (false == face.isShapeOK())
                {
                    CNotice.printTraceID("TWAP3");
                    return;
                }

                CScriptFEMM femm = formMain.m_femm;

                femm.deleteAll();

                /// 1. 작업 중인 Face 를 제외하고 형상 그리기
                foreach (CNode node in formMain.m_design.NodeList)
                {
                    if (node.GetType().BaseType.Name == "CParts")
                    {
                        if (node.NodeName != m_strPartName)
                        {
                            ((CParts)node).Face.drawFace(femm);
                        }
                    }
                }

                // FEMM 을 최상위로 올린다.
                CProgramFEMM.showFEMM();

                // 혹시 FEMM 의 화면이 닫힌 경우 FEMM 의 화면을 복원합니다.
                formMain.reopenFEMM();

                /// 2. 작업중인 Face 형상 그리기
                face.drawFace(femm);
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
            }
        }
Пример #16
0
        public double solveForce(double minX, double minY, double maxX, double maxY, string strFieldImageFullName = null)
        {
            string strCommand;
            double dForce;

            const double dOutSpace = 0.2f;

            maxX = maxX + Math.Abs(maxX - minX) * dOutSpace;
            minY = minY - Math.Abs(maxY - minY) * dOutSpace;
            maxY = maxY + Math.Abs(maxY - minY) * dOutSpace;

            try
            {
                strCommand = "mi_zoom(" + minX.ToString() + "," + minY.ToString() + "," + maxX.ToString() + "," + maxY.ToString() + ")";
                sendCommand(strCommand);

                strCommand = "mi_analyse()";
                sendCommand(strCommand);

                strCommand = "mi_loadsolution()";
                sendCommand(strCommand);

                strCommand = "mo_zoom(" + minX.ToString() + "," + minY.ToString() + "," + maxX.ToString() + "," + maxY.ToString() + ")";
                sendCommand(strCommand);

                /// mi_loadsolution() 후에 호출해야 한다.
                /// 깜빡임이 심해서 이미지 저장때만 사용한다.
                if (strFieldImageFullName != null)
                {
                    settingPost();
                }

                strCommand = "mi_seteditmode(\"group\")";
                sendCommand(strCommand);

                strCommand = "mo_groupselectblock(" + MOVING_GROUP_NUM.ToString() + ")";
                sendCommand(strCommand);

                strCommand = "mo_blockintegral(19)";
                dForce     = Double.Parse(sendCommand(strCommand));

                strCommand = "mo_clearblock()";
                sendCommand(strCommand);

                if (null != strFieldImageFullName)
                {
                    //-------------------------------------------------------------
                    // 아주 중요
                    //-------------------------------------------------------------
                    //
                    // 디렉토리에 들어있는 \\ 기호는 FEMM 에서 인식하지 못한다.
                    // 따라서 디렉토리안의 \\ 기호를 / 기호로 변경한다
                    strFieldImageFullName = strFieldImageFullName.Replace("\\", "/");
                    //-------------------------------------------------------------

                    strFieldImageFullName = "\"" + strFieldImageFullName + "\"";

                    strCommand = "mo_savebitmap(" + strFieldImageFullName + ")";
                    sendCommand(strCommand);
                }
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
                return(0);
            }


            return(dForce);
        }
Пример #17
0
        // 코일에 대한 문자열 라인을 넘겨 받아서 코일 객체를 초기화 한다.
        public bool readObject(List <string> listStringLines)
        {
            string strTemp;

            string[] arrayString;

            try
            {
                foreach (string strLine in listStringLines)
                {
                    strTemp = strLine.Trim('\t');

                    arrayString = strTemp.Split('=');

                    if (arrayString.Length != 2)
                    {
                        CNotice.noticeWarningID("TIAP3");
                        return(false);
                    }

                    switch (arrayString[0])
                    {
                    // CNode
                    case "NodeName":
                        NodeName = arrayString[1];
                        break;

                    case "KindKey":
                        m_kindKey = (EMKind)Enum.Parse(typeof(EMKind), arrayString[1]);
                        break;

                    // CExperiment
                    case "MeshSizePercent":
                        MeshSizePercent = Convert.ToDouble(arrayString[1]);
                        break;

                    case "ActuatorType":
                        ActuatorType = (EMActuatorType)Enum.Parse(typeof(EMActuatorType), arrayString[1]);
                        break;

                    // CForceExperiment
                    case "Voltage":
                        Voltage = Convert.ToDouble(arrayString[1]);
                        break;

                    case "Current":
                        Current = Convert.ToDouble(arrayString[1]);
                        break;

                    case "MovingY":
                        MovingY = Convert.ToDouble(arrayString[1]);
                        break;

                    case "MovingX":
                        MovingX = Convert.ToDouble(arrayString[1]);
                        break;

                    case "MovingZ":
                        MovingZ = Convert.ToDouble(arrayString[1]);
                        break;

                    default:
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                CNotice.printTrace(ex.Message);
                return(false);
            }

            return(true);
        }