pyAMaFiL 0.0.1__tar.gz

pyamafil-0.0.1/AMaFiL/sources/DebugWrite.cpp

@@ -0,0 +1,142 @@
+#include "stdDefinitions.h"
+#include "mfoGlobals.h"
+#include "agmScalarField.h"
+#include "agmVectorField.h"
+#include "binUtilities.h"
+
+#ifdef _WINDOWS
+#pragma warning(disable:4996)
+#endif
+
+#include "DebugWrite.h"
+#include "debug_data_trace_win.h"
+
+void DebugWriteData(CubeXD *v, const char *fname, int depth, int iter)
+{
+#ifdef _WINDOWS
+    if (debug_input)
+    {
+        char buffer[256], tbuff[32];
+        strcpy(buffer, DEBUG_OUT_PATH);
+        strcat(buffer, fname);
+        if (depth > 0)
+        {
+            sprintf(tbuff, "_%d", depth);
+            strcat(buffer, tbuff);
+            if (iter > 0)
+            {
+                sprintf(tbuff, "_%d", iter);
+                strcat(buffer, tbuff);
+            }
+        }
+        strcat(buffer, ".bin");
+
+        debug_data_trace_win *d = new debug_data_trace_win(buffer);
+        d->write(v);
+        delete d;
+    }
+#endif
+}
+
+void DebugWritePars(const char *fname, CagmVectorField * field, CagmScalarField * w)
+{
+#ifdef _WINDOWS
+    if (debug_input)
+    {
+        char buffer[256];
+        strcpy(buffer, DEBUG_OUT_PATH);
+        strcat(buffer, fname);
+        strcat(buffer, ".bin");
+
+        FILE *fid = fopen(buffer, "wb");
+
+        CbinDataStruct::WriteHeader(fid);
+
+        CbinDataStruct::Write(fid, &CommonThreadsN, 1, "CommonThreadsN");
+        CbinDataStruct::Write(fid, &WiegelmannThreadPriority, 1, "WiegelmannThreadPriority");
+
+        CbinDataStruct::Write(fid, &WiegelmannBoundsCorrection, 1, "WiegelmannBoundsCorrection");
+
+        CbinDataStruct::Write(fid, &WiegelmannWeightType, 1, "WiegelmannWeightType");
+        CbinDataStruct::Write(fid, &WiegelmannWeightBound, 1, "WiegelmannWeightBound");
+        CbinDataStruct::Write(fid, &WiegelmannWeightDivfree, 1, "WiegelmannWeightDivfree");
+
+        CbinDataStruct::Write(fid, &WiegelmannDerivStencil, 1, "WiegelmannDerivStencil");
+        CbinDataStruct::Write(fid, &WiegelmannInversionTolerance, 1, "WiegelmannInversionTolerance");
+        CbinDataStruct::Write(fid, &WiegelmannInversionDenom, 1, "WiegelmannInversionDenom");
+        
+        CbinDataStruct::Write(fid, &WiegelmannProcStep0, 1, "WiegelmannProcStep0");
+
+        CbinDataStruct::Write(fid, &WiegelmannProcStepMax, 1, "WiegelmannProcStepMax");
+        CbinDataStruct::Write(fid, &WiegelmannProcMaxSteps, 1, "WiegelmannProcMaxSteps");
+
+        CbinDataStruct::Write(fid, &WiegelmannProcStepIncrInit, 1, "WiegelmannProcStepIncrInit");
+        CbinDataStruct::Write(fid, &WiegelmannProcStepIncrMatr, 1, "WiegelmannProcStepIncrMatr");
+        CbinDataStruct::Write(fid, &WiegelmannProcStepIncrMain, 1, "WiegelmannProcStepIncrMain");
+
+        CbinDataStruct::Write(fid, &WiegelmannProcStepDecrInit, 1, "WiegelmannProcStepDecrInit");
+        CbinDataStruct::Write(fid, &WiegelmannProcStepDecrMatr, 1, "WiegelmannProcStepDecrMatr");
+        CbinDataStruct::Write(fid, &WiegelmannProcStepDecrMain, 1, "WiegelmannProcStepDecrMain");
+
+        CbinDataStruct::Write(fid, &WiegelmannProcStepLimInit, 1, "WiegelmannProcStepLimInit");
+        CbinDataStruct::Write(fid, &WiegelmannProcStepLimMatr, 1, "WiegelmannProcStepLimMatr");
+        CbinDataStruct::Write(fid, &WiegelmannProcStepLimMain, 1, "WiegelmannProcStepLimMain");
+
+        CbinDataStruct::Write(fid, &WiegelmannProcdLStdWinInit, 1, "WiegelmannProcdLStdWinInit");
+        CbinDataStruct::Write(fid, &WiegelmannProcdLStdWinMatr, 1, "WiegelmannProcdLStdWinMatr");
+        CbinDataStruct::Write(fid, &WiegelmannProcdLStdWinMain, 1, "WiegelmannProcdLStdWinMain");
+
+        CbinDataStruct::Write(fid, &WiegelmannProcdLStdValInit, 1, "WiegelmannProcdLStdValInit");
+        CbinDataStruct::Write(fid, &WiegelmannProcdLStdValMatr, 1, "WiegelmannProcdLStdValMatr");
+        CbinDataStruct::Write(fid, &WiegelmannProcdLStdValMain, 1, "WiegelmannProcdLStdValMain");
+
+        CbinDataStruct::Write(fid, &WiegelmannMatryoshkaUse, 1, "WiegelmannMatryoshkaUse");
+        CbinDataStruct::Write(fid, &WiegelmannMatryoshkaDeepMinN, 1, "WiegelmannMatryoshkaDeepMinN");
+        CbinDataStruct::Write(fid, &WiegelmannMatryoshkaFactor, 1, "WiegelmannMatryoshkaFactor");
+
+        CbinDataStruct::Write(fid, &WiegelmannProcCondType, 1, "WiegelmannProcCondType");
+        CbinDataStruct::Write(fid, &WiegelmannProcCondAbs, 1, "WiegelmannProcCondAbs");
+        CbinDataStruct::Write(fid, &WiegelmannProcCondAbs2, 1, "WiegelmannProcCondAbs2");
+        CbinDataStruct::Write(fid, &WiegelmannProcCondLOS2, 1, "WiegelmannProcCondLOS2");
+        CbinDataStruct::Write(fid, &WiegelmannProcCondLOS, 1, "WiegelmannProcCondLOS");
+        CbinDataStruct::Write(fid, &WiegelmannProcCondBase, 1, "WiegelmannProcCondBase");
+        CbinDataStruct::Write(fid, &WiegelmannProcCondBase2, 1, "WiegelmannProcCondBase2");
+
+        int N[3];
+        field->dimensions(N);
+        CbinDataStruct::Write(fid, N, 3, "N");
+        CagmScalarField comp(N);
+
+        field->getComponent(&comp, PLANE_X);
+        double v = comp.sum();
+        CbinDataStruct::Write(fid, &v, 1, "FieldXSum");
+        double *a = field->getAddress(PLANE_X, 5, 7, 0);
+        CbinDataStruct::Write(fid, a, 1, "X570");
+        a = field->getAddress(PLANE_X, 7, 5, 0);
+        CbinDataStruct::Write(fid, a, 1, "X750");
+
+        field->getComponent(&comp, PLANE_Y);
+        v = comp.sum();
+        CbinDataStruct::Write(fid, &v, 1, "FieldYSum");
+        a = field->getAddress(PLANE_Y, 5, 7, 0);
+        CbinDataStruct::Write(fid, a, 1, "Y570");
+        a = field->getAddress(PLANE_Y, 7, 5, 0);
+        CbinDataStruct::Write(fid, a, 1, "Y750");
+
+        field->getComponent(&comp, PLANE_Z);
+        v = comp.sum();
+        CbinDataStruct::Write(fid, &v, 1, "FieldZSum");
+        a = field->getAddress(PLANE_Z, 5, 7, 0);
+        CbinDataStruct::Write(fid, a, 1, "Z570");
+        a = field->getAddress(PLANE_Z, 7, 5, 0);
+        CbinDataStruct::Write(fid, a, 1, "Z750");
+
+        v = w->sum();
+        CbinDataStruct::Write(fid, &v, 1, "WeightSum");
+
+        CbinDataStruct::WriteFooter(fid);
+
+        fclose(fid);
+    }
+#endif
+}

