Actual source code: ptype.c

  1: /*
  2:      Provides utility routines for manipulating any type of PETSc object.
  3: */
  4: #include <petscsys.h>

  6: const char *const PetscDataTypes[] = {"UNKNOWN",  "DOUBLE", "COMPLEX", "LONG",   "SHORT", "FLOAT", "CHAR",  "BIT_LOGICAL", "ENUM",          "BOOL",   "__FLOAT128", "OBJECT",
  7:                                       "FUNCTION", "STRING", "__FP16",  "STRUCT", "INT",   "INT64", "COUNT", "INT32",       "PetscDataType", "PETSC_", NULL};

  9: /*@C
 10:   PetscDataTypeToMPIDataType - Converts the `PetscDataType` name of a datatype to its `MPI_Datatype`

 12:   Not Collective

 14:   Input Parameter:
 15: . ptype - the PETSc datatype name (for example `PETSC_DOUBLE`)

 17:   Output Parameter:
 18: . mtype - the MPI datatype (for example `MPI_DOUBLE`, ...)

 20:   Level: advanced

 22: .seealso: `PetscDataType`, `PetscMPIDataTypeToPetscDataType()`
 23: @*/
 24: PetscErrorCode PetscDataTypeToMPIDataType(PetscDataType ptype, MPI_Datatype *mtype)
 25: {
 26:   PetscFunctionBegin;
 27:   if (ptype == PETSC_INT) *mtype = MPIU_INT;
 28:   else if (ptype == PETSC_DOUBLE) *mtype = MPI_DOUBLE;
 29: #if defined(PETSC_HAVE_COMPLEX)
 30:   #if defined(PETSC_USE_REAL_SINGLE)
 31:   else if (ptype == PETSC_COMPLEX) *mtype = MPI_C_COMPLEX;
 32:   #elif defined(PETSC_USE_REAL___FLOAT128)
 33:   else if (ptype == PETSC_COMPLEX) *mtype = MPIU___COMPLEX128;
 34:   #else
 35:   else if (ptype == PETSC_COMPLEX) *mtype = MPI_C_DOUBLE_COMPLEX;
 36:   #endif
 37: #endif
 38:   else if (ptype == PETSC_LONG) *mtype = MPI_LONG;
 39:   else if (ptype == PETSC_SHORT) *mtype = MPI_SHORT;
 40:   else if (ptype == PETSC_ENUM) *mtype = MPI_INT;
 41:   else if (ptype == PETSC_BOOL) *mtype = MPI_INT;
 42:   else if (ptype == PETSC_INT64) *mtype = MPIU_INT64;
 43:   else if (ptype == PETSC_COUNT) *mtype = MPIU_COUNT;
 44:   else if (ptype == PETSC_INT32) *mtype = MPIU_INT32;
 45:   else if (ptype == PETSC_FLOAT) *mtype = MPI_FLOAT;
 46:   else if (ptype == PETSC_CHAR) *mtype = MPI_CHAR;
 47:   else if (ptype == PETSC_BIT_LOGICAL) *mtype = MPI_BYTE;
 48: #if defined(PETSC_USE_REAL___FLOAT128)
 49:   else if (ptype == PETSC___FLOAT128) *mtype = MPIU___FLOAT128;
 50: #elif defined(PETSC_USE_REAL___FP16)
 51:   else if (ptype == PETSC___FP16) *mtype = MPIU___FP16;
 52: #endif
 53:   else SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Unknown PETSc datatype");
 54:   PetscFunctionReturn(PETSC_SUCCESS);
 55: }

 57: /*@C
 58:   PetscMPIDataTypeToPetscDataType - Finds the `PetscDataType` name of a datatype from its `MPI_Datatype`

 60:   Not Collective

 62:   Input Parameter:
 63: . mtype - the MPI datatype (for example `MPI_DOUBLE`, ...)

 65:   Output Parameter:
 66: . ptype - the PETSc datatype name (for example `PETSC_DOUBLE`)

 68:   Level: advanced

 70: .seealso: `PetscDataType`
 71: @*/
 72: PetscErrorCode PetscMPIDataTypeToPetscDataType(MPI_Datatype mtype, PetscDataType *ptype)
 73: {
 74:   PetscFunctionBegin;
 75:   if (mtype == MPIU_INT) *ptype = PETSC_INT;
 76: #if defined(PETSC_USE_64BIT_INDICES)
 77:   else if (mtype == MPI_INT) *ptype = PETSC_ENUM;
 78: #endif
 79:   else if (mtype == MPIU_INT64) *ptype = PETSC_INT64;
 80:   else if (mtype == MPIU_COUNT) *ptype = PETSC_COUNT;
 81:   else if (mtype == MPIU_INT32) *ptype = PETSC_INT32;
 82:   else if (mtype == MPI_DOUBLE) *ptype = PETSC_DOUBLE;
 83: #if defined(PETSC_HAVE_COMPLEX)
 84:   #if defined(PETSC_USE_REAL_SINGLE)
 85:   else if (mtype == MPI_C_COMPLEX) *ptype = PETSC_COMPLEX;
 86:   #elif defined(PETSC_USE_REAL___FLOAT128)
 87:   else if (mtype == MPIU___COMPLEX128) *ptype = PETSC_COMPLEX;
 88:   #else
 89:   else if (mtype == MPI_C_DOUBLE_COMPLEX) *ptype = PETSC_COMPLEX;
 90:   #endif
 91: #endif
 92:   else if (mtype == MPI_LONG) *ptype = PETSC_LONG;
 93:   else if (mtype == MPI_SHORT) *ptype = PETSC_SHORT;
 94:   else if (mtype == MPI_FLOAT) *ptype = PETSC_FLOAT;
 95:   else if (mtype == MPI_CHAR) *ptype = PETSC_CHAR;
 96: #if defined(PETSC_USE_REAL___FLOAT128)
 97:   else if (mtype == MPIU___FLOAT128) *ptype = PETSC___FLOAT128;
 98: #elif defined(PETSC_USE_REAL___FP16)
 99:   else if (mtype == MPIU___FP16) *ptype = PETSC___FP16;
100: #endif
101:   else SETERRQ(PETSC_COMM_SELF, PETSC_ERR_SUP, "Unhandled MPI datatype");
102:   PetscFunctionReturn(PETSC_SUCCESS);
103: }

