Zemax OpticStudio ZOS-API 2026 R1

File SequenceSelector.cs

Last update: 13.03.2026

Classes

Namespaces

Source

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;

namespace ZOSAPI.Tools.Sequences
{

    [ComVisible(true)]
    [Serializable]
    public class SequenceElement
    {
        public int ObjectNumber { get; }
        public int FaceNumber { get; }

        [Obsolete("Use the DiffOrderX property instead.", false)]
        public int? DiffractionOrderX => HasDiffractionX ? (int?)DiffOrderX : null;
        [Obsolete("Use the DiffOrderY property instead.", false)]
        public int? DiffractionOrderY => HasDiffractionY ? (int?)DiffOrderY : null;

        public bool HasDiffraction => HasDiffractionX || HasDiffractionY;

        public SequenceElement(
            int objectNumber, int faceNumber, int? diffractionOrderX = null, int? diffractionOrderY = null
        )
            : this(objectNumber, faceNumber, diffractionOrderX ?? NotDiffracted, diffractionOrderY ?? NotDiffracted)
        {
        }

        public override bool Equals(object obj)
        {
            return obj is SequenceElement other && (
                ObjectNumber == other.ObjectNumber &&
                FaceNumber == other.FaceNumber &&
                DiffOrderX == other.DiffOrderX &&
                DiffOrderY == other.DiffOrderY
            );
        }

        public override int GetHashCode()
        {
            // Note: auto-generated by VS
            int hashCode = 1011054043;
            hashCode = hashCode * -1521134295 + ObjectNumber.GetHashCode();
            hashCode = hashCode * -1521134295 + FaceNumber.GetHashCode();
            hashCode = hashCode * -1521134295 + DiffOrderX.GetHashCode();
            hashCode = hashCode * -1521134295 + DiffOrderY.GetHashCode();
            return hashCode;
        }

        public override string ToString()
        {
            if (HasDiffractionX && HasDiffractionY)
                return string.Format(
                    "{0}.{1}/({2},{3})",
                    ObjectNumber,
                    FaceNumber,
                    DiffOrderX,
                    DiffOrderY
                );
            if (HasDiffractionX)
                return string.Format(
                    "{0}.{1}/({2},*)",
                    ObjectNumber,
                    FaceNumber,
                    DiffOrderX
                );
            if (HasDiffractionY)
                return string.Format(
                    "{0}.{1}/(*,{2})",
                    ObjectNumber,
                    FaceNumber,
                    DiffOrderY
                );
            return string.Format("{0}.{1}", ObjectNumber, FaceNumber);
        }

        #region Added in 2025 R2 SP04

        public static readonly int NotDiffracted = 100;

        public int DiffOrderX { get; }
        public int DiffOrderY { get; }

        public bool HasDiffractionX => DiffOrderX != NotDiffracted;
        public bool HasDiffractionY => DiffOrderY != NotDiffracted;

        public SequenceElement(int objectNumber, int faceNumber, int diffractionOrderX, int diffractionOrderY)
        {
            ObjectNumber = objectNumber;
            FaceNumber = faceNumber;
            DiffOrderX = diffractionOrderX;
            DiffOrderY = diffractionOrderY;
        }

        public SequenceElement(int objectNumber, int faceNumber)
            : this(objectNumber, faceNumber, NotDiffracted, NotDiffracted)
        {
        }

        #endregion
    }

    [Guid("CA544B17-9BBD-415A-85B3-E30BEC072E01")]
    [ComVisible(true)]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISequence
    {
        string Name { get; }

        List<SequenceElement> Elements { get; }

        SequenceElement Source { get; }
        SequenceElement Stop { get; }
        SequenceElement Image { get; }

        double Flux { get; }

        bool IsValid { get; }
        bool IsEnabled { get; }
        bool IsComplete { get; }

        bool AreAllElementsUnique { get; }

        int NumDiffractiveElements { get; }

        bool HasDefinedStop { get; }

        #region Added in 2025 R2 SP04

        int NumberOfElements { get; }

        int GhostOrder { get; }
        bool HasGhostOrder { get; }

        int TIROrder { get; }
        bool HasTIROrder { get; }

        double MeanPathLength { get; }

        uint NumRays { get; }

        bool IsResolved { get; }

        int NumDiffractiveEvents { get; }

        SequenceElement GetElementAt(int index);

        #endregion
    }

#if true // NSC_SEQUENCES_GROUPING
    [Guid("3a6fb814-6a62-4adf-a2fe-398b8488c191")]
    [ComVisible(true)]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISequenceGroup
    {
        string Name { get; }

        int NumberOfSequences { get; }

        List<ISequence> Sequences { get; }

        ISequence GetSequenceAt(int index);
    }
#endif

    [Guid("384D43E4-9AC4-40EB-B146-AD2BA726B921")]
    [ComVisible(true)]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISequenceGenerationSettings
    {
#if true // NSC_SEQUENCES_GROUPING
        string AddToGroup { get; set; }
        bool DoAutoGrouping { get; set; }
#endif
    }

