[Artwork] / [QisMLib]

QisMFile

A spatial database created from GDSII/OASIS files

QisMFile C++ API (qismfile.h)

Data Structures (qismbase.h)

QisMExploder (qismexploder.h)

class QisMFileLoadCtrl

Settings that control how a file is loaded into the database

class QisMFileLoadCtrl { .. };

Version Control

Cast to a pointer of another version in the class hierarchy (base/derived)

• Get the latest version number. Version numbers start at 1 and are reflected in the class name using the suffix V<number>. E.g <baseclass>V<version>

• The topmost base class is version 1 (V1 implied)

• The cast returns NULL if a version number is not recognized/implemented

xxxxxxxxxx
virtual void* QisMFileLoadCtrl_cast(const int version) = 0;
virtual const void* QisMFileLoadCtrl_cast(const int version) const = 0;
virtual int QisMFileLoadCtrl_latest_version() const = 0;

Set_layer_map()

Get_layer_map()

Set and get an input layer map to filter/map layers of interest

• layerMap : A string with the following format [Backus-Naur form]

  xxxxxxxxxx
  < LayerString > : "Off" | < Map > { "," < Map > }
  < Map > : < LayerIn > "-" < LayerOut >
  < LayerIn > : "All" | < LayerEntry >
  < LayerOut > : "NULL" | < LayerEntry >
  < LayerEntry > : < Layer > { ":" < DataType > }
  < Layer > : A valid layer number
  < DataType > : A valid datatype number
  

• The impact of the setting on the layer set will persist as long as the file database is alive

• Inform the file loader to treat data on a particular layer:datatype as if they are on another layer:datatype while opening a GDSII/OASIS file.

• The keyword "NULL" informs the loader to ignore a particular layer:datatype as if not present. The keyword "All" refers to all layer:datatypes present in the GDSII/OASIS file.

• This can be used effectively to merge entities having different layer, datatypes to be on the same layer.

• This can also be used to filter out entities on certain layers and datatypes

• The string is processed from left to right. Settings containing "All", override all previous settings

• By default, all layers are loaded as defined in the file

• Example: "1-NULL,2:3-10:3,4-11,5-11"

  • This will result in the following:

  • None of the data on layer 1 will be loaded when the GDSII/OASIS file is opened.

  • Layer 2:3 will be opened as 10:3

  • Layer 4 will be opened as layer 11

  • Layer 5 will be opened as layer 11

  • So all data on layer 4 and 5 will now appear on layer 11 "All-NULL"

  • This will result in the following:

  • No layers will be loaded when the GDSII/OASIS file is opened "Off"

  • This call will turn off layer mapping. Same as empty or null string

xxxxxxxxxx
virtual void Set_layer_map(const char* layerMap) = 0;
virtual const char* Get_layer_map() const = 0;

Set_ignore_texts()

Get_ignore_texts()

Set and get a flag to load or ignore text elements

• If set to true, none of the text elements will be loaded into the database as if the file does not have any text elements to begin with. This could result in a noticably smaller footprint, faster load and faster operations

• The impact of this setting will persist as long as the file database is alive

• By default, all text elements are loaded

xxxxxxxxxx
virtual void Set_ignore_texts(const bool set_ = true) = 0;
virtual bool Get_ignore_texts() const = 0;

Set_file_data_on_disk()

Get_file_data_on_disk()

Load the file data into memory or access them from the file on disk

• If set to false, all of the file data is stored in memory and all access to that data is done via memory addresses. This results in somewhat slower load times, noticably faster operations and larger memory footprint

• If set to true, all of the file data is accessed from the file on disk. This results in somewhat faster load, noticably slower operations (esp. multi-threded operations) and smaller memory footprint. Suitable for file that are equal or larger than the available memory

• By default, the file is loaded to memory

xxxxxxxxxx
virtual void Set_file_data_on_disk(const bool set_ = true) = 0;
virtual bool Get_file_data_on_disk() const = 0;

Compute_exploded_counts()

Specify a list of layers for which exploded vertex counts will be pre-computed for use later

• listOfLayerNumbers : List of layer numbers (no datatypes) to compute the counts for

• nLayers : Number of layer numbers in the list

• Sometimes it becomes necessary to know the total exploded vertex counts for one or more layers in order to determine the distribution of work amongst parallel engines. Using this method allows QisMLib to compute necessary information upfront during file load to make these counts available for later use (QisMFile::Get_cell_layer_exploded_vertices)

• If this method is not used, no such counts will be computed for any layers

xxxxxxxxxx
virtual void Compute_exploded_counts(
  const int* listOfLayerNumbers, const int nLayers
  ) = 0;

Set_ignore_text_scale()

Get_ignore_text_scale()

Control to include/exclude TEXT extents in the calculation of cell extents for GDSII files