105: typedef enum {
106:   PETSC_INT_SIZE    = sizeof(PetscInt),
107:   PETSC_DOUBLE_SIZE = sizeof(double),
108: #if defined(PETSC_HAVE_COMPLEX)
109:   PETSC_COMPLEX_SIZE = sizeof(PetscComplex),
110: #else
111:   PETSC_COMPLEX_SIZE = 2 * sizeof(PetscReal),
112: #endif
113:   PETSC_LONG_SIZE        = sizeof(long),
114:   PETSC_SHORT_SIZE       = sizeof(short),
115:   PETSC_FLOAT_SIZE       = sizeof(float),
116:   PETSC_CHAR_SIZE        = sizeof(char),
117:   PETSC_ENUM_SIZE        = sizeof(PetscEnum),
118:   PETSC_BOOL_SIZE        = sizeof(PetscBool),
119:   PETSC_INT64_SIZE       = sizeof(PetscInt64),
120:   PETSC_INT32_SIZE       = sizeof(PetscInt32),
121:   PETSC_BIT_LOGICAL_SIZE = sizeof(char),
122:   PETSC_COUNT_SIZE       = sizeof(PetscCount)
123: #if defined(PETSC_USE_REAL___FLOAT128)
124:     ,
125:   PETSC___FLOAT128_SIZE = sizeof(__float128)
126: #elif defined(PETSC_USE_REAL___FP16)
127:     ,
128:   PETSC___FP16_SIZE = sizeof(__fp16)
129: #endif
130: } PetscDataTypeSize;

