Motion_FlexBodyBuilder.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
// JA API的C++接口头文件
//--------------------------------------------------------------------------
//
// 源文件:
//     Motion_FlexBodyBuilder.ja
//
// 生成工具:
//     apiwrap
//
// 警告:
//    此文件为自动生成 - 请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/Expression.hxx>
#include <NXOpen/ExternalFileReferenceAdapter.hxx>
#include <NXOpen/Motion.hxx>
#include <NXOpen/Motion_MarkerToNodeData.hxx>
#include <NXOpen/IExternalFileReferencer.hxx>
#include <NXOpen/Motion_MotionBuilder.hxx>
#include <NXOpen/SelectObject.hxx>
#include <NXOpen/ugmath.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 FlexBodyBuilder;
    }
    class CoordinateSystem;
    class Expression;
    class ExternalFileReferenceAdapter;
    class IExternalFileReferencer;
    namespace Motion
    {
        class MarkerToNodeData;
    }
    namespace Motion
    {
        class MotionBuilder;
    }
    namespace Motion
    {
        class SelectLink;
    }
    class NXObject;
    class Point;
    namespace Motion
    {
        class _FlexBodyBuilderBuilder;
        class FlexBodyBuilderImpl;
        class NXOPENCPP_MOTIONEXPORT  FlexBodyBuilder : public NXOpen::Motion::MotionBuilder, public virtual NXOpen::IExternalFileReferencer
        {
            public: enum Positioning
            {
                PositioningAbsoluteOrigin,
                PositioningComponentPosition,
                PositioningThreePointMethod,
                PositioningAtCSys,
                PositioningMotionBody
            };

            public: enum ModelDefineType
            {
                ModelDefineTypeFEAresult,
                ModelDefineTypeFEAmodel
            };

            public: enum ExternalFileReferenceId
            {
                ExternalFileReferenceIdFEAresult,
                ExternalFileReferenceIdFEAmodel
            };

            public: enum UnitSystemType
            {
                UnitSystemTypeInfered,
                UnitSystemTypeMeterNewton,
                UnitSystemTypeFootPoundalF,
                UnitSystemTypeMeterKilogramF,
                UnitSystemTypeFootPoundal,
                UnitSystemTypeMillimeterMillinewton,
                UnitSystemTypeCentimeterCentinewton,
                UnitSystemTypeInchPoundF,
                UnitSystemTypeMillimeterKilogramF,
                UnitSystemTypeMillimeterNewton,
                UnitSystemTypeCentimeterDyne
            };

            public: enum MassSourceType
            {
                MassSourceTypeFlexibleModel,
                MassSourceTypeCustomizedValues,
                MassSourceTypeCombined
            };

            public: enum MassMatrixType
            {
                MassMatrixTypeLumpedAtOneNode,
                MassMatrixTypeDistributeToNodes
            };

            public: enum DistributionMethodType
            {
                DistributionMethodTypeUseElementData,
                DistributionMethodTypeEquidistributeLumpedMassToAllNodes
            };

            public: enum LumpLocationType
            {
                LumpLocationTypeClosestNode,
                LumpLocationTypeNewNodeAtCG
            };
            private: FlexBodyBuilderImpl * m_flexbodybuilder_impl;
            private: friend class  _FlexBodyBuilderBuilder;
            protected: FlexBodyBuilder();
public: ~FlexBodyBuilder();
            public: NXOpen::Motion::SelectLink * SelectionLink
            (
            );
            public: NXOpen::Motion::FlexBodyBuilder::ModelDefineType ModelDefineOption
            (
            );
            public: void SetModelDefineOption
            (
                NXOpen::Motion::FlexBodyBuilder::ModelDefineType modelDefineOption 
            );
            public: NXString MflxdbFileName
            (
            );
            public: void SetMflxdbFileName
            (
                const NXString & mflxdbFileName 
            );
            void SetMflxdbFileName
            (
                const char * mflxdbFileName 
            );
            public: NXOpen::Motion::FlexBodyBuilder::Positioning PositioningType
            (
            );
            public: void SetPositioningType
            (
                NXOpen::Motion::FlexBodyBuilder::Positioning positioningType 
            );
            public: NXOpen::CoordinateSystem * PositionCSys
            (
            );
            public: void SetPositionCSys
            (
                NXOpen::CoordinateSystem * positionCSys 
            );
            public: NXString Name
            (
            );
            public: void SetName
            (
                const NXString & name 
            );
            void SetName
            (
                const char * name 
            );
            public: std::vector<double> GetOffsetPoints
            (
            );
            public: void SetOffsetPoints
            (
                const std::vector<double> & offsetPoints 
            );
            public: NXOpen::Matrix3x3 GetOffsetOrientationMatrix
            (
            );
            public: void SetOffsetOrientationMatrix
            (
                const NXOpen::Matrix3x3 & matrix 
            );
            public: NXOpen::Motion::ParamOverrideState ListMarkerOvrCtrl
            (
            );
            public: void SetListMarkerOvrCtrl
            (
                NXOpen::Motion::ParamOverrideState overrideState 
            );
            public: std::vector<NXOpen::Motion::MarkerToNodeData *> GetMarkerItems
            (
            );
            public: void SetMarkerItems
            (
                const std::vector<NXOpen::Motion::MarkerToNodeData *> & markerToNodeListItem 
            );
            public: NXOpen::Motion::MarkerToNodeData * FindMarkerItem
            (
                const NXString & markerName 
            );
            NXOpen::Motion::MarkerToNodeData * FindMarkerItem
            (
                const char * markerName 
            );
            public: NXOpen::Motion::MarkerToNodeData * CreateMarkerToNode
            (
                NXOpen::NXObject * marker ,
                int markerPosition ,
                int nodeID 
            );
            public: bool MassScalar0
            (
            );
            public: void SetMassScalar0
            (
                bool massScalar0 
            );
            public: bool MassScalar1
            (
            );
            public: void SetMassScalar1
            (
                bool massScalar1 
            );
            public: bool MassScalar2
            (
            );
            public: void SetMassScalar2
            (
                bool massScalar2 
            );
            public: bool MassVector0
            (
            );
            public: void SetMassVector0
            (
                bool massVector0 
            );
            public: bool MassVector1
            (
            );
            public: void SetMassVector1
            (
                bool massVector1 
            );
            public: bool MassVector2
            (
            );
            public: void SetMassVector2
            (
                bool massVector2 
            );
            public: bool MassVector3
            (
            );
            public: void SetMassVector3
            (
                bool massVector3 
            );
            public: bool MassVector4
            (
            );
            public: void SetMassVector4
            (
                bool massVector4 
            );
            public: bool MassMatrix0
            (
            );
            public: void SetMassMatrix0
            (
                bool massMatrix0 
            );
            public: bool MassMatrix1
            (
            );
            public: void SetMassMatrix1
            (
                bool massMatrix1 
            );
            public: bool MassMatrix2
            (
            );
            public: void SetMassMatrix2
            (
                bool massMatrix2 
            );
            public: bool MassMatrix3
            (
            );
            public: void SetMassMatrix3
            (
                bool massMatrix3 
            );
            public: bool MassMatrix4
            (
            );
            public: void SetMassMatrix4
            (
                bool massMatrix4 
            );
            public: bool UseFrequencyFiltering
            (
            );
            public: void SetUseFrequencyFiltering
            (
                bool useFrequencyFiltering 
            );
            public: NXOpen::Expression * CutoffLowerFrequency
            (
            );
            public: NXOpen::Expression * CutoffUpperFrequency
            (
            );
            public: NXOpen::Expression * CutoffFrequencyIncrement
            (
            );
            public: NXOpen::Expression * CutoffDamping
            (
            );
            public: bool UseTransientDamping
            (
            );
            public: void SetUseTransientDamping
            (
                bool useTransientDamping 
            );
            public: NXOpen::Expression * TransientTime
            (
            );
            public: NXOpen::Motion::FlexBodyBuilder::UnitSystemType UnitSystem
            (
            );
            public: void SetUnitSystem
            (
                NXOpen::Motion::FlexBodyBuilder::UnitSystemType unitSystemID 
            );
            public: bool TreatAsRigid
            (
            );
            public: void SetTreatAsRigid
            (
                bool treatAsRigid 
            );
            public: bool TreatAsErfem
            (
            );
            public: void SetTreatAsErfem
            (
                bool treatAsErfem 
            );
            public: NXOpen::Motion::ParamOverrideState NodeToleranceOvrCtrl
            (
            );
            public: void SetNodeToleranceOvrCtrl
            (
                NXOpen::Motion::ParamOverrideState overrideState 
            );
            public: NXOpen::Expression * NodeTolerance
            (
            );
            public: NXOpen::Motion::FlexBodyBuilder::MassSourceType MassSource
            (
            );
            public: void SetMassSource
            (
                NXOpen::Motion::FlexBodyBuilder::MassSourceType massSource 
            );
            public: bool AssociativeToLink
            (
            );
            public: void SetAssociativeToLink
            (
                bool associativeToLink 
            );
            public: NXOpen::Point * CenterOfMass
            (
            );
            public: void SetCenterOfMass
            (
                NXOpen::Point * centerOfMass 
            );
            public: NXOpen::CoordinateSystem * CsysOfInertia
            (
            );
            public: void SetCsysOfInertia
            (
                NXOpen::CoordinateSystem * csysOfInertia 
            );
            public: NXOpen::Expression * Mass
            (
            );
            public: NXOpen::Expression * InertiaIxx
            (
            );
            public: NXOpen::Expression * InertiaIyy
            (
            );
            public: NXOpen::Expression * InertiaIzz
            (
            );
            public: NXOpen::Expression * InertiaIxy
            (
            );
            public: NXOpen::Expression * InertiaIxz
            (
            );
            public: NXOpen::Expression * InertiaIyz
            (
            );
            public: NXOpen::Motion::FlexBodyBuilder::MassMatrixType MassMatrixDistributionType
            (
            );
            public: void SetMassMatrixDistributionType
            (
                NXOpen::Motion::FlexBodyBuilder::MassMatrixType massMarixType 
            );
            public: NXOpen::Motion::FlexBodyBuilder::DistributionMethodType DistributionMethod
            (
            );
            public: void SetDistributionMethod
            (
                NXOpen::Motion::FlexBodyBuilder::DistributionMethodType distributionMethod 
            );
            public: NXOpen::Motion::FlexBodyBuilder::LumpLocationType LumpLocation
            (
            );
            public: void SetLumpLocation
            (
                NXOpen::Motion::FlexBodyBuilder::LumpLocationType lumpLocation 
            );
            public: NXString SimSolutionName
            (
            );
            public: void SetSimSolutionName
            (
                const NXString & simSolutionName 
            );
            void SetSimSolutionName
            (
                const char * simSolutionName 
            );
            public: void UpdateMassPropertiesFromLink
            (
            );
            public: bool OrthoEnable
            (
            );
            public: void SetOrthoEnable
            (
                bool orthoEnable 
            );
            public: NXOpen::Expression * FrequencyLowerLimit
            (
            );
            public: NXOpen::Expression * FrequencyUpperLimit
            (
            );
            public: void AddAdditionalModalFile
            (
                const NXString & additionalModalFile 
            );
            void AddAdditionalModalFile
            (
                const char * additionalModalFile 
            );
            public: void RemoveAdditionalModalFile
            (
                int fileIndex 
            );
            public: int GetNumAdditionalModalFiles
            (
            );
            public: NXString GetAdditionalModalFileName
            (
                int fileIndex 
            );
            public: void SetAdditionalModalFileUnitSystem
            (
                int fileIndex ,
                NXOpen::Motion::FlexBodyBuilder::UnitSystemType unitSystemID 
            );
            public: NXOpen::Motion::FlexBodyBuilder::UnitSystemType GetAdditionalModalFileUnitSystem
            (
                int fileIndex 
            );
            public: void ComputeModelMassProperties
            (
            );
            public: void RecalculateMarkersPositions
            (
            );
            public: virtual NXOpen::ExternalFileReferenceAdapter * GetExternalFileReferenceAdapter
            (
                int referenceObjectId 
            );
            public: virtual void SetExternalFileReferenceAdapter
            (
                int referenceObjectId ,
                NXOpen::ExternalFileReferenceAdapter * adapter 
            );
            public: virtual NXString GetExternalFileDefinitionKey
            (
                NXOpen::ExternalFileReferenceAdapter * adapter 
            );
            public: virtual NXOpen::ExternalFileReferenceAdapter * EstablishReference
            (
                int referenceObjectId ,
                NXOpen::ExternalFileReferenceAdapter::Type referenceType ,
                const NXString & externalFileSpec 
            );
            virtual NXOpen::ExternalFileReferenceAdapter * EstablishReference
            (
                int referenceObjectId ,
                NXOpen::ExternalFileReferenceAdapter::Type referenceType ,
                const char * externalFileSpec 
            );
        };
    }
}
#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