• For GDSII files, by default, the cell extents include the extents of the underlying text items. The extents of a TEXT item depends on it's scale and other presentation attributes. For OASIS files, TEXT extents are not used in the computation of cell extents since the TEXT record has no presentation information associated with it

• If set == true, the presentation information will be ignored during the computation of the cell extents for GDSII files. No impact on OASIS files

• This function impacts the creation of .dbload files but has not effect on loading the .dbload files already created

• If the text scale is ignored, cells containing only TEXT items will have zero width and height. In that case, QisMFileLoadCtrl_load_empty_refs determines if those cells are loaded or not

• This function does NOT impact the extents of the TEXT item (QisMText::textBox) obtained via QisMExploder::Get_vector_data

• This function impacts the extents of a cell reference (QisMSref::refBox) or (QisMAref::refBox) obtained via QisMExploder::Get_data_vector or QisMDraw::Get_display_vector_data

• If the text scales are ignored, all TEXT items will be drawn with the same height (1 file-unit)

xxxxxxxxxx
virtual void Set_ignore_text_scale(const bool set) = 0; 
virtual bool Get_ignore_text_scale() const = 0;

Set_load_empty_refs()

Get_load_empty_refs()

Control to load/ignore empty cells (width, height = 0)

• By default, empty cells are NOT loaded

• A cell is considered empty if it has zero width/height

• If a cell only contains TEXTs, it's extents depend on the Ignore_text_scale setting for GDSII and is always 0,0,0,0 for OASIS and therefore will be loaded or dropped based on this method

xxxxxxxxxx
virtual void Set_load_empty_refs(const bool set_) = 0;
virtual bool Get_load_empty_refs() const = 0;

Reset_to_defaults()

Reset to default settings : All layers loaded as-is, all text loaded, file is loaded to memory

xxxxxxxxxx
virtual void Reset_to_defaults() = 0; 

class QisMFileLoadCtrlV2

Extension (version = 2) for QisMFileLoadCtrl

xxxxxxxxxx
class QisMFileLoadCtrlV2: public QisMFileLoadCtrl { ... }

Set_preprocess_spec

Get_preprocess_cmd

Get_preprocess_spec

Get_preprocess_file

Setup a pre-processor that will generate a new GDSII file which will then be loaded to create the database

• cmd is the name of the pre-processor. This determines what kind of operations will be performed on the source file

• outPath is the path of the pre-processed GDSII that will serve as the source for the database to be created

• spec is a string of arguments separated by spaces. An argument with a space in it must be double quoted

• When no pre-processor is specified (cmd or outPath are empty), QisMLib loads the original file as has been the behavior all along

• List of supported pre-processor --

  • QisMLoadProc1

xxxxxxxxxx
virtual void Set_preprocess_spec(const char* cmd, const char* outpath, const char* spec) = 0;
virtual const char* Get_preprocess_cmd() const = 0;
virtual const char* Get_preprocess_spec() const = 0;
virtual const char* Get_preprocess_file() const = 0;

struct QisMLoadProc1

A pre-processor that generates a semi-flat GDSII based on operation on the source such as -- clipping, sizing, corrections and transformation

xxxxxxxxxx
struct QisMLoadProc1 { ... }

CMD_NAME

Represents the pre-processor name

xxxxxxxxxx
static const char* CMD_NAME() { return "pre-process-1"; }

K_CELL

Specify the view (top) cell from the source

• Default: Default top cell from the source

xxxxxxxxxx
static const char* K_CELL() { return "cell="; } //cell=%s //cell={cellname}

K_BUTTING_UM

Polygons with holes will be represented as a pair of butting polygons with a specified overlap in UM

• Default: Use cutlines for such polygons

xxxxxxxxxx
static const char* K_BUTTING_UM() { return "buttingUM="; } //buttingUM=%lf //buttingUM={overlap}

K_CONVEX

All output polygons are convex in X & Y

xxxxxxxxxx
static const char* K_CONVEX() { return "convex"; } 

K_SIZING_UM

Apply sizing (edge compensation) to the output polygons along X and Y in UM.

• Default: 0.0 or no-sizing

• Both the sizing values MUST be either positive, or negative or 0.0

xxxxxxxxxx
static const char* K_SIZING_UM() { return "sizingUM="; } //sizingUM=%lf,%lf //sizingUM={x},{y}

K_MAXVERT

Specify the max. number of vertices for any output polygon (3 <= max. vert. <= 8190)

• Default: 8190

xxxxxxxxxx
static const char* K_MAXVERT() { return "maxvert="; } //maxvert=%d //maxvert={n}

K_CORRX_UM

Apply bi-linear corrections on the source polygons based on points where a correction/distortion is measured

• Any number of correction points can be specified (>=1)

• Each point MUST have FOUR values in UM -- {x} and {y} represent the point in the source; {dx} and {dy} represent the measured distortion/correction

