KratosMultiphysics
KRATOS Multiphysics (Kratos) is a framework for building parallel, multi-disciplinary simulation software, aiming at modularity, extensibility, and high performance. Kratos is written in C++, and counts with an extensive Python interface.
Public Member Functions | Public Attributes | List of all members
empire_wrapper.EmpireWrapper.__EmpireWrapper Class Reference
Collaboration diagram for empire_wrapper.EmpireWrapper.__EmpireWrapper:

Public Member Functions

def __init__ (self, echo_level, dry_run)
 
def Connect (self, xml_input_file)
 Establishes the necessary connection with the Emperor. More...
 
def Disconnect (self)
 Performs disconnection and finalization operations to the Emperor. More...
 
def SendMesh (self, mesh_name, model_part)
 Send the mesh to the server. More...
 
def ReceiveMesh (self, mesh_name, model_part)
 Recieve mesh from the server. More...
 
def SendDataField (self, mesh_name, data_field_name, kratos_variables)
 Send data field to the server. More...
 
def ReceiveDataField (self, mesh_name, data_field_name, kratos_variables)
 Receive data field from the server. More...
 
def SendArray (self, array_name, array_to_send)
 Send signal to the server. More...
 
def ReceiveArray (self, array_name, array_size)
 Receive signal from the server. More...
 
def SendConvergenceSignal (self, signal)
 Send the convergence signal of an loop. More...
 
def ReceiveConvergenceSignal (self)
 Receive the convergence signal of an loop. More...
 

Public Attributes

 model_parts
 
 echo_level
 
 dry_run
 
 libempire_api
 

Constructor & Destructor Documentation

◆ __init__()

def empire_wrapper.EmpireWrapper.__EmpireWrapper.__init__ (   self,
  echo_level,
  dry_run 
)

Constructor #####

Member Function Documentation

◆ Connect()

def empire_wrapper.EmpireWrapper.__EmpireWrapper.Connect (   self,
  xml_input_file 
)

Establishes the necessary connection with the Emperor.

Public Functions #####

◆ Disconnect()

def empire_wrapper.EmpireWrapper.__EmpireWrapper.Disconnect (   self)

Performs disconnection and finalization operations to the Emperor.

◆ ReceiveArray()

def empire_wrapper.EmpireWrapper.__EmpireWrapper.ReceiveArray (   self,
  array_name,
  array_size 
)

Receive signal from the server.

Parameters
[in]namename of the signal
[in]sizeOfArraysize of the array (signal)
[in]signalthe signal

void EMPIRE_API_recvSignal_double(char *name, int sizeOfArray, double *signal);

◆ ReceiveConvergenceSignal()

def empire_wrapper.EmpireWrapper.__EmpireWrapper.ReceiveConvergenceSignal (   self)

Receive the convergence signal of an loop.

Returns
1 means convergence, 0 means non-convergence

int EMPIRE_API_recvConvergenceSignal();

◆ ReceiveDataField()

def empire_wrapper.EmpireWrapper.__EmpireWrapper.ReceiveDataField (   self,
  mesh_name,
  data_field_name,
  kratos_variables 
)

Receive data field from the server.

Parameters
[in]namename of the field
[in]sizeOfArraysize of the array (data field)
[out]dataFieldthe data field to be received

void EMPIRE_API_recvDataField(char *name, int sizeOfArray, double *dataField);

◆ ReceiveMesh()

def empire_wrapper.EmpireWrapper.__EmpireWrapper.ReceiveMesh (   self,
  mesh_name,
  model_part 
)

Recieve mesh from the server.

Parameters
[in]namename of the mesh
[in]numNodesnumber of nodes
[in]numElemsnumber of elements
[in]nodescoordinates of all nodes
[in]nodeIDsIDs of all nodes
[in]numNodesPerElemnumber of nodes per element
[in]elemsconnectivity table of all elements

void EMPIRE_API_recvMesh(char *name, int *numNodes, int *numElems, double **nodes, int **nodeIDs, int **numNodesPerElem, int **elem);

◆ SendArray()

def empire_wrapper.EmpireWrapper.__EmpireWrapper.SendArray (   self,
  array_name,
  array_to_send 
)

Send signal to the server.

Parameters
[in]namename of the signal
[in]sizeOfArraysize of the array (signal)
[in]signalthe signal

void EMPIRE_API_sendSignal_double(char *name, int sizeOfArray, double *signal);

◆ SendConvergenceSignal()

def empire_wrapper.EmpireWrapper.__EmpireWrapper.SendConvergenceSignal (   self,
  signal 
)

Send the convergence signal of an loop.

Parameters
[in]signal1 means convergence, 0 means non-convergence void EMPIRE_API_sendConvergenceSignal(int signal);

◆ SendDataField()

def empire_wrapper.EmpireWrapper.__EmpireWrapper.SendDataField (   self,
  mesh_name,
  data_field_name,
  kratos_variables 
)

Send data field to the server.

Parameters
[in]namename of the field
[in]sizeOfArraysize of the array (data field)
[in]dataFieldthe data field to be sent

void EMPIRE_API_sendDataField(char *name, int sizeOfArray, double *dataField);

◆ SendMesh()

def empire_wrapper.EmpireWrapper.__EmpireWrapper.SendMesh (   self,
  mesh_name,
  model_part 
)

Send the mesh to the server.

Parameters
[in]namename of the mesh
[in]numNodesnumber of nodes
[in]numElemsnumber of elements
[in]nodescoordinates of all nodes
[in]nodeIDsIDs of all nodes
[in]numNodesPerElemnumber of nodes per element
[in]elemsconnectivity table of all elements

void EMPIRE_API_sendMesh(char *name, int numNodes, int numElems, double *nodes, int *nodeIDs, int *numNodesPerElem, int *elems);

Member Data Documentation

◆ dry_run

empire_wrapper.EmpireWrapper.__EmpireWrapper.dry_run

◆ echo_level

empire_wrapper.EmpireWrapper.__EmpireWrapper.echo_level

◆ libempire_api

empire_wrapper.EmpireWrapper.__EmpireWrapper.libempire_api

◆ model_parts

empire_wrapper.EmpireWrapper.__EmpireWrapper.model_parts

The documentation for this class was generated from the following file: