cuns/runtimeWrite.cxx

Go to the documentation of this file.

/****************************************************************************
 *
 * CaeXxxxx implementation of runtimeWrite(), runtimeCreate(), and
 * runtimeDestroy()
 *
 * (C) 2021 Cadence Design Systems, Inc. All rights reserved worldwide.
 *
 ***************************************************************************/
 
#include "apiCAEP.h"
#include "apiCAEPUtils.h"
#include "apiGridModel.h"
#include "apiPWP.h"
#include "runtimeWrite.h"
#include "pwpPlatform.h"
 
 
#if 0
static void
stepN(CAEP_RTITEM *pRti)
{
    PWP_UINT32 cnt = 1; /* the # of MINOR progress sub-steps */
    if (caeuProgressBeginStep(pRti, cnt)) {
        while (cnt--) {
            /*
            // PUT YOUR SUB-STEP OUTPUT LOGIC HERE
            */
            /* incr to next sub-step */
            caeuProgressIncr(pRti);
        }
        caeuProgressEndStep(pRti);
    }
}
#endif
 
 
//-------------------------------------------------------------------------
// The Mapper class is only needed if
// caeuPublishMeshLinkValueDefinitions("Custom") is called.
// See runtimeCreate() and PwModCustomIndexSchemeReady()
//-------------------------------------------------------------------------
 