xxxxxxxxxx
static const char* K_CORRX_UM() { return "corrx="; } //corrx={%lf,%lf,%lf,%lf}[,...] //corrx={x},{y},{dx},{dy}[,...]

K_XFORM

Apply affine transformations (scale, rotation, mirror, translation and shear) to the source polygons

• The order in which the transformations are applied is exactly as specified

• {xform} represents one transformation. Multiple transformations are separated by +. Transformations can be repeated with same or different values

• E.g affine=angle:30+flip:X+angle:5 -- Rotate by 30 deg. then flip the X values (mirror about Y) the rotate again by 5 deg.

xxxxxxxxxx
static const char* K_XFORM() { return "affine="; } //affine=%s{+%s}* //affine={xform}{+{xform}}* 

K_XFORM_SCALE

Apply scaling along X (first value) and Y (second value)

xxxxxxxxxx
static const char* K_XFORM_SCALE() { return "scale:"; } //scale:%lf,%lf{+%s}* //scale:{sx},{sy}{+{xform}}*

K_XFORM_TXY_UM

Apply translation along X (first value) and Y (second value) in UM

xxxxxxxxxx
static const char* K_XFORM_TXY_UM() { return "txyUM:"; } //txy:%lf,%lf{+%s}* //txy:{dx},{dy}{+{xform}}*

K_XFORM_ANGLE

Apply rotation in degrees

xxxxxxxxxx
static const char* K_XFORM_ANGLE() { return "angle:"; } //angle:%lf{%s}* //angle:{deg}{+{xform}}*

K_XFORM_FLIP

Apply mirroring along X or Y or both

• flip:X : Flip (negate) the X values i.e Mirror along X i.e Mirror about Y

• flip:Y : Flip the Y values i.e Mirror along Y i.e Mirror about X

• flip:XY : Flip the X & Y values

xxxxxxxxxx
static const char* K_XFORM_FLIP() { return "flip:"; } //flip:{X | Y | XY}{+%s}* //flip:{X | Y | XY}{+{xform}}*

K_XFORM_SHEAR

• Apply shearing along X and Y

• The shear factor is the fraction of the total width (X) or height (H). shear:0,0 implies no shearing

xxxxxxxxxx
static const char* K_XFORM_SHEAR() { return "shear:"; } //shear:%lf,%lf{+%s}* //shear:{shx},{shy}{+{xform}}*

K_CIRCLE_UM

Detect repeating polygons that are circles based on a max. chord error in UM

• The output is semi-flat where repeating boundaries (patterns) are grouped in a cell and referenced in the home-view

• By default, boundaries are not tested for their 'circularity'

xxxxxxxxxx
static const char* K_CIRCLE_UM() { return "circleUM="; } //circleUM=%lf //circleUM={max_chord_error}

K_JITTER_UM

Specify a max. jitter (slop) in UM to treat two boundaries as identical

• The output is semi-flat where repeating boundaries (patterns) are grouped in a cell and referenced in the home-view

• By default, even a difference of 1 grid in X or Y value for any vertex will result in the two boundaries to be declared 'non-identical' patterns

xxxxxxxxxx
static const char* K_JITTER_UM() { return "jitterUM="; } //jitterUM=%lf //jitterUM:{max_jitter}

K_MIN_REP

Specify the min. number of repetitions for a repeating boundary to constitute a separate 'pattern' (cell)

• The output is semi-flat where repeating boundaries are grouped in a cell and referenced in the home-view

• Any pattern that does not meet this threshold will be folded into the top cell (flattened)

xxxxxxxxxx
static const char* K_MIN_REP() { return "minrep="; } //minrep=%d //minrep={min_repetitions}

K_NO_AREFS

Disable array (uniform repetition a.k.a lattice, along X and Y)

• The output is semi-flat where repeating boundaries are grouped in a cell and referenced in the home-view

• This will only apply to patterns that meet the min. repetition threshold

xxxxxxxxxx
static const char* K_NO_AREFS() { return "noarefs"; }

K_TILE_V

The data space is partitioned into tiles for multi-threading. Specify the heuristic for partitioning based on the est. number of vertices crossing any given tile

• This is like partitioning the data space based on data density

• Makes use of QisMExplCounterV5::Break_window_by_vertcross_adv

• Default: tileV=75000

xxxxxxxxxx
static const char* K_TILE_V() { return "tileV="; } //tileV=%d //tileV={n_vert_per_tile}

K_NT

The data space is partitioned into tiles for multi-threading. Specify the number of tiles to be processed in parallel

• Default: 1

xxxxxxxxxx
static const char* K_NT() { return "nt="; } //nt=%d //nt={n_tile_threads}

K_NP

The data space is partitioned into tiles for multi-threading. Specify the number of threads to be used per tile for certain operations

• Default: 1

xxxxxxxxxx
static const char* K_NP() { return "np="; } //np=%d //np={n_threads_per_tile}

