apiCAEPUtils.cxx

Go to the documentation of this file.

/****************************************************************************
 *
 * Pointwise Plugin utility functions
 *
 * (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.
 *
 ***************************************************************************/
 
#include <algorithm>
#include <string>
#include <vector>
 
#include <string.h>
 
#include "apiPWP.h"
#include "apiCAEPUtils.h"
#include "apiGridModel.h"
#include "pwpPlatform.h"
 
 
 
CAEP_RTITEM*
caeuFindFormatById (PWP_UINT32 id)
{
    CAEP_RTITEM *ret = 0;
    PWP_UINT32 ii;
    for (ii=0; ii < caepFormatCnt; ++ii) {
        if (id == caepRtItem[ii].FormatInfo.id) {
            ret = &(caepRtItem[ii]);
            break;
        }
    }
    return ret;
}
 
 
CAEP_RTITEM*
caeuFindFormatByName (const char name[])
{
    CAEP_RTITEM *ret = 0;
    PWP_UINT32 ii;
    for (ii=0; ii < caepFormatCnt; ++ii) {
        if (0 == strcmp(caepRtItem[ii].FormatInfo.name, name)) {
            ret = &(caepRtItem[ii]);
            break;
        }
    }
    return ret;
}
 
 
PWP_BOOL
caeuProgressInit(CAEP_RTITEM *pRti, PWP_UINT32 cnt)
{
    PWP_BOOL ret = PWP_FALSE;
    if (nullptr != pRti) {
        // Setting both to PWP_UINT32_MAX indicates are are before first step
        pRti->progTotal = PWP_UINT32_MAX;
        pRti->progComplete  = PWP_UINT32_MAX;
        pRti->clocks[CAEPU_CLKS_PROGUPDATE] =
            pRti->clocks[CAEPU_CLKS_PROGINIT] = clock();
        ret = PwuProgressBegin(pRti->pApiData->apiInfo.name, cnt);
        pRti->opAborted = !ret;
    }
    return ret;
}
 
 
PWP_BOOL
caeuProgressBeginStep(CAEP_RTITEM *pRti, PWP_UINT32 total)
{
    PWP_BOOL ret = PWP_CAST_BOOL((nullptr != pRti) && (0 != total) &&
        !pRti->opAborted);
    if (ret) {
        const bool IsFirstStep = (PWP_UINT32_MAX == pRti->progComplete) &&
            (PWP_UINT32_MAX == pRti->progTotal);
        pRti->progComplete = 0;
        pRti->progTotal = total;
        if (!IsFirstStep) {
            ret = PwuProgressNextStep(pRti->pApiData->apiInfo.name);
        }
        pRti->clocks[CAEPU_CLKS_BEGSTEP] = clock();
    }
    return ret;
}
 
 
PWP_BOOL
caeuProgressIncr(CAEP_RTITEM *pRti)
{
    PWP_BOOL ret = PWP_FALSE;
    if ((nullptr != pRti) && !pRti->opAborted) {
        // send update a max of 2 times per second
        const clock_t DELAY = (CLOCKS_PER_SEC / 2);
        pRti->clocks[CAEPU_CLKS_PROGINCR] = clock();
        ++pRti->progComplete;
        if (DELAY <= CAEPU_RT_CLKS_DIFF(pRti, CAEPU_CLKS_PROGUPDATE,
                        CAEPU_CLKS_PROGINCR)) {
            ret = PwuProgressStatus (pRti->pApiData->apiInfo.name,
                pRti->progComplete, pRti->progTotal);
            pRti->clocks[CAEPU_CLKS_PROGUPDATE] =
                pRti->clocks[CAEPU_CLKS_PROGINCR];
            pRti->opAborted |= !ret;
        }
        else {
            ret = PWP_TRUE;
        }
    }
    return ret;
}
 
 
static void
sendDiffTimeMsg(CAEP_RTITEM *pRti, const char txt[], clock_t diff)
{
    if (nullptr != pRti) {
        PWP_INT32 hours;
        PWP_INT32 minutes;
        PWP_INT32 seconds;
        char msg[512];
        char *p = msg;
        if (txt && txt[0]) {
            strcpy(p, txt);
            strcat(p, ": ");
            p += strlen(p);
        }
        CAEPU_CLKS_TO_HMS(diff, hours, minutes, seconds);
        sprintf(p, "%ld:%02ld:%02ld (h:mm:ss) / %ld msec", (long)hours,
            (long)minutes, (long)seconds, (long)CAEPU_CLKS_TO_MSECS(diff));
        caeuSendDebugMsg(pRti, msg, 0);
    }
}
 
 
static void
sendClkDiffTimeMsg(CAEP_RTITEM *pRti, const char txt[],
    CAEPU_ENUM_CLOCKS startId, CAEPU_ENUM_CLOCKS endId)
{
    if (nullptr != pRti) {
        sendDiffTimeMsg(pRti, txt, CAEPU_RT_CLKS_DIFF(pRti, startId, endId));
    }
}
 
 
PWP_BOOL
caeuProgressEndStep(CAEP_RTITEM *pRti)
{
    const PWP_BOOL ret = PWP_CAST_BOOL(nullptr != pRti);
    if (ret) {
        pRti->clocks[CAEPU_CLKS_ENDSTEP] = clock();
        pRti->progComplete = 0;
        pRti->progTotal = 0;
        sendClkDiffTimeMsg(pRti, "Step time", CAEPU_CLKS_BEGSTEP,
            CAEPU_CLKS_ENDSTEP);
    }
    return ret;
}
 
 
void
caeuProgressEnd(CAEP_RTITEM *pRti, PWP_BOOL ok)
{
    if (nullptr != pRti) {
        pRti->clocks[CAEPU_CLKS_PROGEND] = clock();
        pRti->progTotal = 0;
        pRti->progComplete  = 0;
        pRti->clocks[CAEPU_CLKS_PROGUPDATE] = 0;
        PwuProgressEnd(pRti->pApiData->apiInfo.name, ok);
        sendClkDiffTimeMsg(pRti, "Export time", CAEPU_CLKS_PROGINIT,
            CAEPU_CLKS_PROGEND);
    }
}
 
 
int
caeuFileClose(CAEP_RTITEM* pRti, const CAEP_WRITEINFO *pWriteInfo)
{
    int ret = 0;
    if (nullptr != pRti) {
        switch (pRti->FormatInfo.fileDest) {
        case PWP_FILEDEST_FILENAME:
            if (pRti->fp) {
                if (0 == pwpFileClose(pRti->fp)) {
                    if (pRti->opAborted) {
                        pwpFileDelete(pWriteInfo->fileDest);
                    }
                    else {
                        ret = 1;
                    }
                }
                pRti->fp = 0;
                if (0 != pwpCwdPop()) {
                    ret = 0;
                }
            }
            break;
 
        case PWP_FILEDEST_BASENAME:
        case PWP_FILEDEST_FOLDER:
            /* restore cwd to the original folder.
            */
            if (0 == pwpCwdPop()) {
                ret = 1;
            }
            break;
        case PWP_FILEDEST_SIZE: // silence compiler warning
            break;
        }
    }
    return ret;
}
 
 
void
caeuSendDebugMsg(CAEP_RTITEM *pRti, const char txt[], PWP_UINT32 code)
{
    if (0 != pRti) {
        PwuSendDebugMsg(pRti->pApiData->apiInfo.name, txt, code);
    }
}
 
 
void
caeuSendInfoMsg(CAEP_RTITEM *pRti, const char txt[], PWP_UINT32 code)
{
    if (0 != pRti) {
        PwuSendInfoMsg(pRti->pApiData->apiInfo.name, txt, code);
    }
}
 
 
void
caeuSendWarningMsg(CAEP_RTITEM *pRti, const char txt[], PWP_UINT32 code)
{
    if (0 != pRti) {
        PwuSendWarningMsg(pRti->pApiData->apiInfo.name, txt, code);
    }
}
 
 
void
caeuSendErrorMsg(CAEP_RTITEM *pRti, const char txt[], PWP_UINT32 code)
{
    if (0 != pRti) {
        PwuSendErrorMsg(pRti->pApiData->apiInfo.name, txt, code);
    }
}
 
 
 
