CommonTypes.hpp | Ansys Developer Portal

/*
* Copyright 2023 ANSYS, Inc. Unauthorized use, distribution, or duplication is prohibited.
*/
 
#pragma once
 
#include "SystemCouplingParticipant/CommonSettings.hpp"
#include "SystemCouplingParticipant/ElementTypes.hpp"
 
#include <string>
 
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(const TimeStep&) = default;
 
  TimeStep(TimeStep&&) = default;
 
  TimeStep& operator=(const TimeStep&) = default;
 
  TimeStep& operator=(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){};
 
  AnalysisType analysisType{Steady}; 
  bool restartsSupported{false};
  Dimension dimension{Dimension::D3}; 
};
 
struct SetupFileInfo {
  std::string setupFileName; 
  bool restartsSupported;    
  SetupFileInfo() :
      restartsSupported(false){};
 
  SetupFileInfo(const std::string& setupFileName) :
      setupFileName(setupFileName),
      restartsSupported(false){};
 
  SetupFileInfo(const std::string& setupFileName, bool restartsSupported) :
      setupFileName(setupFileName),
      restartsSupported(restartsSupported){};
};
 
struct ResultsInfo {
  std::string baseFileName; 
  ResultsInfo(const std::string& baseFileName) :
      baseFileName(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, const std::string& message) :
      isValid(isValid),
      message(message){};
};
 
struct MeshValidityStatus {
  bool isInvalid;      
  std::string message; 
  /* \brief Provide a default constructor for MeshValidityStatus */
  MeshValidityStatus() :
      isInvalid(false){};
 
  MeshValidityStatus(bool isInvalid, const std::string& message) :
      isInvalid(isInvalid),
      message(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 DisplayName = std::string;           
using AttributeName = 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(const ParticipantInfo&) = default;
 
  ParticipantInfo(ParticipantInfo&&) = default;
 
  ParticipantInfo& operator=(const ParticipantInfo&) = default;
 
  ParticipantInfo& operator=(ParticipantInfo&&) = default;
 
  ParticipantInfo(
    const std::string& scHost,
    unsigned short scPort,
    const std::string& participantName) :
      scHost(scHost),
      scPort(scPort),
      participantName(participantName),
      isCosimulation(true)
  {
  }
 
  ParticipantInfo(
    const std::string& scHost,
    unsigned short scPort,
    const std::string& participantName,
    const std::string& buildInformation) :
      scHost(scHost),
      scPort(scPort),
      participantName(participantName),
      isCosimulation(true),
      buildInformation(buildInformation)
  {
  }
 
  ParticipantInfo(
    const std::string& scHost,
    unsigned short scPort,
    const std::string& participantName,
    const std::string& buildInformation,
    const std::string& transcriptFilename) :
      scHost(scHost),
      scPort(scPort),
      participantName(participantName),
      isCosimulation(true),
      buildInformation(buildInformation),
      transcriptFilename(transcriptFilename)
  {
  }
};
 
}  // namespace sysc
System Coupling C++ library 2023 R2

CommonTypes

Connect with Ansys
