Motion_MotionSolutionBuilder.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
// C++接口到JA API的头文件
//--------------------------------------------------------------------------
//
// 源文件:
//     Motion_MotionSolutionBuilder.ja
//
// 生成方式:
//     apiwrap
//
// 警告:
//    此文件由系统自动生成 - 请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/Expression.hxx>
#include <NXOpen/Motion_AdamsSolverProperty.hxx>
#include <NXOpen/Motion_RecurdynSolverProperty.hxx>
#include <NXOpen/Motion_EntityPropTableBuilder.hxx>
#include <NXOpen/libnxopencpp_motion_exports.hxx>
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4996)
#endif
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace NXOpen
{
    namespace Motion
    {
        class MotionSolutionBuilder;
    }
    class Direction;
    class Expression;
    namespace Motion
    {
        class AdamsSolverProperty;
    }
    namespace Motion
    {
        class EntityPropTableBuilder;
    }
    namespace Motion
    {
        class RecurdynSolverProperty;
    }
    namespace Motion
    {
        class _MotionSolutionBuilderBuilder;
        class MotionSolutionBuilderImpl;
        class NXOPENCPP_MOTIONEXPORT  MotionSolutionBuilder : public NXOpen::Motion::EntityPropTableBuilder
        {
            public: enum SolutionTypes
            {
                SolutionTypesNormal,
                SolutionTypesArticulation,
                SolutionTypesSpreadsheet,
                SolutionTypesFlexbody
            };

            public: enum AnalysisTypes
            {
                AnalysisTypesDynamic,
                AnalysisTypesStatic,
                AnalysisTypesControl
            };

            public: enum Objective
            {
                ObjectiveIntegratedSolve,
                ObjectiveExportToExternalPlatform
            };

            public: enum Platform
            {
                PlatformAmesim,
                PlatformSimulink,
                PlatformFmi,
                PlatformProcyon,
                PlatformConcurrent,
                PlatformDspace,
                PlatformScalexio
            };

            public: enum WorkingDirectoryType
            {
                WorkingDirectoryTypeSimFolder,
                WorkingDirectoryTypeUserDefined
            };

            public: enum GravityOption
            {
                GravityOptionNoGravity,
                GravityOptionEarthGravity,
                GravityOptionUserDefinedComponent,
                GravityOptionUserDefinedVector
            };

            public: enum GravityValueOption
            {
                GravityValueOptionExpression,
                GravityValueOptionProfile2d
            };

            public: enum StepTypeOption
            {
                StepTypeOptionNumSteps,
                StepTypeOptionStepSize,
                StepTypeOptionPrintIntervalCurve,
                StepTypeOptionSpeedSweepDriver
            };

            public: enum UnitLength
            {
                UnitLengthMillimeter,
                UnitLengthCentimeter,
                UnitLengthMeter,
                UnitLengthInch,
                UnitLengthFoot,
                UnitLengthMicrometer
            };

            public: enum UnitMass
            {
                UnitMassGram,
                UnitMassKilogram,
                UnitMassMetricTonne,
                UnitMassSlinch,
                UnitMassSlug,
                UnitMassMilligram
            };

            public: enum UnitForce
            {
                UnitForceMicronewton,
                UnitForceNewton,
                UnitForceKilogramForce,
                UnitForcePound,
                UnitForceDyne
            };

            public: enum OutputType
            {
                OutputTypeBinary,
                OutputTypeAscii,
                OutputTypeAsciiAndBinary,
                OutputTypeRestartAndBinary,
                OutputTypeRestartAndAscii,
                OutputTypeRestart,
                OutputTypeAll,
                OutputTypeNone,
                OutputTypeBinaryAfterRun
            };

            public: enum PrintMethod
            {
                PrintMethodActual,
                PrintMethodInterpolated
            };

            public: enum KinematicMethod
            {
                KinematicMethodSingleStep,
                KinematicMethodMultiStep
            };

            public: enum InverseDynamicMethod
            {
                InverseDynamicMethodSingleStep,
                InverseDynamicMethodMultiStep
            };

            public: enum AssemblingMethod
            {
                AssemblingMethodOneStage,
                AssemblingMethodTwoStages
            };

            public: enum RedundancyCheck
            {
                RedundancyCheckYes,
                RedundancyCheckNo,
                RedundancyCheckFullPivoting
            };

            public: enum RedundantConstraintCheck
            {
                RedundantConstraintCheckEveryTimeStep,
                RedundantConstraintCheckBeginningOfSimulation
            };

            public: enum MatrixScaling
            {
                MatrixScalingStandard,
                MatrixScalingIterative
            };

            public: enum StaticSolverType
            {
                StaticSolverTypeHarwell,
                StaticSolverTypeQrFull
            };

            public: enum StaticJacobianType
            {
                StaticJacobianTypeFinite,
                StaticJacobianTypeExact
            };

            public: enum DynamicIntegrationMethod
            {
                DynamicIntegrationMethodBdf,
                DynamicIntegrationMethodPece,
                DynamicIntegrationMethodRbdf
            };

            public: enum DynamicSimulationType
            {
                DynamicSimulationTypeCoSimulation,
                DynamicSimulationTypeModelExchange
            };

            public: enum DynamicSolverAcceleration
            {
                DynamicSolverAccelerationBanded,
                DynamicSolverAccelerationHarwell,
                DynamicSolverAccelerationIterative
            };

            public: enum DynamicInitialVelocityMethod
            {
                DynamicInitialVelocityMethodQr,
                DynamicInitialVelocityMethodMoorePenrosePseudoInverse,
                DynamicInitialVelocityMethodMinimumKineticEnergy
            };

            public: enum ConstraintsOptimizationExcludeType
            {
                ConstraintsOptimizationExcludeTypeNone,
                ConstraintsOptimizationExcludeTypeSelect
            };

            public: enum TimeSeriesFileNameFormat
            {
                TimeSeriesFileNameFormatOutputName,
                TimeSeriesFileNameFormatResultOutputName
            };

            public: enum VehicleRoadHeightAdjustment
            {
                VehicleRoadHeightAdjustmentNone,
                VehicleRoadHeightAdjustmentRoad,
                VehicleRoadHeightAdjustmentVehicle
            };

            public: enum RealTimeSystemType
            {
                RealTimeSystemTypeWindows,
                RealTimeSystemTypeLinux
            };

            public: enum StaticSuspensionType
            {
                StaticSuspensionTypeDependent,
                StaticSuspensionTypeIndependent
            };

            public: enum MotionSolverType
            {
                MotionSolverTypeClassic,
                MotionSolverTypeNextGeneration
            };
            private: MotionSolutionBuilderImpl * m_motionsolutionbuilder_impl;
            private: friend class  _MotionSolutionBuilderBuilder;
            protected: MotionSolutionBuilder();
public: ~MotionSolutionBuilder();
            public: NXOpen::Motion::MotionSolutionBuilder::SolutionTypes SolutionType
            (
            );
            public: void SetSolutionType
            (
                NXOpen::Motion::MotionSolutionBuilder::SolutionTypes solutionType 
            );
            public: NXOpen::Motion::MotionSolutionBuilder::AnalysisTypes AnalysisType
            (
            );
            public: void SetAnalysisType
            (
                NXOpen::Motion::MotionSolutionBuilder::AnalysisTypes analysisType 
            );
            public: int Step
            (
            );
            public: void SetStep
            (
                int step 
            );
            public: bool StaticAnalysis
            (
            );
            public: void SetStaticAnalysis
            (
                bool staticAnalysis 
            );
            public: NXOpen::Direction * GravityVector
            (
            );
            public: void SetGravityVector
            (
                NXOpen::Direction * gravityVector 
            );
            public: NXString Description
            (
            );
            public: void SetDescription
            (
                const NXString & description 
            );
            void SetDescription
            (
                const char * description 
            );
            public: NXString Name
            (
            );
            public: void SetName
            (
                const NXString & name 
            );
            void SetName
            (
                const char * name 
            );
            public: NXOpen::Motion::AdamsSolverProperty * AdamsSolverProperty
            (
            );
            public: void SetAdamsSolverProperty
            (
                NXOpen::Motion::AdamsSolverProperty * adamsSolverProperty 
            );
            public: NXOpen::Motion::RecurdynSolverProperty * RecurdynSolverProperty
            (
            );
            public: void SetRecurdynSolverProperty
            (
                NXOpen::Motion::RecurdynSolverProperty * recurdynSolverProperty 
            );
            public: bool IsSkipStep
            (
            );
            public: void SetSkipStep
            (
                bool isSkipStep 
            );
            public: NXString SkipSteps
            (
            );
            public: void SetSkipSteps
            (
                const NXString & skipSteps 
            );
            void SetSkipSteps
            (
                const char * skipSteps 
            );
            public: NXOpen::Expression * TimeExpression
            (
            );
            public: NXOpen::Expression * GravityValueExpression
            (
            );
        };
    }
}
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#ifdef __GNUC__
#ifndef NX_NO_GCC_DEPRECATION_WARNINGS
#pragma GCC diagnostic warning "-Wdeprecated-declarations"
#endif
#endif
#undef EXPORTLIBRARY