PWP_BOOL
caeuPublishValueDefinition(const char key[], PWP_ENUM_VALTYPE type,
    const char value[], const char access[], const char desc[],
    const char range[])
{
    return PwuPublishValueDefinition(CAEP_VALUE_GROUP, key, type, value, access,
        desc, range);
}
 
 
PWP_BOOL
caeuAssignInfoValue(const char key[], const char value[],
    bool createIfNotExists)
{
    return  PwuAssignValueEnum(CAEP_INFO_GROUP, key, value,
                createIfNotExists);
}
 
 
PWP_BOOL
caeuPublishHighOrderValueDefinitions(const PWP_UINT32 maxPolynomialDegree)
{
    bool ret = false;
    if (1 == maxPolynomialDegree) {
        ret = true;  // All is OK. Nothing to do.
    }
    else if ((maxPolynomialDegree >= 2) && (maxPolynomialDegree <= 4)) {
        auto maxPolyDegStr = [maxPolynomialDegree]()-> const char *
        {
            static char ret[2] = { '\0' };
            ret[0] = (char)('0' + maxPolynomialDegree);
            return ret;
        };
        ret = caeuAssignInfoValue("MaxMeshPolynomialDegree", maxPolyDegStr());
    }
 
    return PWP_CAST_BOOL(ret);
}
 
 
PWP_BOOL
caeuPublishMeshLinkValueDefinitions(const char *indexScheme)
{
    const std::vector<std::string> Schemes{
        "ZeroBased", "OneBased", "Custom"
    };
    // indexScheme one of: "ZeroBased", "OneBased", and "Custom"
    const bool ret = (nullptr != indexScheme) && (Schemes.end() !=
        std::find(Schemes.begin(), Schemes.end(), indexScheme)) &&
        caeuAssignInfoValue("MeshLinkSupported", "true", true) &&
        caeuAssignInfoValue("IndexScheme", indexScheme, true);
    return PWP_CAST_BOOL(ret);
}
 
 
PWP_ENDIANNESS
caeuFileByteOrder(PWGM_HGRIDMODEL model)
{
    PWP_ENDIANNESS ret = PwuGetOsEndianness(); // assume Native
    const char *str = 0;
    if (PwModGetAttributeString(model, "FileByteOrder", &str)) {
        // one of: Native|Swap|LittleEndian|BigEndian
        if (0 == strcmp(str, "Swap")) {
            ret = (PWP_ENDIAN_BIG == ret) ? PWP_ENDIAN_LITTLE : PWP_ENDIAN_BIG;
        }
        else if (0 == strcmp(str, "LittleEndian")) {
            ret = PWP_ENDIAN_LITTLE;
        }
        else if (0 == strcmp(str, "BigEndian")) {
            ret = PWP_ENDIAN_BIG;
        }
    }
    return ret;
}
 
 
PWP_BOOL
caeuExportBndryConditionsOnly(PWGM_HGRIDMODEL model)
{
    PWP_BOOL ret;
    return PwModGetAttributeBOOL(model, "BoundaryConditionsOnly", &ret) ? ret :
        PWP_FALSE;
}
 
 
PWP_ENUM_ENCODING
caeuFileEncoding(PWGM_HGRIDMODEL model)
{
    PWP_ENUM_ENCODING ret = PWP_ENCODING_SIZE;
    const char *str = 0;
    if (PwModGetAttributeString(model, "FileFormat", &str)) {
        // one of: ASCII|Binary|Unformatted
        if (0 == strcmp(str, "ASCII")) {
            ret = PWP_ENCODING_ASCII;
        }
        else if (0 == strcmp(str, "Binary")) {
            ret = PWP_ENCODING_BINARY;
        }
        else if (0 == strcmp(str, "Unformatted")) {
            ret = PWP_ENCODING_UNFORMATTED;
        }
        // else something very wrong
    }
    return ret;
}
 
 
PWP_ENUM_PRECISION
caeuFilePrecision(PWGM_HGRIDMODEL model)
{
    PWP_ENUM_PRECISION ret = PWP_PRECISION_SIZE;
    const char *str = 0;
    if (PwModGetAttributeString(model, "FilePrecision", &str)) {
        // one of: Single|Double
        if (0 == strcmp(str, "Single")) {
            ret = PWP_PRECISION_SINGLE;
        }
        else if (0 == strcmp(str, "Double")) {
            ret = PWP_PRECISION_DOUBLE;
        }
        // else something very wrong
    }
    return ret;
}
 
 
PWP_BOOL
caeuExportStructuredAsUnstructured(PWGM_HGRIDMODEL model)
{
    PWP_BOOL ret;
    return PwModGetAttributeBOOL(model, "GridStructuredAsUnstructured", &ret)
        ? ret : PWP_FALSE;
}
 
 
 
static int
openFileName(CAEP_RTITEM* pRti, const CAEP_WRITEINFO *pWriteInfo)
{
    int ret = 0;
    if ((nullptr != pRti) && pWriteInfo && pWriteInfo->fileDest &&
            pWriteInfo->fileDest[0]) {
        caeuFileClose(pRti, pWriteInfo); // sanity check
        switch (pWriteInfo->encoding) {
        case PWP_ENCODING_ASCII:
            pRti->fp = pwpFileOpen(pWriteInfo->fileDest,
                (sysFILEMODE)(pwpWrite | pwpAscii));
            break;
        case PWP_ENCODING_BINARY:
            pRti->fp = pwpFileOpen(pWriteInfo->fileDest,
                (sysFILEMODE)(pwpWrite | pwpBinary));
            break;
        case PWP_ENCODING_UNFORMATTED:
            pRti->fp = pwpFileOpen(pWriteInfo->fileDest,
                (sysFILEMODE)(pwpWrite | pwpUnformatted));
            break;
        case PWP_ENCODING_SIZE: // silence compiler warning
            break;
        }
        ret = (0 != pRti->fp);
    }
    return ret;
}
 
 
static int
fileDestCwdPush(const char *fileDest)
{
    int ret = 0;
    if (fileDest && fileDest[0]) {
        char dir[FILENAME_MAX];
        char *p;
        strcpy(dir, fileDest);
        p = strrchr(dir, '/');
        if (p) {
            // strip file/base name from end of path
            *p = '\0';
            if (0 == pwpCwdPush(dir)) {
                ret = 1;
            }
        }
    }
    return ret;
}
 
 
int
caeuFileOpen(CAEP_RTITEM* pRti, const CAEP_WRITEINFO *pWriteInfo)
{
    int ret = 0;
    if (nullptr != pRti) {
        switch (pRti->FormatInfo.fileDest) {
        /* Plugin wants a full "/path/to/filename.ext"
        */
        case PWP_FILEDEST_FILENAME:
            if (fileDestCwdPush(pWriteInfo->fileDest)) {
                if (!openFileName(pRti, pWriteInfo)) {
                    pwpCwdPop();
                }
                else {
                    ret = 1;
                }
            }
            break;
 
        /* Plugin wants a base "/path/to/basefilename" (no ext)
        */
        case PWP_FILEDEST_BASENAME:
            /* Set the cwd to the given folder.
               It is the plugin's job to open the appropriate files.
            */
            ret = fileDestCwdPush(pWriteInfo->fileDest);
            break;
 
        /* Plugin wants a folder "/path/to/folder/" (no file or ext)
        */
        case PWP_FILEDEST_FOLDER:
            /* Set the cwd to the given folder.
               It is the plugin's job to open the appropriate files.
            */
            if (0 == pwpCwdPush(pWriteInfo->fileDest)) {
                ret = 1;
            }
            break;
        case PWP_FILEDEST_SIZE: // silence compiler warning
            break;
        }
    }
    return ret;
}
 
static const char *invalid = "!invalid";
 
 
const char *
caeuEncodeToText(PWP_ENUM_ENCODING enc)
{
    switch (enc) {
    case PWP_ENCODING_ASCII: return "ascii";
    case PWP_ENCODING_BINARY: return "binary";
    case PWP_ENCODING_UNFORMATTED: return "unformatted";
    case PWP_ENCODING_SIZE: // silence compiler warning
        break;
    }
    return invalid;
}
 
 
const char *
caeuPrecisionToText(PWP_ENUM_PRECISION prec)
{
    switch (prec) {
    case PWP_PRECISION_SINGLE: return "single";
    case PWP_PRECISION_DOUBLE: return "double";
    case PWP_PRECISION_SIZE: // silence compiler warning
        break;
    }
    return invalid;
}
 
 
const char *
caeuDimensionToText(PWP_ENUM_DIMENSION dim)
{
    switch (dim) {
    case PWP_DIMENSION_2D: return "2D";
    case PWP_DIMENSION_3D: return "3D";
    case PWP_DIMENSION_SIZE: // silence compiler warning
        break;
    }
    return invalid;
}