The PlanarRT_X program — API documentation

TMC Suite package. A compute kernel for the electrodynamic computation of planar structures in the X-mode in the time domain. Output file: tmc_rtx.exe. All signatures are taken from the sources in src/kernels/PlanarRT_X/ and the shared headers from src/Include/.

A note on the shared code. PlanarRT_X is a copy of the PlanarRT_H codebase with a modified computation core. The description of the common classes is in planar_rt_h.md; here — only the differences of the X variant.

1. Purpose of the program

PlanarRT_X (tmc_rtx.exe) is a compute kernel of the TMC Suite package that performs the electrodynamic computation of planar structures in the X-mode. The algorithm uses 4 sub-steps for each 1T time cycle (instead of 2 in H-polarization) and stores 8 voltage components and 6 conductance values at each node.

Key differences from H-polarization:

• 4 sub-steps per 1T cycle (instead of 2);
• 8 voltage components per node (instead of 4), the field rUo removed;
• the voltage/conductance arrays are 3 times larger (6*nNumNode instead of 2*nNumNode);
• 6 conductance values per node (instead of 2);
• the electron charge and mass are used in the computation (ELECTRON_Q___, ELECTRON_M___);
• additional block types RECT_STAT_Y, CIRCLE_STAT_Y, POLYGON_STAT_Y, FILE_Y are recognized;
• the DistributionIntegrated calls (accumulation for the radiation pattern) are commented out;
• the settings registry key: SetRegistryKey("PlanarRT_X").

Everything else (the MFC framework, the dialogs, the global functions, the file formats) is identical to PlanarRT_H (see planar_rt_h.md).

2. Project composition and source differences

The project file is named PlanRT_H.vcxproj (like the H kernel!), but lies in the folder src/kernels/PlanarRT_X/; the project name inside is <ProjectName>PlanRT_X</ProjectName>, the target is <TargetName>tmc_rtx</TargetName>.

The list of files coincides with the H project (planar_rt_h.md, §2), including the cross-project TmcSMatrix.cpp/TmcTtoS.cpp and the same list of libraries. However, the files are not byte-for-byte identical. A comparison of the copies (by MD5):

The differences are implemented directly in the code of the copies, not through #ifdef: a search for #ifdef ELECTRON_Q___ / #ifdef CTMCRTH_INDANBLCK_* across all the sources finds no occurrences.

2.1. The six preprocessor macros of the X project

In the PreprocessorDefinitions of the X project (all 4 configurations) 6 names are additionally set:

ELECTRON_Q___
ELECTRON_M___
CTMCRTH_INDANBLCK_FILEY
CTMCRTH_INDANBLCK_RECTSTATY
CTMCRTH_INDANBLCK_CIRCSTATY
CTMCRTH_INDANBLCK_POLYGSTTY

The project rule (see CLAUDE.md): these macros are set only in the X-mode project properties (C/C++ → Preprocessor → Preprocessor Definitions) and are not added to the shared headers.

What these names mean in the current code:

That is, in the current revision of the code these 6 names are not conditional-compilation switches but constants (the electron physical constants and the string keywords of the _Y-suffixed block types), already defined in the shared headers. The requirement to set them in the project settings is a historical requirement of the X-mode build (likely for an older revision of the headers).

3. Key types (X-mode)

3.1. sTmcRTHNodeDielOne — a node (X-mode, 4 tacts)

The exact definition from src/kernels/PlanarRT_X/TmcRTHNodeDiel.h:

struct STMCRTH_NODEDIELONE
{
    _ELEM_VAL_RTH rU;       // the incident voltage (tact 0)
    _ELEM_VAL_RTH rU1;      // the incident voltage (tact 1)
    _ELEM_VAL_RTH rU2;      // the incident voltage (tact 2)
    _ELEM_VAL_RTH rU3;      // the incident voltage (tact 3)
    _ELEM_VAL_RTH rU_Cur;   // the current voltage
    _ELEM_VAL_RTH rU_Cur1;  // the "current+1" tact voltage
    _ELEM_VAL_RTH rU_Cur2;  // the "current+2" tact voltage
    _ELEM_VAL_RTH rU_Cur3;  // the "current+3" tact voltage
    _real rY;               // the node conductance
    int   nNodeGlobal;      // the node number in the global topology
    int   nType;            // the node type (as in H, see planar_rt_h.md §3.3)
};

Differences from the H variant: rU1, rU2, rU3, rU_Cur2, rU_Cur3 are added; the field rUo is removed. In total 8 voltage components (4 incident + 4 current) versus 4 in H (rU, rU_Cur, rU_Cur1, rUo).

3.2. The kernel arrays and the 6 node conductances

The global arrays prUNode1/prYNode are allocated with the size 6*nNumNode + 32 (in H — 2*nNumNode + 32); the reserve of 32 elements is used to align the working pointer to 32 bytes.

The meaning of the six prYNode values per node — by the comments in TmcRTHRectNode.h (X):

// prYNode[0] - value 2/(y1+y2+y3+y4+y5+y+y6*y7/(y6+y7));
// prYNode[1] - value y5;
// prYNode[2] - value y;
// prYNode[3] - value 2*(y6*y7)/(y6+y7);
// prYNode[4] - value 2*(y7-y6)/(y6+y7);
// prYNode[5] - value prYNode[3]*prYNode[4]/4;

The storage of the voltages by tact — by the comments in the same place:

// prUNode1[0] - voltage in takt t   and t-4;
// prUNode1[1] - voltage in takt t-1 and t-5;
// prUNode1[2] - voltage in takt t-2 and t-6;
// prUNode1[3] - voltage in takt t-3 and t-7;

4. The CTmcRTHRectNode class — differences

The general description (the fields, the public methods) — planar_rt_h.md, §5. The differences of the X variant:

4.1. Additional private methods (only in X)

4.2. The algorithm of one 1T cycle (X-mode, 4 sub-steps)

The exact sequence from RunKernel1T() (TmcRTHRectNode.cpp:537, the X copy):

Sub-step 0: RunExciteInputs();  RunScatteringNode();  RunBlockNode();  PutField(0);
            // DistributionIntegrated(0);  — commented out
            nTCurrent++;  dTCurrent += dT;
Sub-step 1: RunExciteInputs1(); RunScatteringNode1(); RunBlockNode1(); PutField(1);
            nTCurrent++;  dTCurrent += dT;
Sub-step 2: RunExciteInputs2(); RunScatteringNode2(); RunBlockNode2(); PutField(2);
            nTCurrent++;  dTCurrent += dT;
Sub-step 3: RunExciteInputs3(); RunScatteringNode3(); RunBlockNode3(); PutField(3);
            nTCurrent++;  dTCurrent += dT;

The counter nTCurrent grows by 1 in each sub-step (i.e. +4 per cycle). The main loop RunKernel (for(; nTCurrent < nTMax; ...)) calls PutSmatrix() on completion — as in H.

All four DistributionIntegrated(0..3) calls are commented out (lines 548, 558, 568, 578) — the accumulation of the field for the radiation pattern is not performed in the X-mode.

5. The CTmcRTHNodeDiel class — differences

The general description — planar_rt_h.md, §6.

5.1. Additional public methods (only in X)

5.2. The *_STAT_Y and FILE_Y blocks

The X variant of TmcRTHNodeDiel.cpp additionally recognizes in the TOPOLOGY section the keywords RECT_STAT_Y, CIRCLE_STAT_Y, POLYGON_STAT_Y, FILE_Y (the string constants CTMCRTH_INDANBLCK_*Y from Tmcgrviw.h). The H variant does not handle these blocks.

6. Summary table of H vs X differences