pyamafil-0.0.1/AMaFiL/sources/LinesProcessor.cpp

@@ -0,0 +1,114 @@
+#include "stdDefinitions.h"
+#include "LinesTaskQueue.h"
+#include "LinesProcessor.h"
+#include "agmVectorField.h"
+#include "agmVectorFieldLineFuncs.h"
+
+#define l_div_position(p, N, k1, tk) \
+{ \
+    if (p >= double((N)-1) || fabs(p-(double((N)-1))) < 1e-5) \
+    { \
+        k1 = (N)-2; \
+        tk = 1; \
+    } \
+    else \
+    { \
+        k1 = (int)floor(p); \
+        if (k1 < 0) \
+        { \
+            k1 = 0;  \
+            tk = 0; \
+        } \
+        else \
+            tk = (p) - k1; \
+    } \
+}
+
+#define l_get_point(Ny, tfield, x1, y1, z1, tx, ty, tz) \
+    ((1-(tz))* ((1-(ty))* ((1-(tx))*tfield[(y1)     +  (z1)   *Ny][x1] + (tx)*tfield[(y1)     +  (z1)   *Ny][x1+1]) + \
+                    (ty)* ((1-(tx))*tfield[((y1)+1) +  (z1)   *Ny][x1] + (tx)*tfield[((y1)+1) +  (z1)   *Ny][x1+1]))  \
+   +     (tz)* ((1-(ty))* ((1-(tx))*tfield[(y1)     + ((z1)+1)*Ny][x1] + (tx)*tfield[(y1)     + ((z1)+1)*Ny][x1+1]) + \
+                    (ty)* ((1-(tx))*tfield[((y1)+1) + ((z1)+1)*Ny][x1] + (tx)*tfield[((y1)+1) + ((z1)+1)*Ny][x1+1]))  \
+    )
+
+bool fcond(void *p, const CagmRKF45Vect& v)
+{
+    T_Lines *pp = (T_Lines *)p;
+    return v.e[0] < pp->absBoundAchieve       || v.e[0]  > (pp->N)[0] - pp->absBoundAchieve - 1 
+        || v.e[1] < pp->absBoundAchieve       || v.e[1]  > (pp->N)[1] - pp->absBoundAchieve - 1
+        || v.e[2] < pp->absBoundAchieveBottom || v.e[2]  > (pp->N)[2] - pp->absBoundAchieve - 1
+        ;
+}
+
+uint32_t fdata(void *p, const double /*t*/, const CagmRKF45Vect& v, CagmRKF45Vect& vp)
+{
+    vp.e[0] = 0; vp.e[1] = 0; vp.e[2] = 0;
+
+    T_Lines *pp = (T_Lines *)p;
+    if ((v.e[0] >= 0 && v.e[0]  <= (pp->N)[0] - 1
+      && v.e[1] >= 0 && v.e[1]  <= (pp->N)[1] - 1
+      && v.e[2] >= 0 && v.e[2]  <= (pp->N)[2] - 1))
+    {
+        double field[3];
+        ((T_Lines *)p)->vfield->getPoint(((CagmRKF45Vect&)v).v(), field);
+        vp.e[0] = field[0] * ((T_Lines *)p)->dir;
+        vp.e[1] = field[1] * ((T_Lines *)p)->dir;
+        vp.e[2] = field[2] * ((T_Lines *)p)->dir;
+        double n = 1.0/sqrt(vp.e[0]*vp.e[0] + vp.e[1]*vp.e[1] + vp.e[2]*vp.e[2]);
+        vp.e[0] *= n;
+        vp.e[1] *= n;
+        vp.e[2] *= n;
+        return 0;
+    }
+
+    //return (rc ? 1 : 0);
+    return 1;
+}
+
+//-----------------------------------------------------------------------------
+CLinesProcessor::CLinesProcessor(LQPSupervisor *_supervisor, CagmVectorField *_v, int _dir, double _step, double _relErr, double _absErr
+        , double _boundAchieve, double _boundAchieveBottom, int _maxLength, int *_passed)
+    : supervisor(_supervisor)
+      ,v(_v)
+      ,dir(_dir)
+      ,step(_step)
+      ,boundAchieve(_boundAchieve) 
+      ,boundAchieveBottom(_boundAchieveBottom)
+      ,maxLength(_maxLength)
+      ,passed(_passed)
+{
+    rkf45 = new CagmRKF45(_absErr, _relErr, fdata, 3, nullptr, fcond, boundAchieve);
+    coord = new double[3*maxLength];
+}
+
+//-----------------------------------------------------------------------------
+CLinesProcessor::~CLinesProcessor()
+{
+    delete rkf45;
+    delete[] coord;
+}
+
+//-------------------------------------------------------------------------------------
+uint32_t CLinesProcessor::setTaskParams(void *params)
+{
+    memcpy(point, (double *)params, 3*sizeof(double)); 
+
+    return 0;
+}
+
+//-----------------------------------------------------------------------------
+uint32_t CLinesProcessor::ActionCore()
+{
+    int lineLength;
+    int code;
+
+    if ( !supervisor->needProcessing(queueID) )
+            return 0;
+
+    /* CagmVectorFieldOps::Status s = */
+    v->getOneFullLine(rkf45, point, dir, step, boundAchieve, boundAchieveBottom, maxLength, &lineLength, coord, &code);
+    /* uint32_t rc = */
+    supervisor->SetResult(queueID, point, coord, lineLength, (int)code, CagmVectorFieldOps::Status::BufferOverload);
+
+    return 0;
+}

