CommonTypes.hpp | Ansys Developer Portal

 /*
 * Copyright ANSYS, Inc. Unauthorized use, distribution, or duplication is prohibited.
 */
  
 #pragma once
  
 #include "SystemCouplingParticipant/CommonSettings.hpp"
 #include "SystemCouplingParticipant/ElementTypes.hpp"
 #include "SystemCouplingParticipant/NonFatalError.hpp"
  
 #include <string>
 #include <utility>
  
 namespace sysc {
  
 enum ConvergenceStatus {
   Diverging = -1,
   NotYetConverged = 0,
   Converged = 1,
   Complete = 2,
   NotEvaluated = 3
 };
  
 enum class DataType {
   Real = 0,
   Complex = 1
 };
  
 struct TimeStep {
   int timeStepNumber{0};    
   double startTime{0.0};    
   double timeStepSize{0.0}; 
   TimeStep() = default;
  
   TimeStep(int timeStepNumber, double startTime, double timeStepSize) :
       timeStepNumber(timeStepNumber),
       startTime(startTime),
       timeStepSize(timeStepSize){};
 };
  
 struct SolutionControl {
   int minimumIterations{0}; 
   int maximumIterations{0}; 
 };
  
 struct SetupInfo {
   /* \brief Provide a constructor for SetupInfo. */
   SetupInfo() = default;
  
   SetupInfo(
     enum AnalysisType analysisType) :
       analysisType(analysisType){};
  
   SetupInfo(
     enum AnalysisType analysisType,
     bool restartsSupported) :
       analysisType(analysisType),
       restartsSupported(restartsSupported){};
  
   SetupInfo(
     enum AnalysisType analysisType,
     bool restartsSupported,
     enum Dimension dimension) :
       analysisType(analysisType),
       restartsSupported(restartsSupported),
       dimension(dimension){};
  
   SetupInfo(
     enum AnalysisType analysisType,
     bool restartsSupported,
     enum Dimension dimension,
     enum TimeIntegration timeIntegration) :
       analysisType(analysisType),
       restartsSupported(restartsSupported),
       dimension(dimension),
       timeIntegration(timeIntegration){};
  
   AnalysisType analysisType{Steady}; 
   bool restartsSupported{false};
   Dimension dimension{Dimension::D3};                         
   TimeIntegration timeIntegration{TimeIntegration::Implicit}; 
 };
  
 struct SetupFileInfo {
   std::string setupFileName; 
   bool restartsSupported;    
   SetupFileInfo() :
       restartsSupported(false){};
  
   SetupFileInfo(std::string setupFileName) :
       setupFileName(std::move(setupFileName)),
       restartsSupported(false){};
  
   SetupFileInfo(std::string setupFileName, bool restartsSupported) :
       setupFileName(std::move(setupFileName)),
       restartsSupported(restartsSupported){};
 };
  
 struct ResultsInfo {
   std::string baseFileName; 
   ResultsInfo(std::string baseFileName) :
       baseFileName(std::move(baseFileName)){};
 };
  
 enum Topology {
   Surface = 2,
   Volume = 3
 };
  
 struct ValidityStatus {
   bool isValid;        
   std::string message; 
   /* \brief Provide a default constructor for ValidityStatus */
   ValidityStatus() :
       isValid(true){};
  
   ValidityStatus(bool isValid, std::string message) :
       isValid(isValid),
       message(std::move(message)){};
 };
  
 struct MeshValidityStatus {
   bool isInvalid;      
   std::string message; 
   /* \brief Provide a default constructor for MeshValidityStatus */
   MeshValidityStatus() :
       isInvalid(false){};
  
   MeshValidityStatus(bool isInvalid, std::string message) :
       isInvalid(isInvalid),
       message(std::move(message)){};
 };
  
 enum PrimitiveType {
   Float = 0,         
   Double = 1,        
   Int32 = 2,         
   Int64 = 3,         
   UnsignedInt16 = 4, 
   UnsignedInt64 = 5  
 };
  
 using OpaqueDataAccess = void*; 
 using RegionName = std::string;            
 using VariableName = std::string;          
 using CouplingInterfaceName = std::string; 
 using RestartPoint = std::string;          
 using TargetDataLocation = std::string;    
 using DisplayName = std::string;           
 using AttributeName = std::string;         
 using ParameterName = std::string;         
 struct ParticipantInfo {
   std::string scHost;
   unsigned short scPort{0};
   std::string participantName;
   bool isCosimulation{false};
   std::string buildInformation;
   std::string transcriptFilename;
  
   ParticipantInfo() = default;
  
   ParticipantInfo(
     std::string scHost,
     unsigned short scPort,
     std::string participantName) :
       scHost(std::move(scHost)),
       scPort(scPort),
       participantName(std::move(participantName)),
       isCosimulation(true)
   {
   }
  
   ParticipantInfo(
     std::string scHost,
     unsigned short scPort,
     std::string participantName,
     std::string buildInformation) :
       scHost(std::move(scHost)),
       scPort(scPort),
       participantName(std::move(participantName)),
       isCosimulation(true),
       buildInformation(std::move(buildInformation))
   {
   }
  
   ParticipantInfo(
     std::string scHost,
     unsigned short scPort,
     std::string participantName,
     std::string buildInformation,
     std::string transcriptFilename) :
       scHost(std::move(scHost)),
       scPort(scPort),
       participantName(std::move(participantName)),
       isCosimulation(true),
       buildInformation(std::move(buildInformation)),
       transcriptFilename(std::move(transcriptFilename))
   {
   }
 };
  
 }  // namespace sysc
System Coupling C++ library 2025 R1

CommonTypes

Connect with Ansys