K_TILE_ROI_UM

Specify the region of interest in UM. Output polygons will be clipped against this ROI

• This is the data space that will be partitioned

• Default: Extents of the source view cell

xxxxxxxxxx
static const char* K_TILE_ROI_UM() { return "roi="; } //roi=%lf,%lf,%lf,%lf //roi={minx},{miny},{maxx},{maxy}

K_TILE_DBG

Output the partitioning tiles as boxes on the specified layer for diagnostics

xxxxxxxxxx
static const char* K_TILE_DBG() { return "tileDBG="; } //tileDBG=%d:%d //tileDBG={lnum}:{dnum}

K_ACSV

K_ACSP

Provide OEM string and key file path for Trusted/OEM based licensing

xxxxxxxxxx
static const char* K_ACSV() { return "acsv="; } //acsv=%s //acsv={vendor_string}
static const char* K_ACSP() { return "acsp="; } //acsp=%s //acsv={key_file_path}

struct QisMLoadProcOAS

A pre-processor that translates an OASIS file to GDSII record-by-record with options for filtering

• Best suited for complex OASIS files that take long to load using the standard loading operation

xxxxxxxxxx
struct QisMLoadProcOAS { ... }

CMD_NAME

Represents the pre-processor name

xxxxxxxxxx
static const char* CMD_NAME() { return "pre-process-oas"; }

K_MAXV

Specify the max. number of vertices in any output polygon (boundary or path) maxv={4 <= n <= 8190} by breaking larger polygons into smaller ones

xxxxxxxxxx
static const char* K_MAXV() { return "maxv="; } //maxv=%d

K_DROPCELLS

Drop select cell (definition and references) based on regular expression dropcells={separator}{doslike_regex}[{separator}{doslike_regex}]*

• {separator} is a char that delimits individual expressions

• {doslike_regex} is a regular-expression in dos-like syntax (as opposed to unix-like)

• Any cell whose name matches ANY of the expressions will be dropped from the output (definition and all references)

xxxxxxxxxx
static const char* K_DROPCELLS() { return "dropcells="; } //dropcells=%c%s[%c%s]*

K_LAYERMAP

Filter or re-map layers in the output

​x
layermap={str}

where...

{str} := {map}[,{map}]*
{map} := {from}-{to}
{from} := "ALL" | {layer} | {layer}:{datatype}
{to} := "NULL" | {layer} | {layer}:{datatype}
{layer},{datatype} >= 0

• ALL implies all {layer}:{datatype} (*:*)

• NULL implies OFF/dropped

• ALL-NULL turns all layers OFF

• ALL-{layer} re-maps all layer numbers to {layer} thereby merging all layers with the same datatype into a single {layer}:datatype

• ALL-{layer}:{datatype} merges all layers to a single {layer}:{datatype}

• Unless ALL is used already, any {layer}[:{datatype}] not present in the mapping remains unaffected