pyamafil-0.0.1/AMaFiL/sources/MagFieldOps.cpp

@@ -0,0 +1,240 @@
+// MagFieldOps.cpp : Defines the initialization routines for the DLL.
+//
+
+#include "stdDefinitions.h"
+
+#ifdef _WINDOWS
+#include <windows.h>
+#pragma warning (disable : 4996)
+#endif
+
+#include <ctime>
+#include "string.h"
+
+#include "MagFieldOps.h"
+
+#include "mfoGlobals.h"
+#include "VersionInfoResource.h"
+
+#include "agmScalarField.h"
+#include "agmVectorField.h"
+
+//------------------------------------------------------------------
+int getPriority(w_priority p)
+{
+    int sys_p = 0;
+#ifdef _WINDOWS
+    switch (p)
+    {
+        case lowest:
+            sys_p = THREAD_PRIORITY_LOWEST;
+            break;
+        case low:
+            sys_p = THREAD_PRIORITY_BELOW_NORMAL;
+            break;
+        case normal:
+            sys_p = THREAD_PRIORITY_NORMAL;
+            break;
+        case high:
+            sys_p = THREAD_PRIORITY_ABOVE_NORMAL;
+            break;
+        case highest:
+            sys_p = THREAD_PRIORITY_HIGHEST;
+            break;
+        default:
+            sys_p = THREAD_PRIORITY_BELOW_NORMAL;
+    }
+#endif
+
+    return sys_p;
+}
+
+//------------------------------------------------------------------
+bool mapIntproceed(bool bGet, std::string name, int &value, int defaultValue = 0)
+{
+    auto search = mapInt.find(name);
+    bool rc = search != mapInt.end();
+    if (bGet) // return true, if exist
+    {
+        if (rc)
+            value = search->second;
+        else
+            value = defaultValue;
+    }
+    else
+    {
+        mapInt[name] = defaultValue;
+    }
+
+    return rc;
+}
+
+//------------------------------------------------------------------
+bool mapDoubleproceed(bool bGet, std::string name, double &value, double defaultValue = 0)
+{
+    auto search = mapDouble.find(name);
+    bool rc = search != mapDouble.end();
+    if (bGet) // return true, if exist
+    {
+        if (rc)
+            value = search->second;
+        else
+            value = defaultValue;
+    }
+    else
+    {
+        mapDouble[name] = defaultValue;
+    }
+
+    return rc;
+}
+
+//------------------------------------------------------------------
+void _proceedGlobals(bool bGet)
+{
+    // mapIntproceed   (bGet, "synchronous", WiegelmannSynchronous, 1);
+    // mapIntproceed   (bGet, "show_progress", WiegelmannShowProgress, 1);
+    // mapDoubleproceed(bGet, "show_progress_time_quant", WiegelmannShowProgressTimeQuant, 1);
+    // mapIntproceed   (bGet, "timeout_ms", WiegelmannProcTimeoutMS, 60000);
+    //mapDoubleproceed(bGet, "d_functional_value_terminate_init", WiegelmannProcdLStopInit, 1e-4); // dL value ...
+    //mapDoubleproceed(bGet, "d_functional_value_terminate", WiegelmannProcdLStopMatr, 1e-4); 
+    //mapDoubleproceed(bGet, "d_functional_value_terminate_main", WiegelmannProcdLStopMain, 1e-4);
+    //mapIntproceed   (bGet, "d_functional_iterations_terminate_init", WiegelmannProcdLIterInit, 100); // ... during consequently iterations
+    //mapIntproceed   (bGet, "d_functional_iterations_terminate", WiegelmannProcdLIterMatr, 100);
+    //mapIntproceed   (bGet, "d_functional_iterations_terminate_main", WiegelmannProcdLIterMain, 100);
+    // mapDoubleproceed(bGet, "d_functional_value_max_inceasing_init", WiegelmannProcFunctionalLimitInit, 1e-4); // max. rel. avail. L increasing
+    // mapDoubleproceed(bGet, "d_functional_value_max_inceasing", WiegelmannProcFunctionalLimitMatr, 1e-4);
+    // mapDoubleproceed(bGet, "d_functional_value_max_inceasing_main", WiegelmannProcFunctionalLimitMain, 1e-4);
+    // int iWiegelmannMatryoshkaInterpolator;
+    // mapIntproceed   (bGet, "dense_grid_interpolator", iWiegelmannMatryoshkaInterpolator, 0);
+    // mapDoubleproceed(bGet, "dense_grid_interpolator_p1", WiegelmannMatryoshkaInterpolatorP1, 2.0);
+    // mapDoubleproceed(bGet, "dense_grid_interpolator_p2", WiegelmannMatryoshkaInterpolatorP2, 8.0);
+    // mapDoubleproceed(bGet, "dense_grid_interpolator_p3", WiegelmannMatryoshkaInterpolatorP3, 0.0);
+    // mapIntproceed   (bGet, "chunk_size_max", WiegelmannChunkSizeMax, 100);
+    // mapIntproceed   (bGet, "chunk_size_opt", WiegelmannChunkSizeOpt, 30);
+    // mapIntproceed   (bGet, "threads_priority", WiegelmannThreadPriority, 0);
+    // mapIntproceed   (bGet, "metrics_diff_init", WiegelmannGetMetricsDiffInit, 0);
+    // mapIntproceed   (bGet, "metrics_diff_prev", WiegelmannGetMetricsDiffPrev, 0);
+    // if (bGet)
+    // {
+    //     WiegelmannMatryoshkaInterpolator = (CagmVectorFieldOps::Interpolator)iWiegelmannMatryoshkaInterpolator;
+    // }
+    
+    mapIntproceed   (bGet, "bounds_correction", WiegelmannBoundsCorrection, 0);
+    mapIntproceed   (bGet, "threads_priority", WiegelmannThreadPriority, low);
+
+    mapIntproceed   (bGet, "weight_type", WiegelmannWeightType, SWF_COS);
+    mapDoubleproceed(bGet, "weight_bound_size", WiegelmannWeightBound, 0.1);
+    mapDoubleproceed(bGet, "weight_relative_divfree", WiegelmannWeightDivfree, 1.0);
+
+    mapIntproceed   (bGet, "derivative_stencil", WiegelmannDerivStencil, 3);
+    mapDoubleproceed(bGet, "inversion_tolerance", WiegelmannInversionTolerance, 0);
+    mapDoubleproceed(bGet, "inversion_denominator", WiegelmannInversionDenom, 0);
+    
+    mapDoubleproceed(bGet, "step_initial", WiegelmannProcStep0, 0.1); // units of Bav/F2max
+    
+    mapIntproceed   (bGet, "step_max", WiegelmannProcStepMax, 1000000000); // max. aval. step
+    mapIntproceed   (bGet, "max_iterations", WiegelmannProcMaxSteps, 100000); // max. number of step
+
+    mapDoubleproceed(bGet, "step_increment_init", WiegelmannProcStepIncrInit, 1.618);
+    mapDoubleproceed(bGet, "step_increment", WiegelmannProcStepIncrMatr, 1.618);
+    mapDoubleproceed(bGet, "step_increment_main", WiegelmannProcStepIncrMain, 1.618);
+    mapDoubleproceed(bGet, "step_decrement_init", WiegelmannProcStepDecrInit, 0.382);
+    mapDoubleproceed(bGet, "step_decrement", WiegelmannProcStepDecrMatr, 0.382);
+    mapDoubleproceed(bGet, "step_decrement_main", WiegelmannProcStepDecrMain, 0.382);
+    mapDoubleproceed(bGet, "step_terminate_init", WiegelmannProcStepLimInit, 0.01); // related to init. step
+    mapDoubleproceed(bGet, "step_terminate", WiegelmannProcStepLimMatr, 0.01);
+    mapDoubleproceed(bGet, "step_terminate_main", WiegelmannProcStepLimMain, 0.0001);
+
+    mapDoubleproceed(bGet, "d_functional_stdev_value_init", WiegelmannProcdLStdValInit, 5e-4); // min std(rel. dL) ...
+    mapDoubleproceed(bGet, "d_functional_stdev_value", WiegelmannProcdLStdValMatr, 5e-4);
+    mapDoubleproceed(bGet, "d_functional_stdev_value_main", WiegelmannProcdLStdValMain, 5e-4);
+    mapIntproceed   (bGet, "d_functional_stdev_window_init", WiegelmannProcdLStdWinInit, 101); // ... std window size + 1
+    mapIntproceed   (bGet, "d_functional_stdev_window_matr", WiegelmannProcdLStdWinMatr, 101);
+    mapIntproceed   (bGet, "d_functional_stdev_window_main", WiegelmannProcdLStdWinMain, 101);
+
+    mapIntproceed   (bGet, "dense_grid_use", WiegelmannMatryoshkaUse, 1);
+    mapIntproceed   (bGet, "dense_grid_min_n", WiegelmannMatryoshkaDeepMinN, 25);
+    mapDoubleproceed(bGet, "dense_grid_factor", WiegelmannMatryoshkaFactor, 2.0);
+
+    mapIntproceed   (bGet, "add_conditions_mode", WiegelmannProcCondType,  1); // 0 - ignore, 1 - as functional, 2 - as fixed
+
+    mapIntproceed   (bGet, "add_conditions_abs", WiegelmannProcCondAbs,   2);  // 0 - no limit, 1 - no less, 2 - exact
+    mapIntproceed   (bGet, "add_conditions_abs_max", WiegelmannProcCondAbs2,  1); // 0 - no limit, 1 - no greater
+    mapIntproceed   (bGet, "add_conditions_los", WiegelmannProcCondLOS,   2);
+    mapIntproceed   (bGet, "add_conditions_los_max", WiegelmannProcCondLOS2,  1);
+    mapIntproceed   (bGet, "add_conditions_xyz", WiegelmannProcCondBase,  2);
+    mapIntproceed   (bGet, "add_conditions_xyz_max", WiegelmannProcCondBase2, 1);
+
+    mapIntproceed   (bGet, "protocol_step", WiegelmannProtocolStep, 10);
+
+    mapIntproceed   (bGet, "metrics_theta", WiegelmannGetMetricsTheta, 0);
+    mapIntproceed   (bGet, "debug_input", debug_input, 0);
+}
+
+//------------------------------------------------------------------
+__declspec( dllexport ) uint32_t utilInitialize()
+{
+    _proceedGlobals(false);
+    _proceedGlobals();
+    return 0;
+}
+
+//------------------------------------------------------------------
+__declspec( dllexport ) int utilSetInt(char *query, int value)
+{
+    if (!strcmp(query, "threads_priority"))
+        value = getPriority((w_priority)value);
+    bool isNew = mapIntproceed(false, query, value, value);
+    _proceedGlobals();
+    return (isNew ? 1 : 0);
+}
+
+//------------------------------------------------------------------
+__declspec( dllexport ) int utilGetInt(char *query, int *result)
+{ 
+    return mapIntproceed(true, query, *result, 0);
+}
+
+//------------------------------------------------------------------
+__declspec( dllexport ) int utilSetDouble(char *query, double value)
+{
+    bool isNew = mapDoubleproceed(false, query, value, value);
+    _proceedGlobals();
+    return (isNew ? 1 : 0);
+}
+
+//------------------------------------------------------------------
+__declspec( dllexport ) int utilGetDouble(char *query, double *result)
+{ 
+    return mapDoubleproceed(true, query, *result, 0);
+}
+
+//------------------------------------------------------------------
+__declspec(dllexport) int utilGetVersion(char *fullvers, int buflength)
+{
+    std::string s;
+    s = VIR_ProductName;
+    s += " v.";
+    s += VIR_QUOTE_SUBST(VIR_Ver1);
+    s += ".";
+    s += VIR_QUOTE_SUBST(VIR_Ver2);
+    s += ".";
+    s += VIR_QUOTE_SUBST(VIR_Ver3);
+    s += ".";
+    s += VIR_QUOTE_SUBST(VIR_Ver4);
+    s += " (";
+    s += VIR_QUOTE_SUBST(VIR_T_REV);
+    s += VIR_QUOTE_SUBST(VIR_Revision);
+    s += "). ";
+    s += VIR_QUOTE_SUBST(VIR_COPYRIGHT);
+    s += ", ";
+    s += VIR_QUOTE_SUBST(VIR_FROM);
+    s += VIR_QUOTE_SUBST(VIR_Year);
+    s += ", ";
+    s += VIR_CompanyName;
+    
+    strncpy(fullvers, s.c_str(), buflength);
+
+    return (int)s.length();
+}