// This is a trivial, single offset example. Your data will most likely involve
// some sort of mapping container like std::map or std::unordered_map.
//struct Mapper {
//    int offset; // fixed index offset
//
//    static PWP_UINT64 cb(const PWP_UINT64 pwgmNdx, void *cbData)
//    {
//        // Given: pwgmNdx is the index to the vertex returned by
//        // PwModEnumVertices(m, pwgmNdx). The caller wants pwgmNdx mapped to the
//        // index of the vertex as written to the exported mesh file. Currently,
//        // only indices that are part of DB constrained boundary patches get
//        // mapped (subject to change). The mesh link export process invokes this
//        // callback as needed.
//
//        // cbData is the void* passed to PwModCustomIndexSchemeReady(cbData).
//        Mapper *mapper = static_cast<Mapper*>(cbData);
//
//        // Do something here to map the pwgmNdx (0..N-1) to the index used in
//        // the exported mesh. In this trivial example, apply a fixed offset.
//        PWP_UINT64 newNdx = pwgmNdx + mapper->offset;
//
//        return newNdx;
//    }
//};
 
 
PWP_BOOL
runtimeWrite(CAEP_RTITEM *pRti, PWGM_HGRIDMODEL, const CAEP_WRITEINFO *)
{
    // The PWGM_HGRIDMODEL and CAEP_WRITEINFO function arguments are deprecated.
    // The use of pRti->model and pRti->pWriteInfo is now preferred.
    // The grid model data is accessed via pRti->model.
    // The user or Glyph specified export options are available directly via
    // pRti->pWriteInfo or using one of the CAEPU_RT_XXXX(pRti) macros.
 
    PWP_BOOL ret = PWP_FALSE;
    PWP_UINT32 cnt = 1; // the # of MAJOR progress steps
    if (caeuProgressInit(pRti, cnt)) {
        // PUT YOUR MAJOR-STEP OUTPUT LOGIC HERE
        //step1(pRti);
        //step2(pRti);
        //...
        //stepN(pRti);
        caeuProgressEnd(pRti, ret);
        ret = !pRti->opAborted;
    }
 
    //-------------------------------------------------------------------------
    // Only needed if caeuPublishMeshLinkValueDefinitions("Custom") is called.
    // See runtimeCreate()
    //-------------------------------------------------------------------------
    // Capture data needed by Mapper::cb here. If no data needed, you can pass
    // nullptr below instead of &mapper.
    //Mapper mapper{ 10000 };
    //ret = ret && PwModCustomIndexSchemeReady(pRti->model, Mapper::cb, &mapper);
 
    return ret;
}
 
 
PWP_BOOL
runtimeCreate(CAEP_RTITEM * /*pRti*/)
{
    PWP_BOOL ret = PWP_TRUE;
 
    //-----------------------------------------------------------------------
    // BYTE ORDERING:
    //   Uncomment the appropriate lines below to control the byte ordering
    //   options supported by the solver. If "AllowedFileByteOrders" is not
    //   set, the plugin will use the platform's native byte ordering.
    //   Currently, Pointwise only runs on little endian, intel platforms. If
    //   the solver targeted by this plugin cannot import little endian files,
    //   you must force big endian export.
    //-----------------------------------------------------------------------
    //const char * orders = "BigEndian"; // force big endian export
    //const char * orders = "LittleEndian"; // force little endian export
    //const char * orders = "BigEndian|LittleEndian";  // support both
    //ret = ret && caeuAssignInfoValue("AllowedFileByteOrders", orders, true);
 
    //-----------------------------------------------------------------------
    // ELEMENT TOPOLOGY:
    //   Uncomment the lines below and edit the topos[] value to explicitly
    //   control the element topology options supported by the solver. If 
    //   "AllowedElementTopologies" is not set, the allowed element topologies
    //   will be inferred from the supported element types.
    //-----------------------------------------------------------------------
    //const char topos[] = "Structured|Unstructured|Prismatic";
    //ret = ret && caeuAssignInfoValue("AllowedElementTopologies", topos, true);
 
    //-----------------------------------------------------------------------
    // MESHLINK SUPPORT:
    //   Uncomment the appropriate line below if this plugin supports mesh link
    //   exporting for the given indexing scheme.
    //
    //   ZeroBased -
    //     Vertices are written to the mesh file in the same order as returned
    //     by PwModEnumVertices(). In the mesh file the vertices are indexed as
    //     0..NumVerts-1.
    //
    //   OneBased -
    //     Vertices are written to the mesh file in the same order as returned
    //     by PwModEnumVertices(). In the mesh file the vertices are indexed as
    //     1..NumVerts.
    //
    //   Custom - 
    //     Vertices are NOT written to the mesh file in the same order as
    //     returned by PwModEnumVertices(). In this case, the plugin must build
    //     an appropriate index map during export. After the mesh export is
    //     completed but before returning from runtimeWrite(), the plugin must
    //     call PwModCustomIndexSchemeReady(mapperCallback) to notify the
    //     Pointwise export framework that the vertex map is ready. Before
    //     returning from PwModCustomIndexSchemeReady(), the Pointwise export
    //     framework will invoke the mapperCallback as needed to map a PWGM
    //     index to its corresponding exported index.
    //     See PwModCustomIndexSchemeReady() for details.
    //
    // IMPORTANT:
    //   Pointwise only supports MeshLink generation for unstructured grids.
    //   This setting will be ignored for structured exports.
    //-----------------------------------------------------------------------
    //ret = ret && caeuPublishMeshLinkValueDefinitions("ZeroBased");
    //ret = ret && caeuPublishMeshLinkValueDefinitions("OneBased");
    //ret = ret && caeuPublishMeshLinkValueDefinitions("Custom");
 
 
    //-----------------------------------------------------------------------
    // NON-INFLATED BC TYPE NAMES:
    //   Uncomment the lines below and edit the shadowTypes[] value to
    //   specify which of the defined BCs types are non-inflated. Normally, if a
    //   BC is applied to a floating baffle domain, or block-to-block connection
    //   domain, the interior points are "inflated" to create a zero thickness
    //   wall. However, if a non-inflated BC is used, the points are NOT
    //   inflated. These BC types are often used for flow-through or porous
    //   conditions.
    //-----------------------------------------------------------------------
    //const char * const shadowTypes = "bcname1|bcname2";
    //ret = ret && caeuassigninfovalue("ShadowBcTypes", shadowTypes, true);
 
    // These attributes are for example only. You can publish any attribute
    // needed for your solver.
    //ret = ret &&
    //      caeuPublishValueDefinition("iterations", PWP_VALTYPE_UINT, "5",
    //          "RW", "Number of iterations", "0 2000") &&
    //      caeuPublishValueDefinition("magnitude", PWP_VALTYPE_INT, "-5",
    //          "RW", "Signed int magnitude", "-100 100") &&
    //      caeuPublishValueDefinition("mach", PWP_VALTYPE_REAL, "0.3", "RW",
    //          "Incoming flow velocity", "-Inf +Inf 0.0 50.0") &&
    //      caeuPublishValueDefinition("temperature", PWP_VALTYPE_REAL, "77.5",
    //          "RW", "Ambient temperature", "-Inf +Inf -100.0 3000.0") &&
    //      caeuPublishValueDefinition("temperature.units", PWP_VALTYPE_ENUM,
    //          "Fahrenheit", "RW", "Grid temperature units", TempUnitEnum) &&
    //      caeuPublishValueDefinition("units", PWP_VALTYPE_ENUM, "Inches",
    //          "RW", "Grid dimensional units", DimUnitEnum) &&
    //      caeuPublishValueDefinition("description", PWP_VALTYPE_STRING, "",
    //          "RW", "Grid description", "") &&
    //      caeuPublishValueDefinition("linear", PWP_VALTYPE_BOOL, "reject",
    //          "RW", "Grid is linear", "reject|accept");
 
    return ret;
}
 
 
PWP_VOID
runtimeDestroy(CAEP_RTITEM * /*pRti*/)
{
}