• {layer} without {datatype} implies all datatypes ({layer}:* for{from}) or ignore datatype (for{to}`)

• Layer mapping is cumulative. A {map} that appears later in {str} has the potential to override a previous {map}

• NO whitespace characters allowed

xxxxxxxxxx
static const char* K_LAYERMAP() { return "layermap="; } //layermap=%s

F_NOTEXT

Do not output OASIS TEXT records

xxxxxxxxxx
static const char* F_NOTEXT() { return "notext"; }

struct QisMLoadProcHEXT

A pre-processor that creates a database from a hierarchical extraction of a GDSII/OASIS/DBLOAD file

xxxxxxxxxx
struct QisMLoadProcHEXT { ... }

CMD_NAME

Represents the pre-processor name

xxxxxxxxxx
static const char* CMD_NAME() { return "pre-process-hext"; }

K_CELL

Specify the cell to be extracted. This will become the top cell in the output (database)

xxxxxxxxxx
static const char* K_CELL() { return "cell="; } //cell=%s //cell={cellname}

F_NOPATHS

Convert paths to boundaries

xxxxxxxxxx
static const char* F_NOPATHS() { return "nopaths"; } 

K_TOPNAME

Rename the top cell in the output (database)

• This setting overrides K_NAMEMOD for the top cell

xxxxxxxxxx
static const char* K_TOPNAME() { return "top="; } //top=%s //top={name}

K_NAMEMOD

Modify the name of every cell in the output (database) by adding either a prefix or a suffix or both

• This will also affect the top cell name UNLESS K_TOPNAME is also used

• To specify only the suffix, use namemod=,{suffix}

xxxxxxxxxx
static const char* K_NAMEMOD() { return "namemod="; }; //namemod=%s[,%s] //namemod={prefix}[,{suffix}]

K_SCALE

Scale the output (database) by the specified amount (>0.0)

xxxxxxxxxx
static const char* K_SCALE() { return "scale="; } //scale=%lf //scale={value}

K_ANGLE

Rotate the output (database) by the specified amount

xxxxxxxxxx
static const char* K_ANGLE() { return "angle="; } //angle=%lf //angle={degrees}

K_TRANSLATE_UM

Translate the output (database) by the specified amount (in microns)

xxxxxxxxxx
static const char* K_TRANSLATE_UM() { return "translateUM="; } //translateUM=%lf,%lf //translateUM={dx},{dy}

F_FLIPY

Mirror the output (database) about X

xxxxxxxxxx
static const char* F_FLIPY() { return "mirror"; } 

K_LAYEROFFX

Offset every layer and datatype number with the specified amount

xxxxxxxxxx
static const char* K_LAYEROFFX() { return "loffx="; } //loffx=%d,%d //loffx={loffset},{doffset}

K_CLIP_BOX_UM

Clip the data to the specified box (in microns)

• Overrides K_CLIP_POLY_UM and K_CLIP_RND_UM

xxxxxxxxxx
static const char* K_CLIP_BOX_UM() { return "boxclipUM="; } //boxclipUM=%lf,%lf,%lf,%lf //boxclipUM={lx},{ly},{ux},{uy}

K_CLIP_POLY_UM

Clip the data to the specified polygon (in microns)

• MUST be a closed polygon (first vertex = last vertex)

• MUST have at least four vertices (triangle)

• Overrides K_CLIP_RND_UM

xxxxxxxxxx
static const char* K_CLIP_POLY_UM() { return "polyclipUM="; } //polyclipUM=%lf,%lf[,%lf,%lf]3+ //polyclipUM={x},{y}[,{x},{y}]3+

K_CLIP_RND_UM

Clip the data to the specified circle (in microns)

xxxxxxxxxx
static const char* K_CLIP_RND_UM() { return "rndclipUM="; } //rndclipUM=%lf,%lf,%lf,%lf,%lf //rndclipUM={cx},{cy},{radius},{arcres},{arcsag}

class QisMFile

xxxxxxxxxx
class QisMFile { .. };

The API to work with a file loaded into the database

Version Control

Cast to a pointer of another version in the class hierarchy (base/derived)

• Get the latest version number. Version numbers start at 1 and are reflected in the class name using the suffix V<number>. E.g <baseclass>V<version>

• The topmost base class is version 1 (V1 implied)

• The cast returns NULL if a version number is not recognized/implemented

xxxxxxxxxx
virtual void* QisMFile_cast(const int version) = 0;
virtual const void* QisMFile_cast(const int version) const = 0;
virtual int QisMFile_latest_version() const = 0;

Get_last_error_msg()

Get more information about the last error condition in form of an error string

xxxxxxxxxx
virtual const char* Get_last_error_msg() const = 0;

Get_file_path()

Get the path on disk for the file currently loaded into the database

xxxxxxxxxx
virtual const char* Get_file_path() const = 0;

Get_default_top_cell()

Get the name of the default top cell in the file (top cell with the deepest hierarchy tree that is automatically set as the view cell when the file is loaded)

xxxxxxxxxx
virtual const char* Get_default_top_cell() const = 0;

Get_cell_list()

Get the list of cellnames loaded into the database

• listPtr : A buffer to store the address of the list of cellnames

• Success : Number of cellnames (N) in the list pointed to by listPtr (N >= 0)

• Failure : Error code (N < 0). Call Get_last_error_msg to get error string

• ERROR CODES : One of QisMFileError::Get_cell_list_codes

• This method allocates memory to store the list of cellnames each time it is called. This memory must be released using Free_cell_list to avoid memory leak

xxxxxxxxxx
virtual int Get_cell_list(char**& listPtr) const = 0;

Get_top_cell_list()

Get the list of top cellnames loaded into the database

• listPtr : A buffer to store the address of the list of cellnames

• Success : Number of cellnames (N) in the list pointed to by listPtr (N >= 0)

• Failure : Error code (N < 0). Call Get_last_error_msg to get error string

• ERROR CODES : One of QisMFileError::Get_top_cell_list_codes

• This method allocates memory to store the list of cellnames each time it is called. This memory must be released using Free_cell_list to avoid memory leak

xxxxxxxxxx
virtual int Get_top_cell_list(char**& listPtr) const = 0;

Get_non_top_cell_list()

Get the list of cellnames loaded into the database that are not top cells (they are being referenced by at-least one other cell)

• listPtr : A buffer to store the address of the list of cellnames

• Success : Number of cellnames (N) in the list pointed to by listPtr (N >= 0)

• Failure : Error code (N < 0). Call Get_last_error_msg to get error string

• ERROR CODES : One of QisMFileError::Get_non_top_cell_list_codes

• This method allocates memory to store the list of cellnames each time it is called. This memory must be released using Free_cell_list to avoid memory leak

xxxxxxxxxx
virtual int Get_non_top_cell_list(char**& listPtr_) const = 0;

Get_cell_children_list()

Get the list of names for cells being referenced (child cells) by the specified cell

• cellname : Name of the cell being queried

• listPtr : A buffer to store the address of the list of cellnames

• Success : Number of cellnames (N) in the list pointed to by listPtr (N >= 0)

• Failure : Error code (N < 0). Call Get_last_error_msg to get error string

• ERROR CODES : One of QisMFileError::Get_cell_children_list_codes

• If the cell does not exist, the return will be 0 as would be the case if the cell made no references to other cells

• This method allocates memory to store the list of cellnames each time it is called. This memory must be released using Free_cell_list to avoid memory leak

xxxxxxxxxx
virtual int Get_cell_children_list(const char* cellname, char**& listPtr) const = 0;

Get_cell_extents()

Get extents (min-max box) of a cell

• cellname : Name of the cell being queried

• extents : A buffer to store the cell extents

• Success : true

• Failure : false. Call Get_last_error_msg to get more information about the error

• ERROR CODES : One of QisMFileError::Get_cell_extents_codes

xxxxxxxxxx
virtual bool Get_cell_extents(const char* cellname, QisMWindow& extents) const = 0;

Get_layer_list()

Get a complete list of layer and datatype pairs currently loaded into the database

• layers : Buffer to store the address of the list of layer numbers

• dttps : Buffer to store the address of the corresponding list of datatype numbers

• Success : Number of items (N) in layers (and also in dttps). This is the number of layer datatype pairs found in the database. (N >= 0)

• Failure : Error code (N < 0). Call Get_last_error_msg to get more information about the error

• ERROR CODES : One of QisMFileError::Get_layer_list_codes

• This method allocates memory to store the list of layers/datatypes each time it is called. This memory must be released using Free_layer_list to avoid memory leak (twice, once for layers and once for dttps)

xxxxxxxxxx
virtual int Get_layer_list(unsigned short*& layers, unsigned short*& dttps) const = 0;

Free_cell_list()

Release the memory allocated to store a list of cellnames

• list : Address of the list of cellnames

• count : Number of items in the list

xxxxxxxxxx
virtual void Free_cell_list(char** list, const int count) = 0;

Free_layer_list()

Release the memory allocated to store a list of layer or datatype numbers

• list : Address of the list of layer or datatype numbers

xxxxxxxxxx
virtual void Free_layer_list(unsigned short* layersOrDttps) = 0;

Get_cell_index()

Identify a given cell with a unique number

• cellname : Name of the cell in question

• Success : Cell Id (>= 0)

• Failure : Error code (< 0). Call Get_last_error_msg to get more information about the error

• ERROR CODES : One of QisMFileError::Get_cell_index_codes

xxxxxxxxxx
virtual int Get_cell_index(const char* cellname) const = 0;

Get_cell_name()

Get the cellname for a given cell identifier

• index : A valid cell identifier (>= 0)

• Success : Name of the matching cell (non-null, non-empty string)

• Failure : null/empty string. Call Get_last_error_msg to get more information about the error

• ERROR CODES : One of QisMFileError::Get_cell_name_codes

xxxxxxxxxx
virtual const char* Get_cell_name(const int index_) const = 0;

Get_file_report()

Get file report (as a string)

xxxxxxxxxx
SAMPLE OUTPUT

"User Unit: um
Database Unit: 1000 (per um)
Number of Structures: 47
Structure References: 5427
Array References: 510
Boundaries: 5765 (1332,1260,2)
Boxes: 0 (0,0,0)
Paths: 398 (145,87)
Vertices: 52298
Texts: 0(0)
Estimated Memory for Load Data: 0.6MB (612056 bytes)
Total Memory for Load Data: 0.6MB (612056 bytes)
Data Dropped: No
Scan Time:
  0 min 0 sec (elapsed time)
Load Time:
0 min 0 sec (elapsed time)"

xxxxxxxxxx
virtual const char* Get_file_report() const = 0;

Grid()

Get the size of a single database unit (resolution) in terms of the file units

• For a micron file with a nanometer resolution, grid = 0.001 (microns)

• File units in meters = Units()/Grid()

xxxxxxxxxx
virtual double Grid() const = 0;

Units()

Get the size of a single database unit in meters

• For a micron file with a nanometer resolution, units = 1e-9 (m)

• File units in meters = Units()/Grid()

xxxxxxxxxx
virtual double Units() const = 0;

Get_db_idx()

Reserved for internal use

xxxxxxxxxx
virtual int Get_db_idx() const = 0;

Get_cell_layer_exploded_vertices()

Get exploded vertex counts for a specified cell and layer

• cellName : Name of the cell in question

• layerNumber : Layer number in question (all datatypes)

• boundaryVertices : Address of a buffer to retreive the number of boundary vertices

• pathVertices : Address of a buffer to retreive the number of path vertices

• The QisMFileLoadCtrl::Compute_exploded_counts method MUST be used to specify the layers for which exploded counts are desired before file load in order for this method to work

xxxxxxxxxx
virtual bool Get_cell_layer_exploded_vertices(
  const char* cellName, const int layerNumber, long long* boundaryVertices,
  long long* pathVertices
  ) const = 0;

Create_exploder()

Create an independent instance of the exploder to get vector data

• argC, argT, argV : Reserved for internal use

• Success : (non-null) Handle to an instance of the exploder

• Failure : NULL. Call Get_last_error_msg to get more information about the error

• ERROR CODES: One of the QisMExploderError::Create_exploder_codes

• Every instance of the exploder created using this method must be destroyed using Destroy_exploder to avoid memory/resource leak

• This method may throw the std::bad_alloc exception if it fails to allocate the exploder object

• This method is NOT thread-safe. All instances of exploders MUST be created inside the main thread

xxxxxxxxxx
virtual QisMExploder* Create_exploder(
  const int argC, const char* const* argT, void* const* argV
  ) = 0;

Destroy_exploder()

Destroy an instance of the exploder

• handle : Handle to an instance of the exploder object

• This function will wait until the database traversal is completed for the current view object (if a new thread was created for that purpose)

• This method is NOT thread-safe. All instances of exploders MUST be destroyed inside the main thread

xxxxxxxxxx
virtual void Destroy_exploder(QisMExploder* handle) = 0;

class QisMFileMemoryMaps

xxxxxxxxxx
class QisMFileMemoryMaps: public QisMFile { .. };
typedef QisMFileMemoryMaps QisMFileV2;

SaveAs_memory_maps()

Save a disk image of the current QisMFile database in form of memory maps

• outputDir : Path of the directory where the memory maps will be created (If NULL or empty, they will be created in the same location as the input file)

• progressCb : Address of a handler for receiving progress updates

• Success : true

• Failure : false. Call Get_last_error_msg to get information about this error

• ERROR CODE : One of the `QisMFileError::Write_memory_maps_codes

• If the file was loaded to memory (QisMFileLoadCtrl::Get_file_data_on_disk() == false), .scan and .dbload memory maps will be created. Otherwise, .scan and .load memory maps will be created

• Pre-load settings such as layer-mapping/filtering (QisMFileLoadCtrl::Set_layer_map) or dropping texts (QisMFileLoadCtrl::Ignore_texts() == true) will be reflected in the newly created memory maps

• This method is intended primarily for created .scan/.dbload memory maps since they can be used independently of the original file

xxxxxxxxxx
virtual bool SaveAs_memory_maps(const char* outputDir, QisMNotify* progressCb) = 0;

typedef QisMFileV2

xxxxxxxxxx
typedef QisMFileMemoryMaps QisMFileV2;

class QisMFileV3

xxxxxxxxxx
class QisMFileV3: public QisMFileMemoryMaps { .. };

Parent()

Get a handle to QisMLib

xxxxxxxxxx
virtual NsQisMLib::QisMLib* Parent() = 0;
virtual const NsQisMLib::QisMLib* Parent() const = 0;

QisMFile commands

See qismfile.h for relevant C++ API

file.copy_to

xxxxxxxxxx
file.copy_to
  $filedb={id} 
  dir={dir_path}

• Copy the source of this database (represented by $filedb={id}) to a new destination {dir_path}

• The file name(s) remain the same

file.print_report

xxxxxxxxxx
file.print_report $filedb={filedb_id}

• Print the report for the specified database

• Equivalent to QisMFile::Get_file_report in qismfile.h

• {filedb_id} represents name of a variable associated with a file database created using lib.load_file or rtcr.setup_job

file.get_default_cell

xxxxxxxxxx
file.get_default_cell $filedb={filedb_id} [&var={var_id}]

• Get the name of the default cell (top cell with the deepest hierarchy or largest extents)

• Equivalent to QisMFile::Get_default_top_cell in qismfile.h

• {filedb_id} represents name of a variable associated with a file database created using lib.load_file or rtcr.setup_job

• {var_id} if used, sets a string variable of that name to the returned cell name so that it can be used in the subsequent script commands using (({var_id})). e.g. &var=CELL will cause all occurrences of ((CELL)) in the subsequent commands to be replaced by the returned cell name before those commands are executed

file.print_cells

xxxxxxxxxx
file.print_cells $filedb={filedb_id} [extents] [&var={var_name}]

• Print a list of all cells in the database

• Equivalent to QisMFile::Get_cell_list in qismfile.h

• {filedb_id} represents name of a variable associated with a file database created using lib.load_file or rtcr.setup_job

• extents if used, also prints the extents of each cell in the list

• {var_name} if used represents name of a string variable to store comma-separated list of cell names. It can be referenced in subsequent commands using (({var_name}))

file.print_top_cells

xxxxxxxxxx
file.print_top_cells $filedb={filedb_id} [extents] [&var={var_name}]

• Print a list of top cells in the database

• Equivalent to QisMFile::Get_top_cell_list in qismfile.h

• {filedb_id} represents name of a variable associated with a file database created using lib.load_file or rtcr.setup_job

• extents if used, also prints the extents of each cell in the list

• {var_name} if used represents name of a string variable to store comma-separated list of cell names. It can be referenced in subsequent commands using (({var_name}))

file.print_child_cells

xxxxxxxxxx
file.print_child_cells $filedb={filedb_id} cell={cellname} [extents] [&var={var_name}]

• Print a list of cells directly referenced by the specified cell

• Equivalent to QisMFile::Get_cell_children_list in qismfile.h

• {filedb_id} represents name of a variable associated with a file database created using lib.load_file or rtcr.setup_job

• extents if used, also prints the extents of each cell in the list

• {var_name} if used represents name of a string variable to store comma-separated list of cell names. It can be referenced in subsequent commands using (({var_name}))

file.get_cell_extents

xxxxxxxxxx
file.get_cell_extents $filedb={filedb_id} [cell={cellname}] [&var={var_id}]

• Get extents of the specified cell

• Equivalent to QisMFile::Get_cell_extents in qismfile.h

• {filedb_id} represents name of a variable associated with a file database created using lib.load_file or rtcr.setup_job

• {cellname} if used, represents the name of the cell in question. If omitted, the default cell is used

• {var_id} if used, sets a string variable of that name to the returned extents so that it can be used in the subsequent script commands using (({var_id})). e.g. &var=EXTS will cause all occurrences of ((EXTS)) in the subsequent commands to be replaced by the returned extents before those commands are executed. The extents are preserved in the format {minx},{miny},{maxx},{maxy}

file.print_layers

xxxxxxxxxx
file.print_layers $filedb={filedb_id} &var={var_name}

• Print a list of all layers in the database

• Equivalent to QisMFile::Get_layer_list in qismfile.h

• {filedb_id} represents name of a variable associated with a file database created using lib.load_file or rtcr.setup_job

• {var_name} if used represents a string variable to store a comma-separated list of layer:datatype. It can be referenced in subsequent commands using (({var_name}))

file.print_cell_tree

xxxxxxxxxx
file.print_cell_tree $filedb={filedb_id} [cell={cellname}] [&var={name}] [sep={open}{close}{next}]

• Print the tree (hierarchy) for the specified cell

• {filedb_id} represents name of a variable associated with a file database created using lib.load_file or rtcr.setup_job

• {cellname} if used, is the name of the cell whose tree is to be printed. If omitted, the entire database hierarchy (trees of all top cells) is printed

• [&var={name}] if used stores the entire cell hierarchy in a parser-friendly string variable of the specified name. In that case, [sep={open}{close}{next}] can be used to control the separators as follows --

  • {open} is a single character that indicates the start of sub-tree for the current cell. Default: {

  • {close} is a single character that indicates the end of the sub-tree for the current cell. Default: }

  • {next} is a single character that indicates the next cell at the same hierarchy. Defaul: ,

• [out={file_path}] if specified, writes the parser-friendly string to a binary file. The first 8 bytes contain the size of the c-string (including the null-terminator) that follows immediately after

• silent if used will cause the command to suppress the printing of the tree

file.save_memory_maps

xxxxxxxxxx
file.save_memory_maps $filedb={filedb_id} [outdir={output_directory}]

• Save the database as memory maps (cache) on disk

• This feature works for GDSII files only

• Equivalent to QisMFileV2::SaveAs_memory_maps in qismfile.h

• {filedb_id} represents name of a variable associated with a file database created using lib.load_file or rtcr.setup_job

file.create_exploder

xxxxxxxxxx
file.create_exploder &exploder={exploder_id} $filedb={filedb_id}

• Create an instance of the exploder (spatial query object)

• Equivalent to QisMFile::Create_exploder in qismfile.h

• Requires 1 license of license (11027) per call

• {filedb_id} represents name of a variable associated with a file database created using lib.load_file or rtcr.setup_job

• {exploder_id} represents name of a variable associated with the exploder to be created

• Every exploder object created using this command MUST be destroyed using file.destroy_exploder to avoid resource leaks

file.destroy_exploder

xxxxxxxxxx
file.destroy_exploder $exploder={exploder_id} $filedb={filedb_id}

• Destroy an exploder

• Equivalent to QisMFile::Destroy_exploder in qismfile.h

• Releases 1 license of (11027) acquired during file.create_exploder

• {filedb_id} represents name of a variable associated with a file database created using lib.load_file or rtcr.setup_job that was used to create this exploder

• {exploder_id} represents name of a variable associated with the exploder to be destroyed