132: /*@C
133:   PetscDataTypeGetSize - Gets the size (in bytes) of a PETSc datatype

135:   Not Collective

137:   Input Parameter:
138: . ptype - the PETSc datatype name (for example `PETSC_DOUBLE`)

140:   Output Parameter:
141: . size - the size in bytes (for example the size of `PETSC_DOUBLE` is 8)

143:   Level: advanced

145: .seealso: `PetscDataType`, `PetscDataTypeToMPIDataType()`
146: @*/
147: PetscErrorCode PetscDataTypeGetSize(PetscDataType ptype, size_t *size)
148: {
149:   PetscFunctionBegin;
150:   if ((int)ptype < 0) *size = -(int)ptype;
151:   else if (ptype == PETSC_INT) *size = PETSC_INT_SIZE;
152:   else if (ptype == PETSC_DOUBLE) *size = PETSC_DOUBLE_SIZE;
153:   else if (ptype == PETSC_COMPLEX) *size = PETSC_COMPLEX_SIZE;
154:   else if (ptype == PETSC_LONG) *size = PETSC_LONG_SIZE;
155:   else if (ptype == PETSC_SHORT) *size = PETSC_SHORT_SIZE;
156:   else if (ptype == PETSC_FLOAT) *size = PETSC_FLOAT_SIZE;
157:   else if (ptype == PETSC_CHAR) *size = PETSC_CHAR_SIZE;
158:   else if (ptype == PETSC_ENUM) *size = PETSC_ENUM_SIZE;
159:   else if (ptype == PETSC_BOOL) *size = PETSC_BOOL_SIZE;
160:   else if (ptype == PETSC_INT64) *size = PETSC_INT64_SIZE;
161:   else if (ptype == PETSC_INT32) *size = PETSC_INT32_SIZE;
162:   else if (ptype == PETSC_COUNT) *size = PETSC_COUNT_SIZE;
163:   else if (ptype == PETSC_BIT_LOGICAL) *size = PETSC_BIT_LOGICAL_SIZE;
164: #if defined(PETSC_USE_REAL___FLOAT128)
165:   else if (ptype == PETSC___FLOAT128) *size = PETSC___FLOAT128_SIZE;
166: #elif defined(PETSC_USE_REAL___FP16)
167:   else if (ptype == PETSC___FP16) *size = PETSC___FP16_SIZE;
168: #endif
169:   else SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE, "Unknown PETSc datatype");
170:   PetscFunctionReturn(PETSC_SUCCESS);
171: }

173: /*@
174:   PetscDataTypeFromString - Gets the enum value of a PETSc datatype represented as a string

176:   Not Collective

178:   Input Parameter:
179: . name - the PETSc datatype name (for example, "double" or "real")

181:   Output Parameters:
182: + ptype - the enum value, only valid if found is `PETSC_TRUE`
183: - found - the string matches one of the data types

185:   Level: advanced

187: .seealso: `PetscDataType`, `PetscDataTypeToMPIDataType()`, `PetscDataTypeGetSize()`
188: @*/
189: PetscErrorCode PetscDataTypeFromString(const char name[], PetscDataType *ptype, PetscBool *found)
190: {
191:   PetscFunctionBegin;
192:   PetscCall(PetscEnumFind(PetscDataTypes, name, (PetscEnum *)ptype, found));
193:   if (!*found) {
194:     char formatted[16];

196:     PetscCall(PetscStrncpy(formatted, name, 16));
197:     PetscCall(PetscStrtolower(formatted));
198:     PetscCall(PetscStrcmp(formatted, "scalar", found));
199:     if (*found) {
200:       *ptype = PETSC_SCALAR;
201:     } else {
202:       PetscCall(PetscStrcmp(formatted, "real", found));
203:       if (*found) *ptype = PETSC_REAL;
204:     }
205:   }
206:   PetscFunctionReturn(PETSC_SUCCESS);
207: }