Zemax OpticStudio ZOS-API 2026 R1

File IAR_Base.cs

Last update: 13.03.2026

Classes

Namespaces

Source

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using ZOSAPI.Common;
using ZOSAPI.Tools;

namespace ZOSAPI.Analysis.Data
{
    [ComVisible(true)]
    [Guid("E1FBA4E6-B9DC-44A4-9958-60003D26E1A0")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_
    {
        IAR_MetaData MetaData { get; }
        IAR_HeaderData HeaderData { get; }

        int NumberOfDataGrids { get; }
        IAR_DataGrid GetDataGrid(int index);
        IAR_DataGrid[] DataGrids { get; }

        int NumberOfDataGridsRgb { get; }
        IAR_DataGridRgb GetDataGridRgb(int index);
        IAR_DataGridRgb[] DataGridsRgb { get; }

        int NumberOfDataSeries { get; }
        IAR_DataSeries GetDataSeries(int index);
        IAR_DataSeries[] DataSeries { get; }

        int NumberOfDataSeriesRgb { get; }
        IAR_DataSeriesRgb GetDataSeriesRgb(int index);
        IAR_DataSeriesRgb[] DataSeriesRgb { get; }

        int NumberOfDataScatterPoints { get; }
        IAR_DataScatterPoints GetDataScatterPoint(int index);
        IAR_DataScatterPoints[] DataScatterPoints { get; }

        int NumberOfDataScatterPointsRgb { get; }
        IAR_DataScatterPointsRgb GetDataScatterPointRgb(int index);
        IAR_DataScatterPointsRgb[] DataScatterPointsRgb { get; }

        int NumberOfRayData { get; }
        IAR_RayData GetRayData(int index);
        IAR_RayData[] RayData { get; }

        IAR_CriticalRayData CriticalRayData { get; }

        IAR_PathAnalysisData PathAnalysisData { get; }
        IAR_SpotDataResultMatrix SpotData { get; }

        IAR_NSCSpotResults NSCSpotData { get; }

        IAR_NSCSingleRayTraceData NSCSingleRayTraceData { get; }

        int NumberOfMessages { get; }
        IMessage GetMessageAt(int index);
        IMessage[] Messages { get; }

        bool GetTextFile(String Filename);
    }

    [ComVisible(true)]
    [Guid("F7B1B0F1-4B73-4CB4-9A7E-73962FAF4233")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_Rgb
    {
        float R { get; }
        float G { get; }
        float B { get; }
    }

    [ComVisible(true)]
    [Guid("851D060B-A9CF-4704-B6D3-ABE72ED6234B")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_Vector2D
    {
        float dx { get; }
        float dy { get; }        
    }

    [ComVisible(true)]
    [Guid("2CAC9767-602E-4B98-9700-2E4E72A69D28")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_ScatterPoint
    {
        double X { get; }
        double Y { get; }
        double Value { get; }
    }

    [ComVisible(true)]
    [Guid("D557544D-9182-426F-B0C6-F8E5589A69E2")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_SpotPoint
    {
        double X { get; }
        double Y { get; }
        double Z { get; }
        double L { get; }
        double M { get; }
        double N { get; }
        double Flux { get; }
        int Config { get; }
        int Wave { get; }

    }

    [ComVisible(true)]
    [Guid("6A0796AB-7F18-4BDE-A71D-60CE339E48A0")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_ScatterPointRgb
    {
        double X { get; }
        double Y { get; }
        IAR_Rgb Value { get; }
    }

    [ComVisible(true)]
    [Guid("07E9BD52-D30E-4F40-8F74-FDF29082F043")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_MetaData
    {
        String FeatureDescription { get; }
        String LensFile { get; }
        String LensTitle { get; }
        DateTime Date { get; }
    }

    [ComVisible(true)]
    [Guid("037A128A-01AB-479C-BFB3-C45E92A52BEC")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_HeaderData
    {
        String[] Lines { get; }
    }

    [ComVisible(true)]
    [Guid("BD067D0A-AE8D-4C84-A8BD-A8680B9FE3E8")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_XYZ
    {
        double X { get; }
        double Y { get; }
        double Z { get; }
    }

    [ComVisible(true)]
    [Guid("574DBE70-BB55-4A0A-BCED-8D08B24C10E2")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_DataGrid
    {
        String Description { get; }
        String XLabel { get; }
        String YLabel { get; }
        String ValueLabel { get; }

        uint Nx { get; }
        uint Ny { get; }
        double Dx { get; }
        double Dy { get; }
        double MinX { get; }
        double MinY { get; }

        double[,] Values { get; }
        IMatrixData ValueData { get; }

        double X(int rowX);
        double Y(int colY);
        double Z(int rowX, int colY);

        IAR_XYZ XYZ(int rowX, int colY);

        IAR_DataGridRgb ConvertToRGB(IColorTranslator translator);

    }

    [ComVisible(true)]
    [Guid("FA289F4B-8C6B-4302-80BA-3254B9CD1423")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_DataGridVector
    {
        String Description { get; }
        String XLabel { get; }
        String YLabel { get; }
        String ValueLabel { get; }

        uint Nx { get; }
        uint Ny { get; }
        double Dx { get; }
        double Dy { get; }
        double MinX { get; }
        double MinY { get; }

        double[,] DeltaXValues { get; }
        double[,] DeltaYValues { get; }
        IMatrixData DeltaXValueData { get; }
        IMatrixData DeltaYValueData { get; }

        double X(int rowX);
        double Y(int colY);
        double DeltaX(int rowX, int colY);
        double DeltaY(int rowX, int colY);        
    }

    [ComVisible(true)]
    [Guid("87A51042-19D2-4D01-85D4-02FFF599D79A")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_DataGridRgb
    {
        String Description { get; }
        String XLabel { get; }
        String YLabel { get; }
        String ValueLabel { get; }

        uint Nx { get; }
        uint Ny { get; }
        double Dx { get; }
        double Dy { get; }
        double MinX { get; }
        double MinY { get; }

        IAR_Rgb[,] Values { get; }
        IAR_Rgb GetValue(int x, int y);
        void FillValues(
            uint fullSize,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]float[] rData,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]float[] gData,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]float[] bData);
    }

    [ComVisible(true)]
    [Guid("5570536F-0C5F-41C9-AD2C-C56B280319E6")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_DataSeries
    {
        String Description { get; }

        String XLabel { get; }
        IVectorData XData { get; }

        String[] SeriesLabels { get; }
        int NumSeries { get; }
        IMatrixData YData { get; }

        IAR_DataSeriesRgb ConvertToRGB(IColorTranslator translator);
    }

    [ComVisible(true)]
    [Guid("5C88B347-E31C-426B-9488-02E148EC2886")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_DataSeriesRgb
    {
        String Description { get; }
        uint NumSeries { get; }
        IVectorData XData { get; }
        uint NumberOfRows { get; }
        IAR_Rgb[,] YVals { get; }
        IAR_Rgb GetYPoint(int row, int col);
        void FillYValues(
            uint fullSize,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]float[] rData,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]float[] gData,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]float[] bData);
        String XLabel { get; }
        String[] SeriesLabels { get; }
    }

    [ComVisible(true)]
    [Guid("7B7B1D1C-1B7A-47D6-8CD5-3DBBC4B6C8A2")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_DataScatterPoints
    {
        String Description { get; }
        uint NumPoints { get; }
        IAR_ScatterPoint[] Points { get; }
        IAR_ScatterPoint GetPoint(int idx);
        void FillPointValues(
            uint fullSize,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]double[] xData,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]double[] yData,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]double[] valueData);
        String XLabel { get; }
        String YLabel { get; }
        String ValueLabel { get; }

        IAR_DataScatterPointsRgb ConvertToRGB(IColorTranslator translator);
    }

    [ComVisible(true)]
    [Guid("97788734-B5DF-479C-A7AD-31B647F8E6F8")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_DataScatterPointsRgb
    {
        String Description { get; }
        uint NumPoints { get; }
        IAR_ScatterPointRgb[] Points { get; }
        IAR_ScatterPointRgb GetPoint(int idx);
        void FillPointValues(
            uint fullSize,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]double[] xData,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]double[] yData,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]float[] rData,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]float[] gData,
            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)][In][Out]float[] bData);
        String XLabel { get; }
        String YLabel { get; }
        String ValueLabel { get; }
    }

    [ComVisible(true)]
    [Guid("13EB31A2-68F3-40A7-990F-1DC09BE61A28")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_RayInfo
    {
        int RayIndex { get; }
        int Segment { get; }
        int Parent { get; }
        int Level { get; }
        int In_object { get; }
        int Hit_object { get; }
        int Hit_face { get; }
        double X { get; }
        double Y { get; }
        double Z { get; }
        double L { get; }
        double M { get; }
        double N { get; }
        double Nx { get; }
        double Ny { get; }
        double Nz { get; }
        double Ex { get; }
        double Ey { get; }
        double Ez { get; }
        double PathLength { get; }
        double OpticalPathLength { get; }
        double Wavelength { get; }
        int Vignetted { get; }
        int Error { get; }
    }

    [ComVisible(true)]
    [Guid("10CB0805-6D74-430F-8D18-40045ADA4E43")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_RayData
    {
        String Description { get; }
        uint NumRays { get; }
        IAR_RayInfo[] Rays { get; }
        IAR_RayInfo GetRay(int idx);
    }

    [ComVisible(true)]
    [Guid("04576353-2F54-425D-8CE1-B74002F0628C")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_CriticalRayData
    {
        uint NumRays { get; }
        string[] HeaderLabels { get; }
        IAR_CriticalRayInfo[] Rays { get; }

        IAR_CriticalRayInfo GetRay(uint idx);
    }

    [ComVisible(true)]
    [Guid("81F3E249-59D5-468B-92EB-2B3CE7C423E4")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_CriticalRayInfo
    {
        int FieldPoint { get; }
        CriticalRayType RayType { get; }
        bool Pass { get; }
        int TerminationObject { get; }
        double Wavelength { get; }

        double XIn { get; }
        double YIn { get; }
        double ZIn { get; }
        double LIn { get; }
        double MIn { get; }
        double NIn { get; }

        double XTarget { get; }
        double YTarget { get; }
        double ZTarget { get; }
        double LTarget { get; }
        double MTarget { get; }
        double NTarget { get; }

        double XActual { get; }
        double YActual { get; }
        double ZActual { get; }
        double LActual { get; }
        double MActual { get; }
        double NActual { get; }
    }

    [ComVisible(true)]
    [Guid("033B7EDE-0AB4-44CA-8485-F23DBFC188FB")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_SpotDataResult
    {
        double X { get; set; }
        double Y { get; set; }
        double Z { get; set; }
        double L { get; set; }
        double M { get; set; }
        double N { get; set; }
        double Detector_X { get; set; }
        double Detector_Y { get; set; }
        double Detector_Z { get; set; }
        double RefCoord_X { get; set; }
        double RefCoord_Y { get; set; }
        double RMSSpot_X { get; set; }
        double RMSSpot_Y { get; set; }
        double RMSSpotSize { get; set; }
        double GeoSpotSize { get; set; }
    }

    [ComVisible(true)]
    [Guid("A9416F0B-EBB7-4C95-BF99-8770DAFFF3F6")]
    public enum NSCSpotErrorType
    {
        None = 0,
        SetActiveConfigFailed,
        NoValidObjects,
        NoValidSequences,
        RayTraceError,
        RayTraceFileError,
        ComputationAborted,
        NoSpotPointsFound,
        CannotAccessData
    }

    [ComVisible(true)]
    [Guid("A845CF70-9980-4C1D-B5DD-362A5EAB8A68")]
    public enum NSCAiryErrorType
    {
        SequenceInvalid = 0,
        None,
        AiryRadiusNotEnabled,
        RefractiveIndexNotFixed,
        DirectionCosinesNotSupported,
        InstanceAllNotSupported
    }

    [ComVisible(true)]
    [Guid("5ED11402-D910-4218-866D-E19D2507205A")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_NSCSpotResults
    {
        bool GetError();
        NSCSpotErrorType GetErrorCode();
        int GetNumberOfSequencesUsed();
        int GetNumberOfWavelengthsUsed();
        int GetNumberOfConfigurationsUsed();
        bool GetIsValid_For(int sequence);
        int GetNumberOfPoints_For(int sequence);
        double GetTotalFlux_For(int sequence);
        double GetRefCoord_X_For(int sequence);
        double GetRefCoord_Y_For(int sequence);
        double GetRefCoord_Z_For(int sequence);
        double GetRMSSpot_X_For(int sequence);
        double GetRMSSpot_Y_For(int sequence);
        double GetRMSSpotSize_For(int sequence);
        double GetGeoSpotSize_For(int sequence);
        double GetAiryDisk_For(int sequence);
        bool GetAiryIsValid_For(int sequence);
        NSCAiryErrorType GetAiryErrorCode_For(int sequence);
        bool GetIsValid_For(int sequence, int wave);
        int GetNumberOfPoints_For(int sequence, int wave);
        double GetTotalFlux_For(int sequence, int wave);
        double GetRefCoord_X_For(int sequence, int wave);
        double GetRefCoord_Y_For(int sequence, int wave);
        double GetRefCoord_Z_For(int sequence, int wave);
        double GetRMSSpot_X_For(int sequence, int wave);
        double GetRMSSpot_Y_For(int sequence, int wave);
        double GetRMSSpotSize_For(int sequence, int wave);
        double GetGeoSpotSize_For(int sequence, int wave);
        double GetAiryDisk_For(int sequence, int wave);
        bool GetAiryIsValid_For(int sequence, int wave);
        NSCAiryErrorType GetAiryErrorCode_For(int sequence, int wave);
        bool GetIsValid_ByConfig_For(int sequence, int config);
        int GetNumberOfPoints_ByConfig_For(int sequence, int config);
        double GetTotalFlux_ByConfig_For(int sequence, int config);
        double GetRefCoord_X_ByConfig_For(int sequence, int config);
        double GetRefCoord_Y_ByConfig_For(int sequence, int config);
        double GetRefCoord_Z_ByConfig_For(int sequence, int config);
        double GetRMSSpot_X_ByConfig_For(int sequence, int config);
        double GetRMSSpot_Y_ByConfig_For(int sequence, int config);
        double GetRMSSpotSize_ByConfig_For(int sequence, int config);
        double GetGeoSpotSize_ByConfig_For(int sequence, int config);
        double GetAiryDisk_ByConfig_For(int sequence, int config);
        bool GetAiryIsValid_ByConfig_For(int sequence, int config);
        NSCAiryErrorType GetAiryErrorCode_ByConfig_For(int sequence, int config);
        bool GetIsValid_ByConfig_For(int sequence, int config, int wave);
        int GetNumberOfPoints_ByConfig_For(int sequence, int config, int wave);
        double GetTotalFlux_ByConfig_For(int sequence, int config, int wave);
        double GetRefCoord_X_ByConfig_For(int sequence, int config, int wave);
        double GetRefCoord_Y_ByConfig_For(int sequence, int config, int wave);
        double GetRefCoord_Z_ByConfig_For(int sequence, int config, int wave);
        double GetRMSSpot_X_ByConfig_For(int sequence, int config, int wave);
        double GetRMSSpot_Y_ByConfig_For(int sequence, int config, int wave);
        double GetRMSSpotSize_ByConfig_For(int sequence, int config, int wave);
        double GetGeoSpotSize_ByConfig_For(int sequence, int config, int wave);
        double GetAiryDisk_ByConfig_For(int sequence, int config, int wave);
        bool GetAiryIsValid_ByConfig_For(int sequence, int config, int wave);
        NSCAiryErrorType GetAiryErrorCode_ByConfig_For(int sequence, int config, int wave);
        IVectorData GetSpotData_X_For(int sequence);
        IVectorData GetSpotData_Y_For(int sequence);
        IVectorData GetSpotData_Z_For(int sequence);
        IVectorData GetSpotData_L_For(int sequence);
        IVectorData GetSpotData_M_For(int sequence);
        IVectorData GetSpotData_N_For(int sequence);
        IVectorData GetSpotData_Flux_For(int sequence);
        IVectorData GetSpotData_X_For(int sequence, int wave);
        IVectorData GetSpotData_Y_For(int sequence, int wave);
        IVectorData GetSpotData_Z_For(int sequence, int wave);
        IVectorData GetSpotData_L_For(int sequence, int wave);
        IVectorData GetSpotData_M_For(int sequence, int wave);
        IVectorData GetSpotData_N_For(int sequence, int wave);
        IVectorData GetSpotData_Flux_For(int sequence, int wave);
        IVectorData GetSpotData_X_ByConfig_For(int sequence, int config);
        IVectorData GetSpotData_Y_ByConfig_For(int sequence, int config);
        IVectorData GetSpotData_Z_ByConfig_For(int sequence, int config);
        IVectorData GetSpotData_L_ByConfig_For(int sequence, int config);
        IVectorData GetSpotData_M_ByConfig_For(int sequence, int config);
        IVectorData GetSpotData_N_ByConfig_For(int sequence, int config);
        IVectorData GetSpotData_Flux_ByConfig_For(int sequence, int config);
        IVectorData GetSpotData_X_ByConfig_For(int sequence, int config, int wave);
        IVectorData GetSpotData_Y_ByConfig_For(int sequence, int config, int wave);
        IVectorData GetSpotData_Z_ByConfig_For(int sequence, int config, int wave);
        IVectorData GetSpotData_L_ByConfig_For(int sequence, int config, int wave);
        IVectorData GetSpotData_M_ByConfig_For(int sequence, int config, int wave);
        IVectorData GetSpotData_N_ByConfig_For(int sequence, int config, int wave);
        IVectorData GetSpotData_Flux_ByConfig_For(int sequence, int config, int wave);
    }

    [ComVisible(true)]
    [Guid("A3CF12B7-6361-41C1-BCE5-11B246C07227")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_SpotDataResultMatrix
    {
        double Get_X_For(int fieldN, int waveN);
        double Get_Y_For(int fieldN, int waveN);
        double Get_Z_For(int fieldN, int waveN);
        double Get_L_For(int fieldN, int waveN);
        double Get_M_For(int fieldN, int waveN);
        double Get_N_For(int fieldN, int waveN);

        double GetDetector_X_For(int fieldN, int waveN);
        double GetDetector_Y_For(int fieldN, int waveN);
        double GetDetector_Z_For(int fieldN, int waveN);
        double GetGeoSpotSizeFor(int fieldN, int waveN);

        double GetRMSSpotSizeFor(int fieldN, int waveN);
        double GetRMSSpot_X_For(int fieldN, int waveN);
        double GetRMSSpot_Y_For(int fieldN, int waveN);

        double GetReferenceCoordinate_X_For(int fieldN, int waveN);
        double GetReferenceCoordinate_Y_For(int fieldN, int waveN);

        double HalfWidth_X { get; }
        double HalfWidth_Y { get; }

        double MaxRadius { get; }
        double MeanRadius { get; }

        int NumberOfFields { get; }
        int NumberOfWavelengths { get; }
    }

    [ComVisible(true)]
    [Guid("B8B620E8-3C5A-4677-B44C-7E57CD8EA2C1")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_PathAnalysisData
    {
        double TotalFluxIn { get; }
        double TotalFluxOut { get; }
        uint TotalRays { get; }
        uint TotalHits { get; }
        uint NumPaths { get; }
        uint PathNumber { get; set; }
        uint PathBranches { get; }
        uint PathSource { get; }
        uint LastObject { get; }
        uint LastFace { get; }
        double PathFluxOut { get; }
        double PathFluxPercent { get; }
        string PathSequence { get; }
        IAR_PathAnalysisEntry[] Paths { get; }

        IAR_PathAnalysisEntry GetPathNumber(uint idx);
        IAR_PathAnalysisEntry GetPathUncategorized();
    }

    [ComVisible(true)]
    [Guid("EA60F439-7AEB-499D-9E62-5771459588DC")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_NSCSingleRayTraceData
    {
        bool IsValid { get; }

        string ZRDFile { get; }
        int NumberOfSegments { get; }
        int WaveIndex { get; }
        double WavelengthUM { get; }

        bool ReadSegmentFull(
            int segmentNumber,
            out int segmentLevel,
            out int segmentParent,
            out int hitObj, out int hitFace,
            out int insideOf,
            out Tools.RayTrace.RayStatus status,
            out double x, out double y, out double z,
            out double l, out double m, out double n,
            out double exr, out double exi,
            out double eyr, out double eyi,
            out double ezr, out double ezi,
            out double intensity,
            out double pathLength,
            out int xybin, out int lmbin,
            out double xNorm, out double yNorm, out double zNorm,
            out double index, out double startingPhase,
            out double phaseOf, out double phaseAt);
    }

        [ComVisible(true)]
    [Guid("6BF1DFF7-E038-4661-BE64-04F3AF547816")]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IAR_PathAnalysisEntry
    {
        uint PathNumber { get; }
        UInt64 RaysInPath { get; }
        uint HitsInPath { get; }
        uint GhostsInPath { get; }
        uint UniqueObjectsInPath { get; }
        double TotalPathFlux { get; }
        uint NumberOfObjectsInPath { get; }
        int[] PathObjectList { get; }
        int[,] PathObjectAndFaceList { get; }
        int GetPathObjectNumber(int objectNumber);
        int PathSource { get; }
    }
}

Connect with Ansys