    [Guid("17D40E7C-F8A4-4A00-B9D1-1C78A5A0AC8C")]
    [ComVisible(true)]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IStraightThroughPathsGenerationSettings : ISequenceGenerationSettings
    {
        bool EndWithDetector { get; set; }
    }
    
    [Guid("0EC6F4B7-338A-4F82-A801-7F1DFBC490ED")]
    [ComVisible(true)]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IFromPathAnalysisGenerationSettings : ISequenceGenerationSettings
    {
        int FilterNumber { get; set; }
        bool IncludeAllUpToFilterNumber { get; set; }
    }

    [Guid("BBCEA4BB-B6B9-4CA9-8E53-51DB7A634DB2")]
    [ComVisible(true)]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface IViaZRDOrPAFGenerationSettings : ISequenceGenerationSettings
    {
        string RayDatabaseFile { get; set; }
        string FilterString { get; set; }
        Analysis.RayTracing.PathAnalysisSortType SortBy { get; set; }
        double RelativeMinimumFlux { get; set; }
    }

    [Guid("D577ECCB-E508-458F-BDB0-FBDF1FD8D33E")]
    [ComVisible(true)]
    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
    public interface ISequenceSelector : ISystemTool
    {
        int NumberOfSequences { get; }

        /* Sequence Access */

        bool ContainsSequenceName(string name);

        [Obsolete("Use the GetIndexOfSequenceByName method instead.", false)]
        int? IndexOfSequenceName(string name);

        ISequence GetSequenceAt(int index);
        ISequence FindSequenceByName(string name);

        /* Modifiers */

        void ClearSequences();

        void DeleteSequence(int index);
        int DeleteSequences(IEnumerable<int> indices);
        int DeleteSequenceRange(int start, int end);
        int DeleteInvalidSequences();
        int DeleteIncompleteSequences();
        int DeleteSequencesBelowFlux(double minFlux);

        bool EnableSequence(int index);
        bool DisableSequence(int index);

        void RenameSequence(int index, string newName);

        void ReplaceSequence(int index, string sequence);
        void ReplaceSequence(int index, IEnumerable<object> sequence);

        void AddSequence(string sequence);
        void AddSequence(IEnumerable<object> sequence);

        int OffsetObjectNumbersInSequence(int index, int startAtObject, int off);
        int OffsetObjectNumbersInSequence(int index, int startAtObject, int endAtObject, int off);

        /* Sorting */

        void SortByAscendingFlux();
        void SortByDescendingFlux();

        void SortByAscendingSize();
        void SortByDescendingSize();

        void SortByAscendingNumDiffractions();
        void SortByDescendingNumDiffractions();

        /* Serialization */

        void LoadSequences(string filePath);

        void InsertSequencesFromFile(string filePath);

        void SaveSequences(string filePath, bool formatted = false);

        /* Wizard */

        ISequenceGenerationSettings GenerationSettings { get; set; }

        IStraightThroughPathsGenerationSettings SelectStraightThroughPathsGeneration();
        IFromPathAnalysisGenerationSettings SelectFromPathAnalysisGeneration();
        IViaZRDOrPAFGenerationSettings SelectViaZRDOrPAFGeneration();

        [ComVisible(false)]
        bool Undo();

        #region Added in 2025 R2 SP04

        int GetIndexOfSequenceByName(string name);

        void ClearAll();

        void ResetDefaultSequenceNames();
        void ResetAllSequenceNames();

        void SortByAscendingGhostOrder();
        void SortByDescendingGhostOrder();

        void SortByDescendingTIROrder();
        void SortByAscendingTIROrder();

        void SortByDescendingMeanPathLength();
        void SortByAscendingMeanPathLength();

        void SortByDescendingNumRays();
        void SortByAscendingNumRays();

        void SortByDescendingUniqueCount();
        void SortByAscendingUniqueCount();

        void SortByDescendingImageObjectNumber();
        void SortByAscendingImageObjectNumber();

#if true // NSC_SEQUENCES_GROUPING
        /* Grouping */

        int NumberOfGroups { get; }

        List<string> GroupNames { get; }

        string GetGroupNameAt(int index);

        ISequenceGroup GetSequenceGroup(string groupName);

        void MakeNewGroup(string groupName);

        void AddSequenceToGroup(string groupName, int index);
        void AddSequencesToGroup(string groupName, IEnumerable<int> indices);

        void RemoveSequenceFromGroup(string groupName, int index);
        void RemoveSequencesFromGroup(string groupName, IEnumerable<int> indices);

        void MergeSequenceGroups(string groupNameA, string groupNameB);
        void MergeSequenceGroups(IEnumerable<string> groupNames);

        void RenameGroup(string groupName, string newName);

        void RemoveGroup(string groupName);
        int RemoveAllGroups();

        void ApplyAutomaticGrouping();
#endif

        #endregion
    }

}

Connect with Ansys