[Artwork] / [QisMLib] / [Programmer's Corner]

QisMLib Script Commands

Console (qismscript64.exe) Commands

These commands are only applicable when using the scripting console (qismscript64.exe) to execute scripts or commands

usage.required

usage.required {description}

• Report mandatory paramters for using a script (one per line)

• {description} is the appropriate description of the parameter

usage.option

xxxxxxxxxx
usage.option [{description}]

• Report optional paramters for using a script (one per line)

• {description} is the appropriate description of the parameter

usage.info

xxxxxxxxxx
usage.info {description}

• Report any additional information relevant to a script

• {description} is the appropriate information

sleep

xxxxxxxxxx
sleep 
  interval={interval_s}

• Sleep for the specified interval in seconds

assert

xxxxxxxxxx
assert
  key={name} 
  [msg={prompt}]

• Alternative to script.required

• Confirm that a string variable has been set. If not, exit the script with an error message

• key={name} identifies the variable in question

• [msg={prompt}] if specified will show up in the error message

• The error message will appear as error: missing {name} or error: missing {name}={ {prompt} }

askif

xxxxxxxxxx
askif 
  key={key} 
  [msg={message}]

• Check if the string variable {key} has been set. If not, prompt the user for a value

• {message} is the appropriate message to add to the prompt

system

xxxxxxxxxx
system {program} {args}*

• Execute an application or command provided by the system (or shell)

• {program} is the appropriate application/command to execute

• {args} are one or more paramters to pass per the application/command's usage

commands

xxxxxxxxxx
commands 
  [{search-string}]

• Get a list of available commands and it's paramters

• {search-string} if specified only lists commands whose name/paramter-list contain the search string

exit

xxxxxxxxxx
exit

• Terminate the execution of the script WITHOUT normally (without an error)

Basic (QisMScript) Commands

Various utility commands that aid in the development of a script Available to all applications using the QisMLib system with scripting enabled

script.procedure

xxxxxxxxxx
script.procedure {procedure_name}

• Begin definition of a new procedure called {procedure_name}

• Every script.procedure MUST have a matching script.end_procedure

• Nested procedures are not allowed. i.e A procedure cannot define another procedure from within itself. It can however, call other procedures already defined at the time of execution

• A procedure definition MUST appear before it is called using script.call or script.foreach

script.end_procedure

xxxxxxxxxx
script.end_procedure

• Close the definition of the procedure in question

script.call

xxxxxxxxxx
script.call {procedure_name}

• Execute the specified procedure (already defined at this point)

• All the variables (object handles and strings) defined at this point are available to the called procedure

• Procedures can call other procedures already defined at the time of execution

script.push

xxxxxxxxxx
script.push {token}+

• Add one or more tokens to a list of tokens that will be passed to every subsequent command

script.pop

xxxxxxxxxx
script.pop [{token}]

• Remove the specified token from the list of tokens that will be passed to every subsequent command

• If no token is specified, the entire list is cleared

script.required

xxxxxxxxxx
script.required {var_id}+

• Confirm that all of the specified var(s) have been defined before proceeding with the next command to avoid unexpected outcomes of the subsequent command execution(s)

• {var_id} represents name of one or more variables of type # (string variables) that can be referenced elsewhere in the script as ((var_id))

• This command will return an error if even one of the specified var(s) have not been defined. If this command is part of a script file, the execution of that script will be terminated

script.if

xxxxxxxxxx
script.if {condition} {cmd} {args}*

• Execute a command ONLY IF {condition} evaluated to TRUE

• {condition} can be one of the following:

  • {key} : TRUE if a string variable called {key} is defined and not empty

  • !{key} : TRUE if a string variable called {key} is NOT defined or is empty

  • {key}=={value} : TRUE if a string variable called {key} has been set to {value}

  • {key}!={value} : TRUE if a string variable called {key} does not exist or has a value other than {value}

  • {key}~={value} : TRUE if a string variable called {key} CONTAINS the string {value}

  • {key}~!{value} : TRUE if a string variable called {key} DOES NOT CONTAIN the string {value}

  • {key}@@{regex} : TRUE if a string variable called {key} matches a DOS-like regular expression {regex}

  • {key}@!{regex} : TRUE if a string variable called {key} DOES NOT MATCH a DOS-like regular expression {regex}

  • {key1}|{key2}...|{keyn} : TRUE if at least one of the {key1...n} are defined

  • {key1}&{key2}...&{keyn} : TRUE if all of the {key1...n} are defined

  • extension={name} : TRUE if the specified extension identified by {name} is loaded

• {cmd} {args}* is the command to be executed if the condition is TRUE along with it's arguments

script.set

xxxxxxxxxx
script.set {{key}={value}}+

• Define one or more string variables to be used in the script

• Once defined, a string variable can be referenced elsewhere in the script using (({key}))

script.setif

xxxxxxxxxx
script.setif {{key}={value}}+

• Define one or more string variable ONLY IF not defined already

• Once defined, a string variable can be referenced elsewhere in the script using (({key}))

script.ifset

xxxxxxxxxx
script.ifset {{key}={value}}+

• Assign a value to one or more string variable ONLY IF that variable already has a value

• Subsequently referencing that string variable elsewhere in the script using (({key})) will return the new value

script.substr

xxxxxxxxxx
script.substr 
  in={string} 
  &out={var_name} 
  old={sub_string_to_replace} 
  new={replacement_sub_string}

• Substitute all occurrence of {sub_string_to_replace} in an input string with {replacement_string}

• The modified string is then stored in a string variable called {var_name} and can be accessed in the subsequent command using (({var_name}))

script.tokenize

xxxxxxxxxx
script.tokenize
  in={string}
  &out={var_name}
  old={string_of_separators}
  new={char_separator}

• Separate the specified string into tokens based on a list of character separators represented by {string_of_separators} and compose a new string where those tokens are concatenated using a new separator {char_separator}

• The modified string is then stored in a string variable called {var_name} and can be accessed in the subsequent command using (({var_name}))

script.parse

xxxxxxxxxx
script.parse 
  str={string}
  format={...}
  &vars={id0}[,{id1}...{idn}]

• Parse a string represented by str={string} and based on the format spec. format={...}, set the variables specified by &vars={...}

• The format spec. uses %{index}% to reference the variable from the list of vars. E.g %0% references the very first variable in &var

• The parser will match {string} and {format} until a variable is referenced or if there is an error till either of the two end

• It will print a message (({var})) = {value} for every variable successfully captured

script.branch

xxxxxxxxxx
script.branch script={script_file_path} [{key}={value}]*

• Create a branch to another script as if executing a function defined in form of that script

• {script_file_path} is the path of another script file containing commands representing the branch

• {key}={value} are optional arguments that can be passed on to the branching script and are valid only for the duration of the branch execution

• Nested branches are allowed. A branch can invoke branching commands to another script(s). There is no limit on the number of levels

• Cyclic/recursive branching while possible is to be avoided as it may lead to infinite recursion (and therefore a stack overflow)

• Errors from branching scripts are treated as warnings. Aborts (exit) are ignored

script.capture

xxxxxxxxxx
script.capture &var={id} {program} {args}*

• Execute an application or command provided and capture the it's output to stdout

• &var={id} is name of a string variable where the std output of the command will be saved

• {program} is the appropriate application/command to execute

• {args} are one or more paramters to pass per the application/command's usage

• This is the same as the system command except it allows the capture of the output to a string variable rather than just logging it

• It's best used when the command being invoked is a utility that prints exactly the information to be captured

script.foreach

xxxxxxxxxx
script.foreach
  &token={var_name} 
  {loop={from},{to},{increment}} | {list={list_of_tokens} | file={token_file}}
  {branch={script_file_path} | call={procedure_name}}
  [sep={separator}] 
  [{key}={value}]*

• Execute a loop for each item in a list of items

• loop= creates a for loop starting with an integer {from} upto {to} with a step of {increment}. On each run, the specified token is assigned the value of the for iterator. If {increment} is positive, the test is {from} <= {to}. Otherwise, the test is {from} >= {to}

• Alternately list={list_of_tokens} creates a loop based on a string containing one or more tokens separated by separators. On each run, the specified token is assigned the current item from the list

• Alternately, file={token_file} creates a loop based on a list of items in a text file, one item per line. On each run, the specified token is assigned the item at the current line

• {separator} if used is a list of characters to be used as separators in the list. Default separator is , (comma)

• {var_name} represents the name of a string variable that will temporarily hold a token from the specified list. The value of this token will change as this command iterates through the specified list

• {script_file_path} is the path of another script file containing commands representing the branch to be executed for each token in the list (as if it's a function)

• {procedure_name} is name of a procedure that has already been defined at this point in the execution

• {key}={value} are optional arguments that can be passed on to the branching script and are valid only for the duration of the script.foreach command

• Nested branches are allowed. A branch can invoke branching commands to another script(s). There is no limit on the number of levels

• Nested procedure calls are not allowed

• Cyclic/recursive branching while possible is to be avoided as it may lead to infinite recursion (and therefore a stack overflow)

• Errors from branching scripts are treated as warnings. Aborts (exit) are ignored

script.convert

xxxxxxxxxx
script.convert
  from={spec} 
  to={spec} 
  values={list} 
  [&var={id}] 

• Convert a comma-separated list of values from one unit to another

• {spec} can be one of the following :-

  • m

  • cm

  • mm

  • um

  • nm

  • in

  • mils

  • dpi

  • dbu,{db_id}

  • uu,{db_id}

• For dpi conversions, the value to be converted is implied to be the pixel-size (or the dot-size)

• {db_id} is a variable of type QisMFile* representing the database in question. dbu is the database-unit and uu is the user-unit of that database

• values provides a comma-separated list of values in the source (from) units

• scale if specified multiplies the result with the specified value

• &var if specified will add a new string variable represented by {id} containing a comma-separated list of results

• E.g --

  • from=um to=dpi values=1 will result in 25400. I.e a pixel of size 1um is equivalent to 25400 dots-per-inch

  • from=mm to=um values=1,0.001 will result in 1000,1

  • For a UM db F with NM resolution (units = 1e-6 m and grid = 1e-9 m),

    • from=uu,F to=dpi values=1 will result in 25400 (1um = 25400dpi)

    • from=dpi to=dbu,F values=25400 will result in 1000 (25400dpi = 1000nm)

script.rename

xxxxxxxxxx
script.rename $old={old_id} type={type_name} $new={new_id}

• Move a script variable of name {old_id} and type {type_name} to a new name {new_id}

• The old id for the specified type will cease to exist from this point on

• The type remains the same

• CAUTION -- Any other dependent variables that were added alongside {old_id} such as {old_id}.{something} will continue to exist as is. Therefore, this command should be used sparingly and only when there is no other alternative solution

script.make_id

xxxxxxxxxx
script.make_id str={string} &id={id}

• Convert an arbitrary string {string} into another string {id} that is more suitable to be used as a script variable name

• Replaces most non-alphanumeric characters with an underscore or a hyphen

• Does not guarantee uniqeness. Two non-identical strings could potentially result in the same id

script.num_cpus

xxxxxxxxxx
script.num_cpus [&var={name}]

• Print the no. cpu(s) in the system

• If name is specified, the value is stored as a string variable by that name

script.phys_mem_size

xxxxxxxxxx
script.phys_mem_size [&var={name}]

• Print the amount of physical memory in the system (RAM)

• If name is specified, the value (mem. size in bytes) is stored as a string variable by that name

script.file_name

xxxxxxxxxx
script.file_name 
  path={file_path} 
  [&dir={var}] 
  [&name={var}] 
  [&ext={var}]
  [&basename={var}]
  [&full={var}]

• Get various components of a file at the specified {file_path}

  • &dir if specified, retrieves the directory

  • &name if specified, retrieves the file name (with extension)

  • &ext if specified, retreives the extension

  • &basename if specified, retreives the name (without extension)

  • &full if specified, get the absolute full path

script.file_size

xxxxxxxxxx
script.file_size 
  path={file_path} 

• Print file size

script.new_window_set

xxxxxxxxxx
script.new_window_set 
  &set={set_id}
  llur={name}:{lx},{ly},{ux},{uy}
  llwh={name}:{lx},{ly},{width},{height}
  cwh={name}:{cx},{cy},{width},{height}
  @llur={name}:{txt_file}
  @whll={name}:{txt_file}
  @whc={name}:{txt_file}
  tilerc={name}:{roi_lx},{roi_ly},{roi_ux},{roi_uy}:{cols},{rows}[:{i},{j}]*
  tilewh={name}:{roi_lx},{roi_ly},{roi_ux},{roi_uy}:{width},{height}[:{i},{j}]*
  cxy={name}:{width},{height}[:{cx},{cy}]+
  rand={name}:{roi_lx},{roi_ly},{roi_ux},{roi_uy}:{width},{height}:{count}
  [expand={uu}]
  [shuffle]

• Create a new set of rectangular windows

• Multiple arguments can be used for building a cumulative set

• All co-ordinates and dimensions are in file-units (e.g um, mm, inch) associated with the CAD source

• {set_id} represents name of the variable of type QisMBoxSet* associated with the newly created set

• The QisMBoxSet C++ interface can be found in qismbase.h

• {name} is a string identifier associated with a window which may be used to determine the name of the output file corresponding to that window

• {lx}, {ly}, {ux}, {uy} represent lower-left and upper-right co-ordinates

• {width}, {height} represent the window size

• {cx}, {cy} represents co-ordinates of the window center

• {txt_file} is the path to an existing text file which contains the following :-

  • for @llur= , each line contains {lx},{ly},{ux},{uy} representing one window

  • for @llwh= , the first line contains {width},{height} representing the window size and each subsequent lines contains {lx},{ly} representing the position of the window's lower-left corner

  • for @cwh= , the first line contains {width},{height} representing the window size and each subsequent lines contains {cx},{cy} representing the position of the window's center

• For generating tiles, {roi_lx},{roi_ly},{roi_ux},{roi_uy} represents the region of interest (ROI) to be tiled

• {cols},{rows} represents the number of tiles along X and Y respectively

• {width}, {height} represent the tile size

• {i},{j} is optional represents the position of one or more tiles to be added (1 <= i <= {cols} and 1 <= j <= {rows}). If used, all other tiles not in this list will be dropped

• For the random tile generator rand= , {count} represents the number of tiles to be generated at random locations within the ROI

• expand={uu} if specified, expands (enlarges or shrinks) each tile by the specified amount in user-units on each side

• If shuffle is specified, all the tiles will be randomly shuffled

• Every set created using this command MUST be eventually destroyed by the script using script.delete_window_set to avoid resource leaks

script.delete_window_set

xxxxxxxxxx
script.delete_window_set $set={set_id}

• Delete a rectangular window set created using script.new_window_set

• {set_id} represents name of the variable of type QisMBoxSet* associated with set to be destroyed

script.window_set_to_file

xxxxxxxxxx
script.window_set_to_file $set={set_id} path={file_path} [format={TXT | GDS | OAS}] [units={u_m},{g_m}] [id]

• Write the specified set of windows to a TEXT file

• {set_id} represents name of the variable of type QisMBoxSet* associated with set to be used

• {file_path} is the path of a file to be written

• format=TXT (default) writes a text file where each line of the text file represents one window from the set in the format {minx},{miny},{maxx},{maxy}

• format=GDS or format=OAS writes a GDSII or OASIS file with the boxes on layer 0:0. In that case, units={u_m},{g_m} specifies the units and grid in meters

• id if specified causes the position of the tiles to be written as well

script.window_set_to_string

xxxxxxxxxx
script.window_set_to_string
  $set={set_id}
  &out={var_name}
  sep={char}

• Create a string from the co-ordinates of the windows from the specified set of windows

• {set_id} represents name of the variable of type QisMBoxSet* associated with set to be used

• The new string is then stored in a string variable called {var_name} and can be accessed in the subsequent command using (({var_name}))

• The format of that string is {minx},{miny},{maxx},{maxy}[{char}{minx},{miny},{maxx},{maxy}]* where {char} is the new separator of windows

script.print_vars

xxxxxxxxxx
script.print_vars

• Print the complete list of script variables and their values available at this moment

• Each variable will be reported as {type}.{name} = {value}

• For variables that represent object handles, {value} is an address

QisMLib Commands

See qismlib.h for the relevant C++ API

lib.load_file

xxxxxxxxxx
lib.load_file
&filedb={filedb_id} 
input={input_file_path}
[layermap={layer_map_str}] 
[notext] [diskload] [emptyrefs]

• Create a database from a GDSII/OASIS/DBLOAD file

• Equivalent to QisMLib::Load_file in qismlib.h

• {filedb_id} represents name of a variable associated with the newly created database

• {input_file_path} is the path of a valid GDSII/OASIS/DBLOAD file

• {layer_map_str} if used, is a string specifying the layer mapping. e.g. ALL-NULL,1-100,2:2-200:2,3-300:0

  • re-map 1:* to 100:*

  • re-map 2:2 to 200:2

  • re-map 3:* to 300:0 (combine all datatypes of 3)

  • drop all other layers

• notext if used, drops all TEXT items

• diskload if used, retains the data section of the database on disk to reduce the memory footprint at the cost of operational speed

• emptyrefs if used, loads references to empty cells

• Every database created using this command MUST be eventually unloaded using lib.unload_file to avoid resource leaks

• This command will define two new string variables {filedb_id}.grid and {filedb_id}.units corresponding to the file grid (in meters) and units (in meters). They can be referenced elsewhere in the script using (({filedb_id}.grid)) and (({filedb_id}.units)) respectively. These will only be available while the database is alive (until lib.unload_file is called)

lib.load_processed_file

xxxxxxxxxx
lib.load_processed_file
  procfile={gds}
  &filedb={id} 
  input={gds_oas_dbload}  
  [layermap={string}] 
  [notext]  
  [roiUM={lx},{ly},{ux},{uy}]  
  [cell={name}] 
  [thrnum={nt},{n_per_t}] 
  [partition={nvert}]  
  [sizingUM={x},{y}] 
  [buttingUM={overlap}] 
  [maxvert={n}] 
  [convex]  
  [corrx={x},{y},{dx},{dy}[,{x},{y},{dx},{dy}]*]  
  [affine={xform}{+{xform}}*] 'where xform={scale:{x},{y} | angle:{deg} | txyUM:{dx},{dy} | flip:{X | Y | XY} | shear:{shx},{shy}'  
  [minrep={n>0}] 
  [noarefs] 
  [jitterUM={value}] 
  [circleUM={arcsag}] 
  [dbg1={l}:{d}]
  [acsv={string} acsp={path}]

• Pre-process a GDSII/OASIS/DBLOAD file to create another GDSII file that will be loaded to create the database in question. Therefore the database being created is a modification of the source design

• procfile={gds} is the path where the new processed GDSII will be created to be loaded

• &filedb={id} specifies the name to identify the new database after loading

• input={gds_oas_dbload} is the path of the original GDSII/OASIS or DBLOAD file to be processed

• layermap={string} if specified, filters/maps the layers of the original file before pre-processing

• notext if specified drop TEXT elements

• roiUM={lx},{ly},{ux},{uy} if specified, clips the data to be processed/loaded to the specified region (in file units)

• cell={name} if specified, sets the view cell to be processed. This will be the top cell in the processed file (and the database). Otherwise the default top cell of the original will be used

• thrnum={nt},{n_per_t} if specified sets the multi-threading load. {nt} is the no. threads processing various tiles and {n_per_t} is the no. threads per tile for certain operations. Default: {no. cpus},1

• partition={nvert} if specified determines the threshold (in terms of number of vertices) for breaking up the design into tiles. Default: 75000

• sizingUM={x},{y} if specified applies +ve or -ve sizing (edge compensation) in UM

• buttingUM={overlap} if specified converts polygons will holes into butting polygons with the specified overlap in UM. Default: It uses cutlines for such polygons

• maxvert={n} if specified limits any polygons to the specified max. vertex count. Default: 8190

• convex if specified generate only polygons that are convex in X and Y

• corrx={x},{y},{dx},{dy}[,{x},{y},{dx},{dy}]* if specified, applies bi-linear transformation based on the specified measured/correction points

• affine={xform}{+{xform}}* 'where xform={scale:{x},{y} | angle:{deg} | txyUM:{dx},{dy} | flip:{X | Y | XY} | shear:{shx},{shy}' if specified, applies affine transformations in the order specified (left to right)

• minrep={n>0} if specified, forms pattern cells in the output only for polygons that repeat at least {n} times. Default: 5

• noarefs if specified does not group array-like repeating patterns into AREFs

• jitterUM={value} if specified, allows a tolerance of the specified UM value when comparing polygons for repeating patterns. Default: 0

• circleUM={arcsag} if specified will detect circles such that the max. chord error is {arcsag} in UM. Default: No circle detection

• dbg1={l}:{d} if specified writes diagnostic information (such a tiles) on the specified layer

• acsv and acsp if specified indicate the use of trusted licensing

lib.load_processed_oasis

xxxxxxxxxx
lib.load_processed_oasis
  input={oasis}  
  procfile={gds}
  &filedb={id} 
  [layermap={string}] 
  [notext]  
  [maxv={4 <= n <= 8190} | 0]
  [dropcells={sep}{regex}[{sep}{regex}]*]

• Pre-process an OASIS file to create another GDSII file that will be loaded to create the database in question. Therefore the database being created is a modification of the source design

• procfile={gds} is the path where the new processed GDSII will be created to be loaded

• &filedb={id} specifies the name to identify the new database after loading

• input={oasis} is the path of the original OASIS file to be processed

• layermap={string} if specified, filters/maps the layers of the original file before pre-processing

• notext if specified drop TEXT elements

• maxv controls how polygons with vertices greater than 8190 are handled --

  • if maxv == 0 (default), such polygons (boundaries and paths) are written to GDSII with multiple XY records per boundary/path. This format may work with some GDSII readers and may fail with some others

  • if 4 <= maxv <= 8190, such boundaries are broken up into smaller butting boundaries of max. maxv vertices and a single XY record per boundary. Paths are still written with multiple XY records per path

• dropcells if specified will drop any cell (definition and reference) that matches any of the specified dos-like regular expression {regex}. {sep} is a char used to separate the expressions

lib.load_processed_hext

xxxxxxxxxx
lib.load_processed_hext
  input={oasis}  
  procfile={gds}
  &filedb={id} 
  [layermap={string}] 
  [notext]  
  [cell={name}]
  [nopaths]
  [top={name}]
  [namemod={prefix}[,{suffix}]]
  [scale={scale}]
  [angle={degress}]
  [translateUM={dx},{dy}]
  [mirror]
  [loffx={l},{d}]
  [boxclipUM={minx},{miny},{maxx},{maxy}] | [polyclipUM={x},{y}[,{x},{y}]3+] | [rndclipUM={cx},{cy},{radius},{arcres},{arcsag}]

• Pre-process an OASIS file to create another GDSII file that will be loaded to create the database in question. Therefore the database being created is a modification of the source design

• procfile={gds} is the path where the new processed GDSII will be created to be loaded

• &filedb={id} specifies the name to identify the new database after loading

• input={oasis} is the path of the original OASIS file to be processed

• layermap={string} if specified, filters/maps the layers of the original file before pre-processing

• notext if specified drop TEXT elements

• cell={name} if specified sets the view cell (which will become the top cell in the new database)

• nopaths if specified converts all paths to boundaries. Zero-width paths will be dropped

• top={name} if specified renames the top cell in the (output and the) new database to the specified name. Otherwise, it will be same as the view cell (cell={name})

• namemod={prefix}[,{suffix}] if specified renames all cells with the specified prefix (and/or) suffix. This includes the top cell UNLESS top={name} is also used

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

• scale, angle, translateUM and mirror (flip-Y) transform the entire output appropriately

• loffx={l},{d} if specified adds the specified offsets to the layers and datatypes

• boxclipUM=... if specified clips the data to the specified box (in microns)

• polyclipUM=... if specified clips the data to the specified polygon (in microns)

• rndclipUM=... if specified clips the data to the specified circle (cx,cy,radius and arcsag in microns; arcres in degrees)

lib.load_gds_with_mmaps

​x
lib.load_gds_with_mmaps
  &filedb={id}
  gds={path}
  [mapsdir={dir_path}]
  [layermap={layermap_string}]
  [notext]
  [memload]
  [emptyrefs]

• Load a GDSII file with the option of making use of .load memory maps (database disk image) to speed up the loading

• Equivalent to the C++ API QisMLibV3::Load_gds_with_memory_maps (qismlib.h)

• {id} is name of a variable to be associated with the newly created database object

• {path} is the path of the source GDSII file to be loaded (which was also used to create the memory maps)

• {dir_path} if specified is the directory to find the .load and .scan memory map files. If omitted, the map files are implied to reside in the current working directory

• {layermap_string} if specified filters/re-maps layers. See lib.load_file for syntax

• notext if specified ignores TEXT elements. (default: TEXT elements if present are loaded)

• memload if specified loads the database in memory for faster operations. (default: the database is loaded from disk)

• emptyrefs if specified drops all references to empty cells

• Every database object created with this command MUST be eventually destroyed using lib.unload_file to avoid memory/resource leaks

• If suitable memory maps are not found or the ones that are found have incompatible characteristics, the specified GDSII file is loaded directly without taking advantage of any memory maps just like lib.load_file

lib.unload_file

xxxxxxxxxx
lib.unload_file $filedb={filedb_id}

• Destroy a QisMFile database

• Equivalent to QisMLib::Unload_file in qismlib.h

• {filedb_id} represents name of a variable associated with the database to be destroyed

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

QisMExploder commands

• see qismview.h and qismexploder.h for the relevant C++ API

exploder.set_view

xxxxxxxxxx
exploder.set_view
  $exploder={exploder_id}
  [reset] | {
    [cell={cellname}]
    [layers_on={list} | layers_off={list}]
    [window={minx},{miny},{maxx},{maxy}]
    [nesting={level>0}]
    [inside]
  }

• Set the exploder view

• Equivalent to various QisMExploder::Set_* methods in qismexploder.h or qismview.h

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

• If reset is specified, all other options are ignored and the view is reset to default options

• {cellname} if used, represents the view cell (default -- file.get_default_cell)

• {list} if used, represents a comma-separated list of layers or "ALL" . e.g. 1,2:2,3:3,3:4,4 (default -- ALL on)

• {minx}..{maxy} if used, represents the window co-ordinates in file units (default -- extents of the view cell)

• {level} if used, represents the max. number of nesting levels to traverse (default -- all levels)

• inside if used, only vectors fully inside the view window will be returned. Partially crossing vectors will be dropped (default -- all vectors crossing the view window, partial or full, will be processed)

exploder.get_boundaries

xxxxxxxxxx
exploder.get_boundaries $exploder={exploder_id} &bin={bin_id}

• Get the boundaries for the view set in the exploder (see exploder.set_view) and store it in a container

• Equivalent to QisMExploderV2::Get_boundaries in qismexploder.h

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

• {bin_id} represents name of a variable associated with the container where the boundaries will be stored

• Paths if any, will be converted to boundaries

• Every container created using this command MUST be eventually destroyed using exploder.delete_store to avoid resource leaks

exploder.get_cellref_boundaries

xxxxxxxxxx
exploder.get_cellref_boundaries
  $exploder={id} 
  cell={name} 
  ref={name} 
  &bin={id} 
  [window={lx},{ly},{ux},{uy}] 
  [layers={ON|OFF},{string}] 
  [dbg={l:d}]

• Get boundaries for every reference of a particular cell (including it's entire subtree) in the specified view.

• $exploder={id} represents name of a variable associated with the exploder

• cell={name} is the name of the view cell

• ref={name} is the name of the cell being referenced

• window=... is the region of interest in file-units (default: entire extents of the view cell)

• layers=... can be "ALL" or a comma-separated string of layers to be turned ON or OFF (default: layers=ON,ALL)

• &bin={id} represents name of a variable associated with the container where the boundaries will be stored

• Paths if any, will be converted to boundaries

• Every container created using this command MUST be eventually destroyed using exploder.delete_store to avoid resource leaks

file.make_cellref_semiflat

xxxxxxxxxx
file.make_cellref_semiflat
  $filedb={id} 
  out={path} 
  [cell={name}] 
  [window={lx},{ly},{ux},{uy}] 
  [layers={ON|OFF},{string}] 
  [dbg={l:d}]

• Generate a semi-flat file where the immediate children of the view cell are fully exploded and grouped into a single cell of the same name

• $filedb={id} is the name of the database to be used

• out={path} is the name of the output GDSII file path

• cell={name} if specified becomes the view cell. Otherwise the default top cell is used

• window=... if specified sets the ROI in file-units. Otherwise, the extents of the view cell is used

• layers=... can be "ALL" or a comma-separated string of layers to be turned ON or OFF (default: layers=ON,ALL)

• dbg={l:d} if used outputs misc. data (for debugging/diagnostics) on the specified layer (l:d)

exploder.delete_store

xxxxxxxxxx
exploder.delete_store $bin={bin_id} 

• Delete a container of boundaries only created by exploder.get_boundaries

• {bin_id} represents name of a variable associated with the container to be destroyed

exploder.write_texts_to_file

xxxxxxxxxx
exploder.write_texts_to_file $exploder={exploder_id} file={ascii_file_path} [sort]

• Explode TEXT data and write them to a file

• Uses QisMExploder::Get_vector_data in qismexploder.h to collect TEXT vectors from a view

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

• {ascii_file_path} is the path where an ASCII (text) file will be created

• Each line of the file represents one TEXT vector in the format {text_string},{parent_cell},{x_dbu},{y_dbu},{layer},{texttype}

• sort if specified will sort the items in format order before writing

exploder.write_srefs_to_file

xxxxxxxxxx
exploder.write_srefs_to_file $exploder={exploder_id} file={ascii_file_path} [sort]

• Explode SREF (single cell reference) data and write them to a file

• Uses QisMExploder::Get_vector_data in qismexploder.h to collect SREF vectors from a view

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

• {ascii_file_path} is the path where an ASCII (text) file will be created

• Each line of the file represents one SREF vector in the format {ref_cell},{parent_cell},{x_dbu},{y_dbu},{scale},{angle},{mirror 'N' | 'X'}

• sort if specified will sort the items in format order before writing

exploder.write_arefs_to_file

xxxxxxxxxx
exploder.write_arefs_to_file $exploder={exploder_id} file={ascii_file_path} [sort]

• Explode AREF (array cell reference) data and write them to a file

• Uses QisMExploder::Get_vector_data in qismexploder.h to collect AREF vectors from a view

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

• {ascii_file_path} is the path where an ASCII (text) file will be created

• Each line of the file represents one AREF vector in the format {ref_cell},{parent_cell},{x_dbu},{y_dbu},{scale},{angle},{mirror 'N' | 'X'},{columns},{rows},{col_dx_dbu},{col_dy_dbu},{row_dx_dbu},{row_dy_dbu}

• sort if specified will sort the items in format order before writing

QisMBStore commands

See qismbstore.h for relevant API

store.print_info

xxxxxxxxxx
store.print_info $bin={bin_id}

• Print information about a container of boundaries

• {bin_id} represents name of a variable associated with the container to be written

store.write_as_polys

xxxxxxxxxx
store.write_as_polys
  $bin={bin_id}
  path={output_base_path}
  grid={grid_m}
  units={units_m}
  [format={GDS | OAS}]
  [top={top_cellname}]

• Write a boundary container to disk as a GDSII or OASIS file

• {bin_id} represents name of a variable associated with the container to be written

• {output_base_path} is the directory + file name of the output file. The extension (.gds or .oas) is automatically added based on the format

• {grid_m} and {units_m} are the file grid and units in meters. e.g for a micron file with nano meter resolution, grid = 1e-9 (nm) and units = 1e-6 (um)

• format if used determines the file format. Default -- GDS

• {top_cell_name} if used writes the top cell name as specified. Default -- "TOP"

store.write_as_image

xxxxxxxxxx
store.write_as_image
  $bin={bin_id}
  path={output_base_path}
  grid={grid_m}
  units={units_m}
  resolution={PXSIZE | DPI | GRID},{x}[,{y}]
  [format={TIF | TIF8 | BMP | RAW}]
  [invert]
  [right_to_left]
  [dither=0.0-1.0]

• Write a boundary container as a monochrome bitmap image in TIFF/BMP/RAW format

• Requires the QisMRaster extension to be installed and configured

• Requires 1 license of (14827) per call

• {bin_id} represents name of a variable associated with the container to be written

• {output_base_path} is the directory + file name of the output file. The extension (.tif, .bmp or .raw) is automatically added based on the format

• {grid_m} and {units_m} are the file grid and units in meters. e.g for a micron file with nano meter resolution, grid = 1e-9 (nm) and units = 1e-6 (um)

• resolution can be specified in both X and Y directions as :-

  • PXSIZE -- size of 1 pixel in file units

  • DPI -- dots per inch

  • GRID -- as a multiple of the file grid

• Pixels can be square {x} == {y} or rectangle {x} != {y} . If {y} is omitted, {y} = {x}

• format if specified, determines the file format. Default -- TIF

• invert if used, reverses the image polarity (black (0) data on white (1) background)

• right_to_left if used, rasterizes the data from right to left. i.e. min-x of the data appears on the right hand size (max-x) of the image

• dither if used, generates a dithered image using a 8x8 Bayer matrix. The dithering value must be from 0.0 (max. 0 pixels/8x8 pixel data block) to 1.0 (max. 64 pixels/8x8 pixel data block)

QisMBoundaries commands

• See qismboundaries.h for the corresponding C++ API

boundariesapi.pre_proc_to_file

xxxxxxxxxx
boundariesapi.pre_proc_to_file
  $filedb={id} 
  $tiles={id} 
  gdsii={path}  
  [nt={n_tile_threads}] 
  [np={n_threads_per_tile}]  
  [p&s] | {[cell={name}] [layers={str}] [nesting={level}]  
  [buttingUM={overlap_um}] 
  [convex] 
  [sizingUM={x},{y}] 
  [maxvert={n}]  
  [corrx={{x},{y},{dx},{dy}}+ 
  [affine=[txyUM:{x},{y}]*[angle={deg}]*[scale:{x},{y}]*[shear:{x},{y}]*[flip:{X | Y | XY}]*]  
  [patternize] 
  [ellipsesUM={arcsag_um}] 
  [jitterUM={jitter_um}] 
  [minrep={n}] 
  [acsv={string} acsp={path}]

Generate a GDSII file based on a series of boundary operations on a database

• $filedb={id} represents the database to be processed

• $tiles={id} represents the tiles to be used to partition the data space for multi-threading

• gdsii={path} is the output GDSII file to be created

• nt={n_tile_threads} if specified, is the no. threads to be used to process tiles (default: no. cpus)

• np={n_threads_per_tile} if specified, is the no. threads to be used per tile for certain operations (default: 1)

• p&s if specified indicates that the source database is paint & scratch (Gerber/ODB++)

• cell={name} if specified, represents the view cell (default: deepest top cell)

• layers={str} if specified, is the layers of interest

• nesting={level} if specified, is the nesting level to be set for retrieving the data

• buttingUM={overlap_um} if specified, represents polygons with holes as a pair of butting polygons with the specified overlap in UM

• convex if specified, generates polygons that are convex in X and Y

• sizingUM={x},{y} if specified, applies +ve or -ve sizing (edge compensation) in UM

• maxvert={n} if specified, ensures that no polygon has more than the specified no. vertices

• corrx={{x},{y},{dx},{dy}}+ if specified, applies bi-linear transformation based on a set of measured points. Each point having four values --{x},{y},{dx},{dy}` in UM

• affine if specified, applies a series of affine transformations in the specified order

  • txyUM:{x},{y} applies translation in UM

  • angle={deg} applies rotation in degrees

  • scale:{x},{y} applies scaling along X and Y

  • shear:{x},{y} applies shearing along X and Y

  • flip:{X | Y | XY} applies reflection across X, Y or both

• patternize if specified, generates a semi-flat GDSII based on polygonal pattern recognition

• ellipsesUM={arcsag_um} if specified, attempts to detect circles based on the max. chord error in UM

• jitterUM={jitter_um} if specified, allows for a margin or error in UM when comparing polygons for grouping into patterns

• minrep={n} if specified, only generates a pattern definition if the no. repetitions are >= the specified threshold

• acsv={string} acsp={path} if specified, uses OEM/Trusted licensing for using the pre-processor. acsv is the vendor string. acsp is the key file path

boundariesapi.create

xxxxxxxxxx
boundariesapi.create
 &set={id} 
 units={units_m},{grid_m}

Create a new boundary set

• Create a new boundary set

• Every set must be eventually destroyed

boundaries.write_cache

xxxxxxxxxx
boundaries.write_cache
  $set={id} 
  path={output}

Dump a boundary set to a file on disk (cache file)

• $set={id} is the set in question

• path={output} is the path of the cache file

boundaries.read_cache

xxxxxxxxxx
boundaries.read_cache
  $set={id} 
  path={input}

Replace the specified boundary set with the contents of a disk dump (cache file)

• $set={id} is the set in question

• path={input} is the location of the cache file

boundaries.clear

xxxxxxxxxx
boundaries.clear
  $set={id}

Clear the boundary set

• $set={id} is the set in question

boundaries.add

xxxxxxxxxx
boundaries.add
  $set={id} 
  [$boundaries={id}[,{id}]*] 
  [$bstore={id}[,{id}]*]  
  [box={lx},{ly},{ux},{uy},{l},{d}] 
  [circle={x},{y},{r},{res},{sag},{l},{d}]  
  [$exploder={id}[,{id}]*] 
  [$ann={id}[,{id}]*]

Add boundaries to the specified set

• $set={id} is the set in question

• $boundaries={id}[,{id}]* adds one or more set(s)

• $bstore={id}[,{id}]* adds one or more bstore(s)

• box={lx},{ly},{ux},{uy},{l},{d} adds a box (in DBU)

• circle={x},{y},{r},{res},{sag},{l},{d} adds a circle (in DBU) where {res} is the arc. resolution in degrees and {sag} is the chord error in DBU

• $exploder={id}[,{id}]* adds boundaries from a pre-setup exploder

• $ann={id}[,{id}]* converts an annotation set to boundaries for adding

boundaries.add_lsynth

xxxxxxxxxx
boundaries.add_lsynth
  $set={id} 
  $lsynth={id} 
  spec={lsynth_spec} 
  [thrnum={nt}]"

Add the result of layer synthesis to the specified set

• $set={id} is the set in question

• $lsynth={id} is a pre-setup layer synthesizer to be used

• spec={lsynth_spec} is the layer synthesis expression

• thrnum={nt} if specified is the no. threads to be used for boolean operations (default: no. cpus)

boundaries.add_to_patternize

xxxxxxxxxx
boundaries.add_to_patternize
  $set={id} 
  $patterns={id} 
  [jitter={uu}]

Add the specified set to a patternizer object

• $set={id} is the set in question

• $patterns={id} is the patternizer object in question

• jitter={uu} is the acceptable slop (margin of error) in user-units to be used for polygon matching

boundaries.add_snp

xxxxxxxxxx
boundaries.add_snp
  $set={id} 
  $exploder={id} 
  roi={lx},{ly},{ux},{uy}

Add boundaries from a paint&scratch database

• $set={id} is the set in question

• $exploder={id} is the paint & scratch exploder to be used for extracting boundaries

• roi={lx},{ly},{ux},{uy} is the region of interest

boundaries.union

xxxxxxxxxx
boundaries.union
  $set={id} 
  $bool={id} 
  $settings={id} 
  thrnum={n} 
  [layerwise]

Unionize the contents of the specified set

• $set={id} is the set in question

• $bool={id} is the boolean object to be used for unionization

• $settings={id} is the settings object that has been setup with all the relevant parameters

• thrnum={n} is the no. threads to be used for the union (>=1)

• layerwise if specified, performs the union per layer:datatype. Otherwise, the entire set is unionized irrespective of the layers

boundaries.boolean

xxxxxxxxxx
boundaries.boolean
  $set={id} 
  $set1={id} $set2={id} 
  $bool={id} 
  $settings={id}  
  thrnum={n} 
  op={UNION | INTERSECTION | DIFFERENCE | XOR} 
  [layerwise]

Add boundaries formed by a boolean operation between two sets

• $set={id} is the set for feeding the output

• $set1 and $set2 are the operand sets

• $bool={id} is the boolean object to be used for unionization

• $settings={id} is the settings object that has been setup with all the relevant parameters

• thrnum={n} is the no. threads to be used for the union (>=1)

• layerwise if specified, performs the union per layer:datatype. Otherwise, the entire set is unionized irrespective of the layers

• op is the operation to be performed between the two sets

boundaries.correct

xxxxxxxxxx
boundaries.correct
  $set={id} 
  $corrx={id}

Apply bi-linear transformation to the boundaries in the specified set

• $set={id} is the set in question

• $corrx={id} is the correction object to be used for the transformation

boundaries.transform

xxxxxxxxxx
boundaries.transform
  $set={id} 
  $affine={id}

Apply affine transformation to the boundaries in a set

• $set={id} is the set in question

• $affine={id} is the affine object appropriately setup with the transformations

boundaries.get_extents

xxxxxxxxxx
boundaries.get_extents
  $set={id} 
  [&var={id}]

Get the extents of a set

• $set={id} is the set in question

• &var={id} if specified stores the extents as a string variable. It can be referenced subsequently as (({id}))

boundaries.write_gds_oas

xxxxxxxxxx
boundaries.write_gds_oas
  $set={id} 
  path={file_path} 
  [format=GDS | OAS]

Write a set to GDSII or OASIS

• $set={id} is the set in question

• path={file_path} is the output GDSII/OASIS path

• [format=GDS | OAS] if specified, determines the output format (default: GDSII)

boundaries.write_image

xxxxxxxxxx
boundaries.write_image
  $set={id} 
  dpi={x}[,{y}] 
  [format={TIF8 | TIF | BMP | RAW}] 
  [invert]

Write a set to a 1bpp raster image

• $set={id} is the set in question

• dpi={x}[,{y}] is the resolution in dots-per-inch

• format if specified, is the output format (default: TIF)

• invert if specified, inverts the image polarity (white data, black background)

boundaries.add_to_cad_block

xxxxxxxxxx
boundaries.add_to_cad_block
  $set={id} 
  {$writer={id} | {$block={id}}

Add a set to a CAD data block

• $set={id} is the set in question

• {$writer={id} is the cadwriter to which the boundaries will be added

• Alternately, {$block={id}} is the cad data block to which the boundaries will be added

boundariesapi.destroy

xxxxxxxxxx
boundariesapi.destroy
  $set={id}

Destroy a boundary set

• $set={id} is the set to be destroyed

QisMDraw commands

See qismdraw.h for the corresponding C++ API

draw.image

xxxxxxxxxx
draw.image
  $filedb={filedb_id} 
  [path={img_path_base}] 
  [cell={cellname}]
  [layers={layer_list}] 
  [window={minx},{miny},{maxx},{maxy}] 
  [nesting={level}]
  [format={GIF | DIB | XPM}] 
  [background={BLACK | WHITE}] 
  [filtersize={dfs}]
  [fill={ON | OFF}] 
  [text={ON | OFF}] 
  [res={x},{y}] 
  [refboxes={ON | OFF | NL}]
  [color={OUTLINE | FILL},{str}]

• Render a view of the database to an colored image file on disk

• Makes use of the QisMDraw API defined in qismdraw.h

• Requires ONE license of (11057) per call

• {filedb_id} is name of the variable associated with the file database

• {img_base_path} if specified generates an output file at the specified path (extension automatically added). Otherwise, the image is generated but not written to disk

• {cellname} if specified set the view cell. Default view cell is the deepest top cell

• {layer_list} if specified, is a comma-separated list of layer and/or layer:datatype numbers to be visible. Default: ALL loaded layers

• {minx}..{maxy} if specified represents the window to be set (adjusted to match the image aspect ratio). Default: Extents of the view cell is used

• {level} if specified sets a max. nesting level for drawing. Default: ALL levels

• format if specified sets the output file format. Default: GIF. XPM is only available on Linux.

• background if specified sets the background color. Default: BLACK

• {dfs} if specified sets the display filter size (for both geometries and references). Default: 0

• fill controls the fill mode. Default : OFF

• text controls if TEXT elements are drawn. Default: ON

• {x},{y} if used is the image resolution in pixels along X and Y. Default: 800, 600 pixels

• refboxes if specified controls if the references are drawn with outlines and labels. If ON, references at all nesting levels are drawn with outline and labels. If OFF, outlines and labels are not drawn. If NL, outlines and labels are only drawn for references at the specified nesting level (> 0)

• color=... specifies the colors for various layers for outline and/or fill. See QisMDrawObject::Set_layers_outline_color or QisMDrawObject::Set_layers_fill_color for details

QisMBool Commands

See qismbool.h for the relevant C++ API

bool.create_instance

xxxxxxxxxx
bool.create_instance &bool={boolinst_id}

• Create an instance of the Boolean object

• Equivalent to QisMBool::Create_instance in qismbool.h

• {boolinst_id} is name of a variable of type QisMBoolInst* to be associated with the newly created Boolean object

• Requires ONE license of (11047) which is released by bool.destroy_instance

• Every object created by this command MUST be eventually destroyed by bool.destroy_instance to avoid resource leaks

boolinst.export

xxxxxxxxxx
boolinst.export $bool={id} path={txt_file}

• Export the state of the specified bool object {id} to a state file {txt_file}

• This state file can be then used to set the state of any bool object using boolinst.import

• DO NOT hand edit this file without consulting Artwork Conversion

boolinst.import

xxxxxxxxxx
boolinst.import $bool={id} path={txt_file}

• Set the state of the specified bool object {id} to that reflected by the specified state file {txt_file}

• This state file MUST have been created using boolinst.export

boolinst.apply

xxxxxxxxxx
boolinst.apply $bool={id} $settings={id}

• Apply the specified settings to the boolean object

bool.destroy_instance

xxxxxxxxxx
bool.destroy_instance $bool={boolinst_id}

• Destroy an instance of the Boolean object

• Equivalent to QisMBool::Destroy_instance in qismbool.h

• {boolinst_id} is name of a variable of type QisMBoolInst* associated with the object to be destroyed

bool.create_settings

xxxxxxxxxx
bool.create_settings &settings={settings_id}

• Create an instance of the Boolean settings object

• Equivalent to QisMBool::New_settings in qismbool.h

• {settings_id} is name of a variable of type QisMBoolSettingsV2* to be associated with the newly created object

• Every object created by this command MUST be eventually destroyed by bool.destroy_settings to avoid memory leak

bool.destroy_settings

xxxxxxxxxx
bool.destroy_settings $settings={settings_id}

• Destroy an instance of the Boolean settings object

• Equivalent to QisMBool::Delete_settings in qismbool.h

• {settings_id} is name of a variable of type QisMBoolSettingsV2* associated with the object to be destroyed

boolsettings.set

xxxxxxxxxx
boolsettings.set
  $settings={settings_id}
  [reset]
  [sliver={sliver_value}]
  [clip={minx},{miny},{maxx},{maxy}]
  [butting={overlap}]
  [maxvert={count}]
  [passthru={ON | OFF}]
  [mergestripes={ON | OFF}]
  [convex={OFF | X | Y | FULL | HTRAP | VTRAP}]
  [sizing={OFF | STD | ISOTR | NONISOTR}[,{sizing_x}[,{sizing_y}]]]
  [rndcorners={RTANGLE | THREEPT | FIVEPT}]
  [cutlines] [lnvout] [lnvin={A | B | ALL | NONE}]
  [grid={grid_m}] [units={units_m}]
  [dbg={text_file}]
  [partition=NONE | AUTO,{numvert} | MANUAL,{nx},{ny} | AUTO+,{numvert}]

• Set various Boolean settings

• Equivalent to QisMBoolSettingsV2::Set_param in qismbool.h

• {settings_id} is name of a variable of type QisMBoolSettingsV2* associated with the settings object to be used

• reset if specified, resets all the settings to default values first before applying any other parameters

• {sliver_value} if specified sets the sliver parameter for removal of polygons (slivers) smaller than the specified threshold (in file units). Default: no filtering of tiny polygons

• {minx}..{maxy} if specified sets the clipping window (in file units). Any polygon crossing this window will be clipped. Default: no clipping

• {overlap} if specified (even 0.0), sets the polygon output mode to BUTTING with the specified overlap value along butting edges (in file units). Default: Polygons with holes have cutlines

• {count} if specified sets the max. vertex count for any output polygon. Larger polygons are broken up into smaller ones. Default: 8190 vertices

• passthru if specified sets/resets the pass through mode. If ON, the core boolean operation will be bypassed and only the output formatting procedures (such as clipping) will be run (Works only with boolinst.union). Default: OFF

• mergestripes if ON will force the removal of all edges that were created because of data partitioning across multiple threads. Default: OFF

• convex if specified activates convex mode for the output polygons. Default: OFF

• sizing if specified activates the sizing mode for output polygons. Default: OFF. For STD and ISOTR, {sizing_x} MUST be specified (in file units). For NONISOTR, both {sizing_x} and {sizing_y} MUST be specified

• rndcorners if specified controls sharp corners are handled during sizing. Default: (if ISOTR | NONISOTR sizing) THREEPT

• lnvout if specified sets the output polygon format to Leonov

• cutlines if specified sets the output polygon format to cutlines

• lnvin if specified indicates the format for the source polygons. A , B implies that only the specified operand is in Leonov format. ALL implies both operands are Leonov. NONE (default) implies none of the operands are Leonov.

• {grid_m} and {units_m} if specified represent the data units and resolution. Default: 1e-9 (nm) and 1e-6 (um) respectively

• All dimensional values in file units

• dbg if specified generates a {text_file} with detailed information about the internal state of the boolean object

• partition= sets the data partitioning scheme

  • NONE : no partitioning

  • AUTO : automatic based on no. vertices {numvert} of polygon crossing

  • MANUAL : {nx}, {ny} tiles

  • AUTO+ : automatic based on no. vertices {numvert} of polygon cossing and intersections

boolinst.union

xxxxxxxxxx
boolinst.union
  $bool={boolinst_id}
  $settings={settings_id}
  $in={input_bin_id}
  &out={output_bin_id}
  [thrnum={n_threads}]
  [layer={layer}]

• Unionize a set of polygons

• Equivalent to QisMBoolInst::UnionMT in qismbool.h

• {boolinst_id} is name of a variable of type QisMBoolInst* associated with the boolean object to be used

• {settings_id} is name of a variable of type QisMBoolSettingsV2* associated with the object holding the boolean settings

• {input_bin_id} is name of a variable of type QisMBStore* associated with a set of polygons to be used as the source

• {output_bin_id} is name of a variable of type QisMBStore* to be associated with the newly created set of resulting polygons

• {n_threads} if specified indicates the number of threads to be used for this operation. Default: no. system processors

• layer if specified indicates the layer number to be associated with the output polygons. Default : 0

• The output set of polygons MUST be eventually destroyed using boolinst.delete_store to avoid memory leak

boolinst.binary

xxxxxxxxxx
boolinst.binary
  $bool={boolinst_id}
  $settings={settings_id}
  $bin_a={operand_a_bin_id}
  $bin_b={operand_b_bin_id}
  &out={output_bin_id}
  [op={UNION | INTERSECTION | DIFFERENCE | XOR}]
  [thrnum={n_threads}]
  [layer={layer}]

• Perform binary operation between two sets of polygons

• Equivalent to QisMBoolInst::BinaryMT in qismbool.h

• {boolinst_id} is name of a variable of type QisMBoolInst* associated with the boolean object to be used

• {settings_id} is name of a variable of type QisMBoolSettingsV2* associated with the object holding the boolean settings

• {operand_a_bin_id} and {operand_b_bin_id} are names of variables of type QisMBStore* associated with a set of polygons to be used as the operand A and operand B respectively. The operation to be performed is A op B.

• {output_bin_id} is name of a variable of type QisMBStore* to be associated with the newly created set of resulting polygons

• op if specified represents the boolean operator. Default: UNION

• {n_threads} if specified indicates the number of threads to be used for this operation. Default: no. system processors

• layer if specified indicates the layer number to be associated with the output polygons. Default : 0

• The output set of polygons MUST be eventually destroyed using boolinst.delete_store to avoid memory leak

boolinst.delete_store

xxxxxxxxxx
boolinst.delete_store $bin={bin_id}

• Destroy a set of polygons created by boolinst.union or boolinst.binary ONLY

• {bin_id} is name of a variable of type QisMBStore* associated with the polygon set to be destroyed

• Equivalent to QisMBoolInst::Release in qismbool.h

bool.unionize_to_file

xxxxxxxxxx
bool.unionize_to_file
  $filedb={id} 
  $tiles={id} 
  [out={path}] 
  [thrnum={nt},{np}] 
  [format=oasis] 
  [sliver={value},{units}] 
  [butting={overlap},{units}] 
  [nostripes] 
  [sizing={x},{y},{units}] 
  [maxvert={4 <= n <= 8190}] 
  [layers={string}] 
  [cell={name}] 
  [top={name}] 
  [lout={l}:{d}]

• Generate a file on disk from the union of all data from a view of a database

• $filedb={id} is the name of the database to serve as a the source

• $tiles={id} is the name of a set of tiles that will serve as both the partition as well as ROI for the data to be unionized

• out={path} if specified is the output file path. If omitted, the unionized data will not be written to disk

• thrnum={nt},{np} determines the multi-threading. {nt} is the no. tiles to be processed in parallel while {np} is the no. threads per tile for boolean

• format=oasis if specfied will generate an oasis file. Default: GDSII (if the output path is specified)

• sliver= specifies the sliver {value} in {units} (m, cm, mm, um, nm, mils, inch)

• butting= splits polygons with holes into butting polygons with the specified overlap {value} in {units}

• nostripes if specified removes partition lines within a tile

• sizing= if specified applies non-isometric sizing along X and Y in the specified {units}

• maxvert= is the maximum no. vertices for any polygon (default: 8190)

• layers= is the layers of interest (default: ALL)

• cell= is the view cell (default: deepest top cell of the file)

• top= if specified would be the name of the output top cell (default: TOP)

• lout={l}:{d} specified the layer:datatype for the output data

QisMExplCounter commands

See qismexplcounter.h for the relevant C++ API

explcounter.count

xxxxxxxxxx
explcounter.count
  $filedb={filedb_id}
  [cell={cellname}] 
  [layers={layer_list}] 

• Get polygon and vertex counts for a design

• {filedb_id} is name of a variable associated with the file database to be used

• {cellname} if specified is the view cell to be used. Default : default top cell

• {layer_list} is a comma-separated list of layer or layer:datatype numbers to be treated as a single group. Default: ALL available layers

explcounter.break_window_by_crossing

xxxxxxxxxx
explcounter.break_window_by_crossing
  $filedb={filedb_id}
  [gds={output_gds_path}]
  [cell={cellname}] 
  [layers={layer_list}] 
  [window={minx},{miny},{maxx},{maxy}]
  [maxd={max_quad_depth}]
  [maxv={max_vertices_per_quad}]
  [limitpct={percentage}]
  [lout={output_layer}]
  [&var={set_id}]
  [minv={0 | 1}]
  [thrnum={n}]
  [expand={uu}]
  [shuffle]

• Break a region of interest into tiles based on the no. vertices crossing a region of the ROI

• Uses a quad-tree based algorithm to compute density map. Suitable for cases where the no. intersections between polygons outweigh the no. vertices

• {filedb_id} is name of a variable associated with the file database to be used

• {cellname} if specified is the view cell to be used. Default : default top cell

• {layer_list} is a comma-separated list of layer or layer:datatype numbers to be treated as a single group. Default: ALL available layers

• window if specified represents the region of interest (default: extents of the view cell)

• {output_gds_path} if specified, generates a (GDSII) file at the specified path illustrating the newly computed windows

• {max_quad_depth} if specified controls the resolution of the density map by setting the max. depth of the quad-tree. Increasing the depth increases the resolution of the density map (default: 8)

• {max_vertices_per_quad} if specified controls the breaking up of quads based on the max. no. vertices per leaf quad (default: 1024). Increasing the max. no. vertices reduces the resolution of the density map

• {percentage} if specified limits the no. output tiles to the specified percentage of the original no. computed tiles (default: 100)

• {output_layer} if specified writes the tiles to {output_layer}:0 in the output file

• {set_id} if specified, is name of a variable associated with a newly created list of tiles. It MUST be eventually destroyed using explcounter.delete_windows

• {min_vert} is the minimum no. vertices to keep the quad. Use 1 or 0

• {thrnum} is the num. threads to be used (default: no. cpus)

• expand={uu} if specified, expands (enlarges or shrinks) each tile by the specified amount in user-units on each side

• If shuffle is specified, all the tiles will be randomly shuffled

explcounter.break_window_by_vertnum

xxxxxxxxxx
explcounter.break_window_by_vertnum
  $filedb={filedb_id}
  maxvert={max_vert_per_window}
  [cell={cellname}] 
  [layers={layer_list}] 
  [$tiles={window_set_id}]
  [thrnum={n_threads}] 
  [gds={output_gds_path}] 
  [minvert={min_vert_per_window}]
  [&var={new_set_id}]
  [expand={uu}]
  [shuffle]

• Break a region of interest into tiles based on the no. vertices contained within (a.k.a density map of the ROI)

• Equivalent to QisMExplCounterV3::Break_window_by_vertnum in qismexplcounter.h

• {filedb_id} is name of a variable associated with the file database to be used

• {max_vert_per_window} is the max. no. vertices contained in any of the computed tiles. Larger windows will be broken up into smaller ones until this criteria is satisfied

• {cellname} if specified is the view cell to be used. Default : default top cell

• {layer_list} is a comma-separated list of layer or layer:datatype numbers to be treated as a single group. Default: ALL available layers

• {window_set_id} if specified is name of a variable associated with a list of windows that represents a pre-computed tiles over which this computation will be performed. Use this to:

  • Perform computation only over select areas of the view

  • Control the aspect ratio of the computed tiles

  • Save time by breaking up the ROI into smaller tiles

• {n_threads} if specified is the no. threads to be used to perform this operation. Default: 0 i.e no. cpus in the system. If {n_threads} > 1, the input ROI(s) may be further split into smaller tiles for better multi-threaded load sharing

• {output_gds_path} if specified generates a .sf (GDSII) file at the specified path illustrating the newly computed windows

• {min_vert_per_window} is the min. no. vertices per window. Windows smaller than this count will be dropped from the output

• {set_id} if specified, is name of a variable associated with a newly created list of tiles. It MUST be eventually destroyed using explcounter.delete_windows

• expand={uu} if specified, expands (enlarges or shrinks) each tile by the specified amount in user-units on each side

• If shuffle is specified, all the tiles will be randomly shuffled

explcounter.delete_windows

xxxxxxxxxx
explcounter.delete_windows $windows={set_id}

• Destroy a set of windows allocated by the explcounter commands

• {set_id} is name of a variable associated with the list of windows to be destroyed

QisMWindowProbe commands

See qismwindowprobe.h for relevant C++ API

probe.window

xxxxxxxxxx
probe.window 
  $filedb={filedb_id} 
  window={minx},{miny},{maxx},{maxy} 
  [cell={cellname}]
  [layers={layer_list}]
  [nesting={nesting_level}]

• Probe a rectangular window to collect statistical information corresponding to an extensible list of parameters

• Makes use of QisMWindowProbeObj class in qismwindowprobe.h

• {filedb_id} represents name of a variable associated with the file database to be probed

• {minx}..{maxy} are the extents of the window to be probed

• {cellname} if used represents the view cell (otherwise, the default top cell is used)

• {layer_list} if used is a comma separated list of layer[:datatype] or "ALL". Default is ALL layers

• {nesting_level} if used is the max. nesting level to probe up to. Default is 0 (all nesting levels)

• At the moment, the following parameters are probed and printed:

  • Polygon extents : Cumulative extents of all the polygons that cross the specified view

  • Polygon counts : Total number of polygons that cross the specified view

  • Polygon vertex counts : Sum of vertices of all polygons that cross the view

QisMCADWriter Commands

cadwriter.open

xxxxxxxxxx
cadwriter.open 
  &writer={writer_id}
  grid_m={grid_in_meters}
  units_m={units_in_meters}
  path={output_file_path}
  [format={GDS|OAS}]

• Open a GDSII/OASIS file composer

• {writer_id} is name of a variable to be associated with the writer object

• {grid_in_meters} is the file resolution expressed in meters

• {units_in_meters} is the file units expressed in meters

• {output_file_path} is the path (dir + name + extension) where the output file will be created

• format if specified determines the file format (default : GDS)

• Every open MUST have a corresponding close

cadwriter.begin_cell

xxxxxxxxxx
cadwriter.begin_cell $writer={writer_id} name={cellname}

• Open a cell definition

• {writer_id} is name of a variable associated with an open writer object

• {cellname} is name of the cell to be defined

• Every begin_cell MUST have a corresponding end_cell

cadwriter.create_block

xxxxxxxxxx
cadwriter.create_block
  $writer={writer_id} 
  &block={block_id}

• Create a new block of data to write geometries, texts and cell references

• The block format (GDSII/OASIS...) and the grid/units are inherited from the parent writer

• A cell can have multiple blocks. However, a block cannot enclose a cell definition

• The parent writer itself contains a single block called the File block that represents the main stream

• While a block can be composed independently of the main stream, it MUST be eventually comitted to become part of the main stream and be destroyed

cadwriter.box

xxxxxxxxxx
cadwriter.box
  $writer={writer_id} | $block={block_id}
  {box={minx},{miny},{maxx},{maxy} | center={x},{y},{width},{height}}
  [layer={layer}:{datatype}]
  [repeat=NM,{n},{ndx},{ndy},{m},{mdx},{mdy} | repeat=PTS,{dx0},{dy0}..{dxn},{dyn}]

• Write a rectangular box to the current cell

• {writer_id} is name of a variable associated with an open writer object

• {block_id} is name of a variable associated with an open block object

• {minx}..{miny} are the min-max extents of the box in file units

• {x},{y} is the center point and {width},{height} are the box dimensions in file units

• {layer}:{datatype} if specified is the layer to be associated with the box (default: 0:0)

• Repetitions (optional) can be specified in two forms:

  • Regular repetition is specified using the number of instances {n} in one direction with offsets {ndx},{ndy} and {m} instances in an orthogonal direction with offsets {mdx},{mdy}.

  • Arbitrary repetition is specified using a set of deltas {dx},{dy} from the first instance

cadwriter.text

xxxxxxxxxx
cadwriter.text
  $writer={writer_id} | $block={block_id}
  text={string}
  pos={x},{y}
  [layer={layer}:{datatype}]
  [repeat=NM,{n},{ndx},{ndy},{m},{mdx},{mdy} | repeat=PTS,{dx0},{dy0}..{dxn},{dyn}]

• Write the text {string} to the current cell

• {writer_id} is name of a variable associated with an open writer object

• {block_id} is name of a variable associated with an open block object

• {x},{y} is the insertion point in file units

• {layer}:{datatype} if specified is the layer to be associated with the text (default: 0:0)

• Repetitions (optional) can be specified in two forms:

  • Regular repetition is specified using the number of instances {n} in one direction with offsets {ndx},{ndy} and {m} instances in an orthogonal direction with offsets {mdx},{mdy}.

  • Arbitrary repetition is specified using a set of deltas {dx},{dy} from the first instance

cadwriter.box_set

xxxxxxxxxx
cadwriter.box_set
  $writer={writer_id} | $block={block_id}
  $set={box_set_id}
  [layer={layer}:{datatype}]

• Write a set of rectangular boxes to the current cell

• {writer_id} is name of a variable associated with an open writer object

• {block_id} is name of a variable associated with an open block object

• {box_set_id} is name of a variable associated with the set of boxes to be written

• {layer}:{datatype} if specified is the layer to be associated with the box (default: 0:0)

cadwriter.bstore

xxxxxxxxxx
cadwriter.bstore
  $writer={writer_id} | $block={block_id}
  $bin={bstore_id}

• Write a set of boundaries to the current cell

• {writer_id} is name of a variable associated with an open writer object

• {block_id} is name of a variable associated with an open block object

• {bstore_id} is name of a variable associated with the set of boundaries to be written

cadwriter.boundary

xxxxxxxxxx
cadwriter.boundary
  $writer={writer_id} | $block={block_id}
  {{deltas={dx0},{dy0},{dx1},{dy1}[,{dx},{dy}]* pos={x},{y}} | xy={x1},{y1}..{xn},{yn}}
  [repeat=NM,{n},{ndx},{ndy},{m},{mdx},{mdy} | repeat=PTS,{dx0},{dy0}..{dxn},{dyn}]
  [layer={layer}:{datatype}]

• Write a boundary to the current cell (with or without repetitions)

• All co-ordinates are in file units

• {writer_id} is name of a variable associated with an open writer object

• {block_id} is name of a variable associated with an open block object

• deltas is a list of offsets from the boundary origin 0,0 that form the vertices of the boundary. There MUST be at least two deltas to form a boundary (with 4 vertices). When specifying the deltas, the origin 0,0 and the last delta (to close the boundary) are implied and therefore omitted. e.g deltas=100,0,0,100,-100,0 defines a square of length 100.

• Alongside deltas, pos is the location where the first instance of the boundary is to be placed

• Alternately, one can specify the co-ordinates of the boundary using an x,y list xy=

• {layer}:{datatype} if specified is the layer to be associated with the box (default: 0:0)

• Repetitions (optional) can be specified in two forms:

  • Regular repetition is specified using the number of instances {n} in one direction with offsets {ndx},{ndy} and {m} instances in an orthogonal direction with offsets {mdx},{mdy}.

  • Arbitrary repetition is specified using a set of deltas {dx},{dy} from the first instance

cadwriter.path

xxxxxxxxxx
cadwriter.path
  $writer={writer_id} | $block={block_id}
  {{deltas={dx0},{dy0},{dx1},{dy1}[,{dx},{dy}]* pos={x},{y}} | xy={x1},{y1}..{xn},{yn}}
  width={path_width}
  [type={FLUSH | HALF | ROUND}]
  [repeat=NM,{n},{ndx},{ndy},{m},{mdx},{mdy} | repeat=PTS,{dx0},{dy0}..{dxn},{dyn}]
  [layer={layer}:{datatype}]

• Write a path to the current cell (with or without repetitions)

• All co-ordinates are in file units

• {writer_id} is name of a variable associated with an open writer object

• {block_id} is name of a variable associated with an open block object

• deltas is a list of offsets from the path origin 0,0 that form the vertices of the path. There MUST be at least one delta to form a path (with 2 vertices). When specifying the deltas, the origin 0,0 is implied and therefore omitted. e.g deltas=100,0 defines a one-segment horizontal path of length 100 units.

• Alongside deltas, pos is the location where the first instance of the boundary is to be placed

• Alternately, one can specify the co-ordinates of the path using an x,y list xy=

• {path_width} MUST be specified (> 0.0)

• {layer}:{datatype} if specified is the layer to be associated with the box (default: 0:0)

• type if specified represents the path type. Default: FLUSH

• Repetitions (optional) can be specified in two forms:

  • Regular repetition is specified using the number of instances {n} in one direction with offsets {ndx},{ndy} and {m} instances in an orthogonal direction with offsets {mdx},{mdy}.

  • Arbitrary repetition is specified using a set of deltas {dx},{dy} from the first instance

cadwriter.circle

xxxxxxxxxx
cadwriter.circle
  $writer={writer_id} | $block={block_id}
  circle={x},{y},{radius},{arcres},{arcsag}
  [repeat=NM,{n},{ndx},{ndy},{m},{mdx},{mdy} | repeat=PTS,{dx0},{dy0}..{dxn},{dyn}]
  [layer={layer}:{datatype}]