Using NetMiner Script

1
 1. Introduction

2
Using NetMiner Script

Copyright and Trademarks

Using NetMiner Script

Version 4.4

Copyright 2000-2018 by Cyram Inc.

Companies, names and data used in examples herein are fictitious unless otherwise noted.
All Rights Reserved. No part of this publication may be reproduced, stored in a retrieval system, or
transmitted, in any form or by any means, electronic, mechanical, photocopying, recording, or
otherwise, without the prior written permission of Cyram Inc.

The information in this publication is provided for information only and is subject to change without
notice. Cyram Inc. assume no responsibility or liability for any loss or damage that may arise from the
use of any information in this publication. The software described in this book is furnished under
license and may only be used or copied in accordance with the terms of that license.

NetMiner is a registered trademark of Cyram Inc. CYRAM and CYRAM logo are registered
trademarks of Cyram Inc.

Cyram Inc.
#904, U-Space 2B, 670, Daewangpangyo-ro, Bundang-gu, Seongnam-si, Gyeonggi-do, 13494,
South Korea
Tel: +82-31-739-8352
Fax: +82-31-739-8354

Electronic access: http://www.netminer.com/

How to reference NetMiner 4

In order to reference NetMiner 4, please employ the following bold-faced reference, which is also
found at NetMiner Menu: “Help >> About NetMiner 4”.

Cyram (2018). NetMiner 4.4. Seoul: Cyram Inc.

Technical Support

The NetMiner Help file will guide you to use NetMiner 4. Simply press F1 function key or use
3
 1. Introduction

NetMiner menu bar for triggering Help feature.

Cyram is committed to provide a reliable, high-quality, yet easy-to-use product. If you have any
problem of installing or using NetMiner, please contact us by mail, phone and fax or preferably by
email and World Wide Web.

Cyram Inc.
#904, U-Space 2B, 670, Daewangpangyo-ro, Bundang-gu, Seongnam-si, Gyeonggi-do, 13494,
South Korea
Tel: +82-31-739-8352
Fax: +82-31-739-8354
Email: netminer@cyram.com Web: http://www.netminer.com/

When reporting a problem on NetMiner, please include the following information:

 your name and e-mail address
 version number of NetMiner program
 your hardware and software configuration. (ex. O/S, JRE version, RAM, CPU, etc.)
 a description of steps to reproduce the problem

4
Using NetMiner Script

Contents

1. INTRODUCTION ....................................................................................................... 9

1.1 WHAT IS NETMINER SCRIPT?........................................................................................................ 9

1.1.1 NetMiner Script....................................................................................................................... 9
1.1.2 Benefits of NetMiner Script .................................................................................................. 9
1.1.2 What differentiates NetMiner Script? .............................................................................. 10
1.2 INSTALLATION ................................................................................................................................ 11
1.2.1 Installing the NetMiner 4 package ................................................................................... 11
1.2.2 Using scripts in NetMiner 3 ............................................................................................... 11
1.2.3 Entering NetMiner Script package license key ............................................................. 11
1.3 STARTING SCRIPT WORKBENCH ................................................................................................. 12

2 NETMINER SCRIPTING ENVIRONMENT: SCRIPT WORKBENCH ................. 13

2.1 OVERVIEW ....................................................................................................................................... 13

2.1.1 Program window .................................................................................................................. 13
2.1.2 Structure of the main menu ................................................................................................ 14
2.2 SPECIAL FEATURES .......................................................................................................................... 16
2.2.1 Edit ........................................................................................................................................... 16
2.2.2 Script generator .................................................................................................................... 21
2.2.3 Running ................................................................................................................................... 21
2.2.4 View.......................................................................................................................................... 22

3. USING NETMINER SCRIPT FUNCTIONS ............................................................. 36

3.1 NETMINER SCRIPT FUNCTION STRUCTURE AND FUNCTION CALLS ........................................ 36

3.1.1 NetMiner script function structure ................................................................................... 36
3.1.2 Calling NetMiner Script functions ................................................................................... 37
3.2 ARGUMENTS AND RETURN VALUE OF NETMINER SCRIPT FUNCTIONS ................................. 40
3.2.1 Arguments to NetMiner Script functions ......................................................................... 40
3.2.2 NetMiner Script function return values ........................................................................... 41
3.2.3 Return value data types ....................................................................................................... 42

5
 1. Introduction

4. USING NETMINER SCRIPT .................................................................................... 44

4.1 DATA PROCESSING ......................................................................................................................... 44

4.1.1 Creating NetMiner data sets .............................................................................................. 44
4.1.2 Managing data sets .............................................................................................................. 60
4.2 USING NETMINER ANALYSIS SESSION ....................................................................................... 66
4.2.1 Types of analysis sessions ................................................................................................... 66
4.2.2 Creating analysis session scripts and their make-up ................................................... 70
4.2.3 Managing analysis sessions ............................................................................................... 75
4.3 POST PROCESSING OF NETMINER ANALYSIS REPORT .............................................................. 81
4.4 USING QUERY SETS ........................................................................................................................ 98
4.4.1 Creating and writing query sets ........................................................................................ 98
4.4.2 Using the written query set ................................................................................................ 99

5. SCRIPTING WITH MATRIX DATA ..................................................................... 102

5.1 CHARACTERISTICS OF MATRIX DATA ...................................................................................... 102

5.1.1 Output form of matrix data ............................................................................................. 102
5.1.2 Matrix data representation .............................................................................................. 103
5.2 CREATING MATRIX DATA .......................................................................................................... 103
5.2.1 Making new matrix data .................................................................................................. 103
5.2.2 Getting NetMiner data sets ............................................................................................. 106
5.2.3 Exporting to NetMiner data sets .................................................................................... 109
5.3 ..................................................................................................................... MATRIX DATA ANALYSIS
............................................................................................................................................................... 111
5.3.1 Matrix data basic information........................................................................................ 111
5.3.2 Matrix transformations and operations ....................................................................... 115
5.3.3 Example of analysis using matrix data ........................................................................ 117

6. USING PYTHON .................................................................................................... 122

6.1 PYTHON’S CONDITIONALS AND LOOPS................................................................................... 122

6.1.1 Conditionals........................................................................................................................ 122
6.1.2 Loops .................................................................................................................................... 124
6.1.3 Usages in NetMiner Script .............................................................................................. 127
6.2 PYTHON FUNCTION ..................................................................................................................... 132

6
Using NetMiner Script

6.2.1 Function definition ............................................................................................................ 132

6.2.2 Calling functions and returning a value ...................................................................... 133
6.3 USING EXTERNAL PYTHON MODULES .................................................................................... 134
6.3.1 Calling external Python modules .................................................................................. 134
6.3.2 Using functions of external modules ............................................................................. 134

7 ADVANCED USING NETMINER SCRIPT ............................................................ 136

7.1 USING BASIC TOOLS OF NETMINER ........................................................................................ 136

7.1.1 Using dialog boxes ............................................................................................................ 136
7.1.2 Status dialog box ............................................................................................................... 141
7.1.3 Opening HTML documents ............................................................................................. 142
7.2 CALLING NETMINER SCRIPTS USING EXTERNAL SCRIPTING LANGUAGES ........................... 143
7.2.1 Running NetMiner scripts in the DOS prompt ........................................................... 144
7.2.2 Linking with external scripts .......................................................................................... 144
7.3 PLUG-IN ........................................................................................................................................ 151
7.3.1 What is a plug-in? ............................................................................................................. 151
7.3.2 Creating a plug-in file ...................................................................................................... 151
7.3.3 Registering and running plug-in files ........................................................................... 152

7
 1. Introduction

8
Using NetMiner Script

1. Introduction
1.1 What is NetMiner Script?

1.1.1 NetMiner Script

Based on the Python syntax, NetMiner Script provides an environment for performing
analysis and visualization with respect to various aspects of NetMiner. Execution in
NetMiner Script is exactly the same as execution through the GUI not only in terms of
results but in terms of process as well. Therefore by looking at a script the user can easily
understand what specific task is to be performed in the overall process. NetMiner Script
supports the Python language constructs and modules by default and provides various
functions for network analysis and visualization. With NetMiner Script you can automate
analysis/visualization processes that have to be performed repeatedly as well as perform
condition-based analysis. In addition, external modules written purely in Python can be used
for application in a broader field. The Script Workbench is GUI program for more efficient
use of NetMiner scripts. The script generator of the Script Workbench allows the use of user
interfaces of control panels of an existing NetMiner session so that complex scripts of
analysis and visualization can be more easily written. The Script Workbench provides a
guide box for each NetMiner function as well as a list of functions.

1.1.2 Benefits of NetMiner Script

1) Most features of NetMiner can be performed using a script rather than having to click
with mouse so that complicated series of commands can be stored in scripts and executed
repeatedly without additional work.

2) Analysis flows, such as loops and conditional branching can be controlled by the user in a
flexible way.

3) Various existing math and statistics modules written in Python can be imported without
modification for use, and ordinary data structures provided by Python can be defined.

9
 1. Introduction

4) Simple algorithms can be written by the user in order to be used in combination with
NetMiner features. In addition, user-written files can be added to the NetMiner menu to be
used like internal processes which can be shared with other NetMiner users as well.

1.1.2 What differentiates NetMiner Script?

1) Python-based scripting

Most analysis software packages with scripting feature use their own scripting language.
This requires the user to learn the language, which limits the user base and consequently it’s
not easy to find related material either.

NetMiner Script uses Python, a programming language distributed free of charge and
widely used all over the world. Non-computer majors often get cold feet when they hear the
word programming language, but Python is especially so easy that even complete beginners
who have little knowledge of programming can learn and use it without difficulties,
provided they put in some effort. Also, Python has a wide user base, which means there are
lots of easily-obtainable materials available on the Web for learning Python. To use analysis
algorithms involving math, statistics or data mining for example, you go to a place on the
Web where Python codes written by other people are shared and then, you can download
and use the pertinent source codes. This is especially helpful for Python beginners.
Therefore, learning NetMiner Script is not simply learning another script language – it is
also a gateway to help you to enter the vast world of Python.

2) WYSIWYG scripting

NetMiner is a GUI program and NetMiner Script is a GUI-based script, which means all
tasks executed through the GUI can be controlled by the use of scripts. Although NetMiner
is not the only analysis software that uses both GUI and script, it does differentiate itself
from others in the following respects: Generally, in the case of analysis software that uses
both of the interfaces, although the results of execution in GUI mode and scripting mode are
the same, their processes are not exactly the same. In most of the analysis programs, scripts
control data and processes in a way unrelated to the GUI. In contrast, the way of writing

10
Using NetMiner Script

NetMiner scripts, is the same. Therefore, while writing a NetMiner Script, the user can see
in their mind’s eye which task is corresponding to the execution in GUI. To make it more
convenient in generating scripts, NetMiner enables users to utilize the script generator in the
Script Workbench. By using it, scripts can be automatically generated according to items
selected through the GUI, which helps to avoid the hassle of manual coding in each process.
Because of this, NetMiner Script can be called a WYSIWYG (What You See Is What You
Get) way of scripting.

1.2 Installation

To use NetMiner Script, the following installation procedures are needed.

1.2.1 Installing the NetMiner 4 package

Refer to the installation guide included in the CD for the installation. The installation
guide can also be downloaded on the Web site, at the following address:

http://www.netminer.com>>Download>>Documents>>Installation_Guide.pdf

1.2.2 Using scripts in NetMiner 3

To use Script Workbench, NetMiner 4.0 or above is required. Therefore you have to use
NetMiner 4.0 in order to use Script Workbench. If you purchased NetMiner 3, you can get a
special discount when purchasing NetMiner 4. Please visit the Web site for details.

1.2.3 Entering NetMiner Script package license key

If you registered NetMiner 4 with a license key that includes the scripting package in the
initial installation process of NetMiner 4, you can immediately begin scripting. If you didn’t
register it with a license key that includes the scripting package, however, you can click
‘Help >> Register…’ in the main menu of NetMiner 4 and register it with a new license key
that allows for scripting. Once ‘Tools >> Script Workbench’ is activated, you are ready to
go to begin using NetMiner Script.
11
 1. Introduction

1.3 Starting Script Workbench

Step 1: Double click on the NetMiner 4 icon to run NetMiner 4, or execute the file
‘NetMiner 4.exe’ located in the NetMiner 4 installation folder.

Step 2: Click on ‘Tools >> Script Workbench’ in the main menu bar of NetMiner 4.

Step 3: The following Script Workbench window will come up.

12
Using NetMiner Script

2 NetMiner scripting environment: Script Workbench

2.1 Overview

2.1.1 Program window

1) Main menu

The main menu has various menus needed for writing scripts.

2) Tool Bar

The tool bar contains shortcut icons, including:

‘New’ ‘Run’

‘Open’ ‘Run Selected Line(s)’

‘Save’ ‘Script Generator’

13
 2. NetMiner scripting environment: Script Workbench

3) Edit window

The edit window is the place where you write a script. It provides convenient features
such as autocompletion, line indication, and text color differentiation which enable
programming more efficiently.

4) Log window

The log window shows the results of running a script performed by ‘print’ lines. When an
error occurs, it shows the cause and location where error occurs.

5) Variable window

The variable window shows declared variables in the script analysis process, user-defined
functions and contents.

2.1.2 Structure of the main menu

The menu of Script Workbench is composed of File, Edit, View, Script, and Plug-in.

1) File

Description Shortcut key

New Add a new tab to the edit window. Ctrl + N

Open Open a script file (.py) and show the contents in the edit window. Ctrl + O

Save Save the script being edited in the edit window. Ctrl + S

Save As Save the script being edited in the edit window as a new file.

Close Tab Close the currently active tab in the edit window. Ctrl + F4

Close All Tabs Close all tabs of the edit window.

Close Quit Script Workbench.

2) Edit

14
Using NetMiner Script

Description Shortcut key

Undo Undo the last action. Ctrl + Z

Redo Redo the undone action. Ctrl + Y

Cut Cut the selected area. Ctrl + X

Copy Copy the selected area. Ctrl + C

Paste Paste the cut/copied area. Ctrl + V

Delete Delete the selected area. Del

Select All Select the entire content of the script being edited. Ctrl + A

Toggle Comment Treat the selected area as a comment. If the selected area is a Ctrl + /
comment, cancel that status.

Shift Right Shift the selected area to the right one step. Tab

Shift Left Shift the selected area to the left one step. Shift + Tab

Find/Replace Find a specific word and replace it with another word. Ctrl + F

Editor Fonts… Change the font used for the script.

3) View

Description Shortcut key

Line Number Display line number in the edit window. Ctrl + I

Logs Open up a log window.

Variables Open up a Variable window.

4) Script

Description Shortcut key

Run Run the entire script. Ctrl + R

Run Selected Lines Run the line where the cursor currently is or run the Ctrl + L
selected area.

Script Generator Run the script generator. Ctrl + E

15
 2. NetMiner scripting environment: Script Workbench

Content Assist Auto-complete the function name. Ctrl + Space

Context Show function arguments. It works only when the cursor Ctrl + Shift +
Information is inside the parenthesis. Space

Go to the script where the function is defined, the

Open Declaration F3
function being where the cursor is located.

If checked, NetMiner window is not switched every time

Silent Mode there is an output while the script runs but waits until the
final output comes out.

2.2 Special features

2.2.1 Edit

1) Autocompletion

NetMiner Script not only supports Python but provides functions unique to NetMiner
Script. Script Workbench provide autocompletion for these functions. In the menu, select
‘Script >> Content Assist’ or press the shortcut key Ctrl+Space to bring up a list of classes
and functions for autocompletion.

NetMiner Script provides classes and functions unique to NetMiner as well as classes and
sub functions for processing matrix data, which can be used by entering ‘.’ after the class or
function name. Autocompletion feature is provided as well for these, as shown below.

16
Using NetMiner Script

In addition, if the cursor is held over a function unique to NetMiner Script, the description
of the function is shown, in addition to its arguments.

Finally, when loading a file or exporting it, the file path can be auto-completed through
the following method.
17
 2. NetMiner scripting environment: Script Workbench

Step 1: Go to the folder where the file is, copy the file or select the file and press Ctrl+C.

Step 2: Place the cursor where you want write the path in the Script Workbench edit
window. Click ‘Edit >> Paste’ or press Ctrl+V to autocomplete the path as shown below.

2) Script color differentiation

The color of the content of a script is determined according to the following rules.

Color Item

Green Strings

Blue Control statements (for, if, elif, else, while, continue, break), logical operators (and, or),
logic values (None, True, False), user-defined functions (def)

Brown Numbers

Gray Comments

Black All others

18
Using NetMiner Script

3) Line number display

Script Workbench provides a feature whether the line numbers can be shown or hidden. If
shown, they are shown in the leftmost side of the edit window, as shown below. The feature
can be turned on and off by clicking ‘View >> Line Number’ or pressing the shortcut key
Ctrl+I.

4) Current cursor position display

This feature shows where the cursor is, in terms of line and column. It is shown in the
lower right corner of Script Workbench.

19
 2. NetMiner scripting environment: Script Workbench

5) Right click

If you right click with the mouse in the edit window or do it with a portion of the script
selected, the following feature can be used in more convenient way.

6) Font

You can change the font used in Script Workbench by clicking ‘Edit >> Editor Font’.

20
Using NetMiner Script

2.2.2 Script generator

The script generator supports writing of scripts for analysis modules. All modules are
supported via the main menu of NetMiner, including Transform, Analyze, Statistics,
Visualize, and Chart.

Select an analysis module and then options in the user interface that is the same as the
control panel to generate automatically the corresponding script. The script generator can be
run by clicking 'Script >> Script Generator', which can be run while a project is open.

Under the script generator, analysis session scripts can be very easily written by using the
same option of UI as the one in NetMiner.

2.2.3 Running

21
 2. NetMiner scripting environment: Script Workbench

In Script Workbench, scripts that use Python language features and NetMiner script
functions can be run immediately without a special compile command. The results of
execution are displayed in the log window and the NetMiner process results panel. .

After writing a script, click ‘Script >> Run’ or press the shortcut key Ctrl+R to run it.

In addition, you can execute only selected lines of a script by selecting an area of the
script and clicking on ‘Script >> Run Selected Lines’ or by pressing the shortcut key Ctrl+L.
In addition, you can right click on the selected area to bring up a pop-up menu to do this.

2.2.4 View

The log window shows the results of running a script while the Variable window shows
variable information.

22
Using NetMiner Script

1) Logs window

As shown below, results of various computations of data are shown by using ‘print’
statements.

When errors occurred after running the script, the cause and location where they occurred
are shown as below.

23
 2. NetMiner scripting environment: Script Workbench

If you want to delete the contents in the log window, click on the ‘Clear Screen’ button at
the bottom of the log window.

2) Variables window

Information of user-defined variables and functions is shown after executing the script, in
terms of Name, Category, Type, and Value/Info, as shown below.

For Value/Info, if the data type is not a single value but a row or list data, it is shown in
the form of buttons in a table. The entities in the table are identified by their row and column.
When a button is clicked, data values are shown in a new window, as is done below.

24
Using NetMiner Script

If you want to delete all variable information created so far, click on the ‘Delete All
Variables’ button located at the bottom of the Variable window.

※How are different data types shown

(1) integer
-Variable window

-Value/Info
The value is displayed.

(2) float
-Variable window

-Value/Info
The value is displayed.

25
 2. NetMiner scripting environment: Script Workbench

(3) complex
-Variable window

-Value/Info
The value is displayed.

(4) long
-Variable window

-Value/Info
The value is displayed.

(5) boolean
-Variable window

-Value/Info
The value is displayed.

(6) string
-Variable window

-Value/Info
The value is displayed.

26
Using NetMiner Script

(7) list
-Variable window

-Value/Info (click)

(8) tuple
-Variable window

-Value/Info (click)

(9) dictionary
-Variable window

-Value/Info (click)

27
 2. NetMiner scripting environment: Script Workbench

(10) set
-Variable window

-Value/Info (click)

(11) file
-Variable window

-Value/Info (click)

[Show the file path and whether it’s a file for reading or for writing]

(12) function
-Variable window

28
Using NetMiner Script

-Value/Info (click)

[The cursor is moved to the function in the script edit window]

(13) classObject, instance, instanceMethod

-Variable window

-Value/Info (click)

[The cursor is moved to the class in the script edit window]

(14) module
-Variable window

29
 2. NetMiner scripting environment: Script Workbench

-Value/Info (click)

[The Python file is opened]

(15) session, mainReport, tableReport, mapReport, chartReport

-Variable window

-Value/Info (click)

30
Using NetMiner Script

[Switch to the report window]

[In the case of session, only the session tab is activiated]

(16) stringTable
-Variable window

-Value/Info (click)

31
 2. NetMiner scripting environment: Script Workbench

[Values of the table are shown]

(17) graphNode
-Variable window

-Value/Info (click)

[Labels are shown inside the parentheses]

(18) querySet
-Variable window

32
Using NetMiner Script

-Value/Info (click)

[The query statement in the query set is shown]

(19) importer, exporter

-Variable window

-Value/Info (click)

[File type, path, and NetMiner data name and data type to import are shown]

[File type, path, and NetMiner data and data type to export are shown]

(20) matrix
-Variable window

33
 2. NetMiner scripting environment: Script Workbench

-Value/Info (click)

(21) matrixIterator
-Variable window

-Value/Info (click)

[Data are shown in terms of row index, column index, and value]
(22) customDialog
-Variable window

-Value/Info (click)

34
Using NetMiner Script

(23) objectArray
-Variable window

-Value/Info (click)

[Most are in the form of object array when NetMiner data are loaded]

35
 3. Using NetMiner Script Function

3. Using NetMiner script functions

3.1 NetMiner script function structure and function calls

3.1.1 NetMiner script function structure

There are main function classes in which NetMiner script functions are put in. Specifically,
by a tree structure they are put into sub classes according to their type. Therefore, to use a
function, located in a leaf node, begin with the main function class and work your way down
through sub classes.

In the figure shown below, denotes a class while denotes a function. In NetMiner

Script, you run functions denoted by .

Basically, the structure of NetMiner script functions is as shown above. To use the
[getHtmlData] function in the above figure, you can write the script as shown below
according to the hierarchical structure.

session1 = _NM.Session.createSession('test')
mainReport = session1.getMainReport()
htmlData = mainReport.getHtmlData()

※ Warning: As seen here, keep in mind that data are returned by functions. However, it is
not possible to get a class itself as a return value, such as in ‘nm = _NM’ or ‘session1 =
_NM.Session’.

36
Using NetMiner Script

Tree structures for all NetMiner Script functions are shown in Appendix A.

3.1.2 Calling NetMiner Script functions

1) Basic data classes

The basic data classes are prefixed with an underscore (‘_’), denoting that they’re
the root classes.
There are three basic data classes, namely _NM, _MAT, _SYS.

_NM: Class that contains functions working with unique NetMiner data

_MAT: Class that contains functions working with matrix data

37
 3. Using NetMiner Script Function

_SYS: Class that contains functions controlling Script Workbench execution

2) Four basic types of function calls

(1) _BasicDataClass.SubClass.FunctionName() or DataClass.FunctionName()

Ex ) _ NM.Project.saveProject()
_NM.Dataset.getMainAttributeNames()
matrix.getRowSize()
※ Here, matrix is a data class created by _MAT.Create or _MAT.FromNM.

(2) _BasicDataClass.SubClass.FunctionName(arguments)
38
Using NetMiner Script

or
DataClass.FunctionName(arguments)

Ex ) NM.saveAsProject(r’c:\test.nmf’)
NM.deleteSession(‘session1’)

(3) variable = _BasicDataClass.SubClass.FunctionName()

or
variable = DataClass.FunctionName()

Ex ) workFileNames = NM.getCurrentWorkfileName()
session = NM.getFocusedSession()

(4) variable = _BasicDataClass.SubClass.FunctionName(arguments)

or
variable = DataClass.FunctionName(arguments)

Ex) attributeNames = NM.getSubAttributeNames(‘club’)

In NetMiner Script, you call functions contained by the basic data classes (_NM, _MAT,
_SYS) as shown above.
In addition, functions that have arguments must be provided with arguments, and when a
function has a return value, it must be put into a variable declared by the Python variable
naming convention.

39
 3. Using NetMiner Script Function

3.2 Arguments and return value of NetMiner Script functions

3.2.1 Arguments to NetMiner Script functions

Depending on the particular purpose of a function, it may or may not require arguments. If it
does require arguments, they must be provided in the correct type.

1) How to pass arguments

For functions that require arguments, arguments of appropriate type must be passed in,
inside the parenthesis.
_NM.Project.saveAsProject(r’c:\test.nmf’) _NM.Session.deleteSession(‘session1’)

This type of function yields different results according to the arguments passed in.

Most of the time, datatypes of arguments to NetMiner functions are string, integer, float, or
boolean. When passing in a string that contains a file path, etc., you have to be careful to
prefix the text with ‘r’. See as follows.
r’c:\example\test.dat’

When passing in multiple arguments, they have to be separated by a comma (,) and the
arguments have to be passed in the right order.
 Pass in a value for the noteSetName
_NM.Dataset.getSubNodeAttribute(‘Clubs’, ‘Name’) argument first and then a value for the
attName argument second.

If you don’t provide equivalent values for all arguments to function, an error will occur.

2) Arguments that can be omitted

Arguments to a function that are denoted by square brackets can be omitted. No problems
will occur in executing the function even if they’re omitted. This is because the arguments
denoted by square brackets have default values associated with them. When you don’t
specify a value, the default value will be used.

40
Using NetMiner Script

_SYS.Dialog.createCustomDialog( )  ‘Input Dialog’ is assigned to

title, while empty space (‘’) is
assigned to message.

That is, _SYS.Dialog.createCustomDialog( ) and

_SYS.Dialog.createCustomDialog(‘Input Dialog’, ‘’) is the same.

_SYS.Dialog.createCustomDialog(‘Good Title’, ‘This is..’ )  ‘Good Title’ is passed to title and

‘This is..’ is passed to message

3.2.2 NetMiner Script function return values

1) Functions with no return values

Ex ) _ NM.Project.saveAsProject(r’c:\test.nmf’)
_NM.Session.deleteSession(‘session1’)
_NM.Project.saveProject()

Most functions without return values usually perform some NetMiner operation.
For example, the function _NM.Project.saveProject( ) saves the current project. Because of
that, there is no need to get a return value as in ‘project = _NM.Project.saveProject( )’.
While doing ‘project = _NM.Project.saveProject( )’ will run, the variable project will get
‘NoneType’.

2) Functions with return values

Ex) workFileNames =_ NM.Dataset.getCurrentWorkfileName()

session = _NM.Session.getFocusedSession()
attributeNames = _NM.Dataset.getSubAttributeNames(‘club’)
nameList = _NM.Dataset.getMainAttributeNames( )

Functions that requires a return value are described at the basic form of variable name =
function() or variable name = function(arguments). Notice that, no errors occur even if
you don’t input a variable for getting the return value. In this case you only run a useless
41
 3. Using NetMiner Script Function

function because there is no variable specified to get the result.

For example, _NM.Dataset.getMainAttributeNames( ) returns the attribute name of the
main node. If you just call the function without specifying a variable for getting the return
value, you won’t get the result although the function runs.
Therefore you have to use a variable to get the result, such as ‘nameList =
_NM.Dataset.getMainAttributeNames( )’.
It’s also possible to use the return value directly as an input argument to something else or to
use it at the Python syntax. See as follows.
Ex) for name in _NM.Dataset.getMainAttributeNames():
print name

3.2.3 Return value data types

In NetMiner Script, there are three different datatypes for return values: Python datatypes,
NetMiner datatypes, and matrix datatypes.
For details on the datatypes, refer to Appendix B. In this section, we’ll briefly examine some
of the major types and forms of expression so as to get the return values.

1) Python datatypes

This is the datatypes in a general form of list, integer, decimal and Boolean as a return
value of NetMiner Script functions. There datatype can be used as argument or used in
combination with external Python modules.

<Commonly used Python datatypes in NetMiner Script >

Datatype Keyword Example
Integer int 1, 3, -5
Numbers
Float float 0.05, -1.54e-3
Boolean bool True, False
String str A, B, ABC
List list [1, 2, 3], ['A','B'], ['A', 3, '4']

For other datatypes, refer to Appendix B.

2) NetMiner datatypes
42
Using NetMiner Script

NetMiner datatypes are the one unique to NetMiner and separate from those of Python, and
accordingly values returned can have functions as well. There are seven main NetMiner
datatypes: Session for analysis; Report for dealing with analysis results; StringTable for
managing string tables; Import/Export for file input and output; GraphNode for managing
nodes in a graph; QuerySet for queries; CustomDialog for creating dialog boxes.
Datatype Displayed as Example
session = _NM.Session.createSession(Analyze >> Centralty
Session session >> Degree)
session = _NM.Session.openSession("Degree")
mainreport mainreport = session.getMainReport("[R] Main")
tablereport tablereport = session.getTableReport("[T] table")
Report
mapreport mapreport = session.getMapReport("[M] map")
chartreport chartreport = session.getChartReport("[C] chart")
String Table stringtable stringtable = tablereport.getStringTable( )
Graph Node graphnode graphnode = graphnode[ ][index]
Query Set queryset queryset = _NM.Query.createQuerySet('querySetName')
importer importer = _NM.Import.createTextImporter(r'c:\a.txt')
Import/Export
exporter exporter = _NM.Export.createTextExporter(r'c:\a.txt')
Custom Dialog customdialog customdialog = _SYS.Dialog.createCustomDialog( )

3) Matrix datatypes

This is a datatype that can be created manually in Matrix type or the one to be created after
NetMiner data is taken to. Matrix iterator is a type of list that contains not 0s but index or
element values.
Datatype Displayed as Output type
1.0 1.0 1.0
Matrix matrix 2.0 1.0 0.0
0.0 3.0 2.0
(0,0) - 1.000000
(1,1) - 1.000000
Matrix Iterator matrixiterator
(1,2) - 1.000000
(3,3) - 1.000000

43
 4. Using NetMiner Script

4. Using NetMiner Script

4.1 Data processing

4.1.1 Creating NetMiner data sets

1) Creating and opening projects

- Creating a project -

This section shows how to create a new project. It performs the same function as the one
selecting Blank Project in ‘File >> New >> Project’ of the NetMiner main menu.

Step 1: Write the following script.

_NM.Project.newProject();

UNMS_1.py

Step 2: Click on ‘Script >> Run’ or use the shortcut key (Ctrl+R) to run the script. If there is
a project already open, it will be deleted without warning and a blank project will be created
as follows.

- Opening a project
44
Using NetMiner Script

This section shows how to open a project file (*.nmf). It performs the same function as
‘File >> Open’ of the NetMiner main menu.

Step 1: To load a NetMiner file (.nmf), write the following script. In the example the file
“01.Org_Net_Tiny1.nmf” was used.

filePath = r'%UserProfile%SampleData\Cyram
Dataset\01.Org_Net_Tiny1\01.Org_Net_Tiny1.nmf'; #(1)
_NM.Project.openProject(filePath); #(2)

UNMS_2.py

(1): Enter a string for the path to the file to open. The ‘r’ in front of the character string is
used to treat characters such as ‘\’ literally.

(2): A function to open the project. This function gets an argument in a string that is
developed in(1).

Step 2: Click ‘Script >> Run’ or use the shortcut key (Ctrl+R) to run the script. Confirm that
the file '01.Org_Net_Tiny1.nmf' opens up.

※ To use such features as the script generator of Script Workbench, a project must be open
beforehand.

45
 4. Using NetMiner Script

※ If there is already a project open when opening a new project by Script, Notice that you
won’t be asked whether to save the existing project before opening the new project.

2) Creating and opening a project using the script generator

In Script Workbench, you can make a script by using the Script Generator to create a new
project or to open an existing project. This is especially useful when the path is complicated.

Step 1: Run the script generator in Script Workbench.

Step 2: Select a process under File in the script generator. New Project will generate a script
that creates a new project while Open Project will generate a script that opens an existing
one.

- New Project

Select File > New Project in the script generator. Opening a new project is unrelated to
creating a session, so Session Varible Name input window will be deactivated. Press OK to
generate the script, as follows.

46
Using NetMiner Script

- Open Project

In the script generator, select File > Open Project. Opening an existing project is also
unrelated to creating a session, so Session Variable Name input window will be deactivated.
Press OK to generate the script as follows.

In Open Project, the project file (*.nmf) to open is selected, so the Option window will be
open as shown above. You can select the file by clicking Browse.

Check that the path to the file is correct and press the OK button in the script generator
window. A script for opening a specific .nmf file will be automatically generated as follows.

3) Importing external data to NetMiner

47
 4. Using NetMiner Script

You can import external data by using NetMiner Script. It performs the same function as
is the case of ‘File >> Import’ in NetMiner. File types that can be imported are text files
(*.txt, *.csv) and Excel files (*.xls).

In this example, sample data of ‘01.Org_Net_Tiny1’ was used. If you installed NetMiner
4 with the default settings, you can find the sample data in the folder
'C:\Users\(Username)\NetMiner\SampleData'.

The process to write a script for importing external data is segmented roughly into three
parts.

- Creating an object for importing data -

To import data using a script, create an object for it. The created object includes functions
for setting options.

① Object for importing a text file

To create an object for importing text data (*.txt, *.csv), write the following script.

filePath = r'%UserProfile%SampleData\Cyram Dataset\01.Org_Net_Tiny1\

02.1-mode Network Data\00.Edge List\work interact_weighted.csv'; #(1)
importer = _NM.Import.createTextImporter(filePath); #(2)

(1): Enter the file path in string variable. Notice that ‘r’ is used to treat special characters
such as ‘\’ literally.

(2): Create an object for importing text data and assign it to ‘importer’. The arguments to the
function ‘createTextImporter’ are file path, line separator, and text qualifier. The file path is
where the data to import is located, and is a mandatory argument. The line separator is used
to specify a character by which to identify the end of each line is identified. When loading
a .csv file, comma (‘,’) is the default and when loading a .txt file, tab (‘\t’) is the default. The
text qualifier shows text data inside a specified character. By default (“ “) is used. The
separator and the text qualifier can be omitted. In this case, default values are used.

The arguments are the same as the options in ‘File >> import >> Text File…’ of NetMiner.

48
Using NetMiner Script

② Object for importing an Excel file

To create by scripting an object for importing Excel data (*.xls), write the following script.
Because *.xlsx is not supported, it must be converted to *.xls beforehand.

filePath = r'%UserProfile%SampleData\Cyram Dataset\01.Org_Net_Tiny1\

02.1-mode Network Data\00.Edge List\work interact_weighted.xls'; #(1)
importer = _NM.Importer.createExcelImporter(filePath); #(2)

(1): Key in string variables for the file path. Notice that ‘r’ is used to treat special characters
such as ‘\’ literally.

(2): Create an object for importing text data and assign it to ‘importer’. The arguments to the
function ‘createExcelImporter’ are file path and sheet name. The file path is the path where
the data to import is located, and is a mandatory argument. The sheet name is used to specify
the sheet to be imported from the Excel file. If the sheet name is omitted, the first sheet of
the Excel file is imported. The arguments are the same as the options in ‘File >> import >>
Excel File…’ of NetMiner.

49
 4. Using NetMiner Script

- Setting data import options -

After creating an import object, you can call its functions for setting the options.
As seen in 1), after creating an import object named ‘importer’, you can see a list of its
functions. The functions for setting the options are the same at the one in text file import
objects and Excel file import objects.

① Header

Before importing data, header options must be set. If they are not set, an error will occur
at data import. To set the header options, use the importer used in 1) and write the following
script.

importer.setHeaderOption(False, False); #(1)

(1): The function ‘setHeaderOption’ sets the header options for the importer. The arguments
indicate whether there is a row header and/or there is a column header, respectively. If the
data has a header, enter ‘True’; if it doesn’t, enter ‘False’. The ‘setHeaderOption’ function is
equivalent to the header options of ‘File >> import >> Text File…(or Excel File)’.

50
Using NetMiner Script

Notice that there are several cases that cause a row header or a column header to be
included or not. In case simple index not used as data are used in node set, edge list, or
linked list, and in case of matrix data that include labels, a row header is included. There is a
column header to be included in case there are node set attributes included or in case of
matrix data that include labels. The example below illustrates how header options set by
datatype.

[Example of header]

Data is in the form of node sets and contain attributes for each node; therefore the options
entered should be (False, True).

@Node Label Education Gender Job-ranking Department

John Master Degree Male 1 Finance
Thomas Bachelor Degree Male 5 Marketing
Anna HS Graduate Female 7 Marketing
James Bachelor Degree Male 5 Marketing
Peter Bachelor Degree Male 7 Sales
Mary Bachelor Degree Female 7 Sales
Michael Bachelor Degree Male 6 Marketing
David Bachelor Degree Male 3 Marketing

Data is in the form of edge lists and there are no index for both rows and columns, only
data; therefore the options entered should be (False, False).

John David 4
John Anthony 2

51
 4. Using NetMiner Script

John Steven 1
John Jessica 3
John Elizabeth 5
Thomas David 5
Thomas Anthony 1
Thomas Susan 3
Thomas Elizabeth 4
Anna John 3
Anna Anthony 4
Anna Ashley 1
Anna Jackson 2
James John 2

Data is in the form of matrix and include index; therefore the options entered should be
(True, True).

John Thomas Anna James Peter Mary

John 0 1 0 0 0 0
Thomas 1 0 0 0 0 0
Anna 0 0 0 0 0 0
James 0 0 0 0 0 0
Peter 0 0 0 0 0 0
Mary 0 0 0 0 0 0

Data is in the form of linked lists and there are no index for both rows and columns, only
data; therefore the options entered should be (False, False).

John David Robert

Thomas Elizabeth Susan David
Anna Ashley Susan
Peter Jackson
Mary Jackson Julia Laura
Michael James Richard

Data is in the form of linked lists and there are no index for both rows and columns, only
data; therefore the options entered should be (False, False).

② Setting the type of import data

52
Using NetMiner Script

Set the type of import data (main nodeset, sub nodeset, 1-mode network, 2-mode
network). If network data are imported, set the form of data (edge list, matrix, linked list).
This should be done mandatorily because it determines the type of data to be imported.

The script for setting the import datatype uses the importer that is used in 1). See as
follows.

importer.set1modeEdgeListMode('work interact'); #(1)

(1): This function is in the importer object. You can set the type and form of the data to be
imported.

- setMainNodesetMode : Import to a main nodeset.

- setSubNodesetMode : Import to a sub nodeset.

- set1modeEdgeListMode : Import edge list data to a 1-mode network.

- set1modeMatrixMode : Import matrix data to a 1-mode network.

- set1modeLinkedListMode : Import linked list data to a 1-mode network.

- set2modeEdgeListMode : Import edge list data to a 2-mode network.

- set2modeMatrixMode : Import matrix data to a 2-mode network.

- set2modeLinkedListMode : Import linked list data to a 2-mode network.

The functions correspond to the data types of ‘File >> import >> Text File…(or Excel
File)’ in NetMiner. Refer to the function reference in Chapter 3 for arguments to each
function.

53
 4. Using NetMiner Script

③ Setting data attributes

When importing data in the form of node sets or edge lists, names and types to import are
set as attributes. The importer object used in 1) is used to write the following script.

importer.setAttributeInfo(2, 'Number'); #(1)

(1): This function sets data attributes, and takes row index, attribute type, and attribute name
as its arguments. The row index refers to the index of the row that specifies the attribute
name and the attribute type. The attribute type must be given in string. One out of Number,
Text, DataTime, and Time can be selected. The attribute name can be omitted, in which case
the default name is used.

With the ‘setAttributeInfo’ function you set the same things as you can in ‘More’ in the Data
Type window in File >> import >> Text File…(or Excel File) of NetMiner, as shown below.

54
Using NetMiner Script

④ Misc. options

importer.setDiscardNewlyDiscoveredNodes(); #(1)
importer.setTargetWorkfile('workFile Name', True); #(2)

(1): This function sets the workfile that is to be created as the result of importing data. The
imported data are added to the current workfile. You can set if a sub workfile is created and
you can define the name of the workfile to be created.

(2): This function excludes newly found nodes while importing data. If this function is not
called, newly found nodes are added by default.

The functions correspond to Target Workfile and Data Integrity Option in File >> import
>> Text File…(or Excel File) of NetMiner, as shown below.

- Importing data -

To import external data, at least the following setup script is needed.

filePath = r'%UserProfile%SampleData\Cyram Dataset\01.Org_Net_Tiny1\02.1-mode Network

Data\00.Edge List\work interact_weighted.xls'; #(1)
importer = _NM.Import.createExcelImporter(filePath); #(1)
importer.setHeaderOption(False, False); #(2)
importer.set1modeEdgeListMode('work interact'); #(3)
importer.runImport(); #(4)

UNMS_3.py

(1): Function for creating an importer object.

55
 4. Using NetMiner Script

(2): Function for setting header options.

(3): Function for setting import data type.

(4): Function for importing data. Data are imported based on the settings in (1)~(3).

The result of running the above script is as follows.

4) Exporting NetMiner data

NetMiner data can be exported as a file by using a NetMiner script. It performs the same
function as the one at ‘File >> Export’ of NetMiner. It supports two file types: text files
(*.txt, *csv); and Excel files (*.xls).

To perform this task the file ‘01.Org_Net_Tiny1.nmf’ must be open.

If you installed NetMiner 4 with the default settings, the file ‘01.Org_Net_Tiny1.nmf’ can
be found in the folder ‘C:\Users\(Username)\NetMiner\SampleData\Cyram
Dataset\01.Org_Net_Tiny1’.

Writing a script for exporting data is segmented roughly into three parts.

(1) Creating an exporter object.

(2) Setting export options.

(3) Exporting data.

56
Using NetMiner Script

- Creating an exporter object -

Create an exporter object to export data by using a script. The exporter object contains
functions for setting export options.

① Text file exporter object

To create an exporter object for exporting NetMiner data sets to the form of text data (*.txt,
*.csv), write the following script.

filePath = r'%UserProfile%SampleData\Cyram Dataset\

01.Org_Net_Tiny1\02.1-mode Network Data\00.Edge List\workinteract_weighted2.csv';
#(1)
exporter = _NM.Export.createTextExporter(filePath); #(2)

(1): Set the path in a sting to which the file is exported. Notice that ‘r’ is used to treat special
characters such as ‘\’ literally.

(2): Create an exporter object for exporting text data and assign it to ‘exporter’. The
arguments to the function ‘createTextExporter’ are file path, separator, text indicator and
date/time indicator. The file path is the one to which file is imported and is a mandatory
argument. The separator specifies a character by which rows of text data is identified. By
default comma (,) is used for *.csv files while tab (‘\t’) is used for *.txt files. The text
indicator is a character by which text data are shown enclosed. By default double quotations
(“ ”) are used. The date/time indicator is a logic value, and by default it is ‘False’. If ‘True’
is used, data in the form of date and time are also shown to be enclosed by the character. The
separator, text indicator, and date/time indicator can be omitted. If omitted, defaults are used.

The arguments are the same as the options in File >> Export >> Text File… of NetMiner.

57
 4. Using NetMiner Script

② Excel file exporter object

To create an exporter object for exporting NetMiner data sets to the form of Excel file
(*.xls), write the following script.

filePath = r’%UserProfile%SampleData\Cyram Dataset\

01.Org_Net_Tiny1\02.1-mode Network Data\00.Edge List\work interact_weighted2.xls';
#(1)
exporter = _NM.Export.createExcelExporter(filePath); #(2)

(1): Set the file path as a string. Notice that ‘r’ is used to treat special characters such as ‘\’
literally.

(2): Create an exporter object for exporting to a Excel file and assign it to ‘exporter’. The
arguments to the function ‘createExcelExporter’ are file path and sheet name. The file path
specifies the path to which data are exported, and is a mandatory argument. The sheet name
specifies the sheet of exported Excel data, and can be omitted. If omitted, it is automatically
set according to the export data name.

- Setting exporter options -

When an exporter object is created, you can use its functions for setting export options,
which are the same regardless of the type of data to be exported.

You choose and call functions based on the type of data exported (node set, matrix) and
the format of network data (edge list, matrix). You can make more specific settings using
arguments to the functions.
58
Using NetMiner Script

The script for exporting NetMiner data sets uses the exporter object used in 1), as is
shown below.

exporter.exportMainNodeSet(); #(1)

(1): This function is included in the exporter object. According to a specific function to be
used, the data to be exported and its format are set.

- exportMainNodeSet : Export the main nodeset in the current workfile.

- exportSubNodeSet : Export the sub nodeset in the current workfile.

- exportNetworkToMatrix: Export the network data in the current workfile in the form of
matrix.

- exportNetworkToEdgeList: Export the network data in the current workfile in the form
of edge list.

The functions correspond to node set options and network options in File >> Export >>
Text File…(or Excel File) of NetMiner, as shown below. The arguments to the functions
correspond to the specific settings. Refer to the function reference in Chapter 3 for details.

- Exporting -

To export NetMiner data sets, al least the following script is needed.

59
 4. Using NetMiner Script

filePath = r'%UserProfile%SampleData\Cyram Dataset\

01.Org_Net_Tiny1\02.1-mode Network Data\00.Edge List\work interact_weighted2.xls';
#(1)
exporter = _NM.Export.createExcelExporter(filePath); #(1)
exporter.exportNetworkToEdgeList('work interact'); #(2)

UNMS_4.py

(1): Function for creating an exporter object.

(2): Function for setting export data type, format, and options.

In contrast to importing data, options have to be set before exporting.

4.1.2 Managing data sets

You can control the data set items of the currently open
workfile. The data sets include node sets, networks, and
workfiles. Generally when a data set is deleted the
associated process log gets deleted accordingly without
confirmation.

1) Getting a list of data names

① Function for getting attribute names of a node set

Before running the following script, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

60
Using NetMiner Script

attribute = _NM.Dataset.getMainAttributeNames(); #(1)

for att in attribute: #(2)
print att; #(2)
print '---------------'
print 'attribute[2] : ', attribute[2]; #(3)
UNMS_5.py

(1): Return to “attiribute” the list of main node set attribute names of the currently open
project.

(2): Print in iteration the attribute names in the list.

(3): Specific attribute names can be returned with its column index of array form like
‘attribute [2]’. In this case, index begins with 0.

◆ Main node set attributes

◆ Results in the log window after running the script

61
 4. Using NetMiner Script

The function ‘_NM.Dataset.getSubAttributeNames( )’ is used in the same way for sub

node sets. As there may be more than one sub node sets, the desired name of sub node set
must be designated as an argument.

② Returning a list of network names

Before running the following script, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

networkNames = _NM.Dataset.get1modeNetworkNames(); #(1)

for name in networkNames: #(2)
print name; #(2)
print '--------------'
print 'networkNames[2] : ', networkNames[2]; #(3)

UNMS_6.py

(1): Return to ‘networkNames’ the list of 1-mode network names of the currently open
project.

(2): Print in iteration the network names in the list.

(3): Specific network names can be returned with its index at array form like
‘networkNames [2]’.

62
Using NetMiner Script

◆ List of networks in the current ◆ Results in the log window after running the
workfile script

The function ‘_NM.Datset.get2modeNetworkNames( )’ is used in the same way for 2-

mode network data as well. As there may be more than one sub node set, the desired name
of sub nodeset must be designated as an argument.

③ Returning workfile names

Before running the following script, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

nameList = _NM.Dataset.getWorkfileNames(); #(1)

currName = _NM.Dataset.getCurrentWorkfileName(); #(2)
for name in nameList: #(3)
print name; #(3)
print '--------------------'
print currName; #(4)

UNMS_7.py

(1): Function for returning at a form of list the workfile names list of the currently open
project.

(2): Function for returning at a form of string the active workfile name of the currently open
project.
63
 4. Using NetMiner Script

(3): Print in iteration the workfile names.

(4): Print the active workfile name.

◆ Current workfile ◆ Results in the log window after running the script

2) Deleting data

① Function for deleting node set attribute

Before running the following script, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

_NM.Dataset.deleteSubAttribute('Clubs', 'Manager'); #(1)

UNMS_8.py

(1): Function for deleting the row ‘Manager’ in the sub node set ‘Clubs’ in the currently
open project.

◆ Before running the script

64
Using NetMiner Script

◆ After running the script: the ‘Manager’ row gets deleted

② Deleting network data

Before running the following script, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

_NM.Dataset.deleteNetwork('work interact'); #(1)

UNMS_9.py

(1): Function for deleting network data ‘work interact’ in the currently open project.

◆ Before running the script ◆ After running the script

3) Activating a workfile

Before running the following script, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

65
 4. Using NetMiner Script

_NM.Workfile.selectWorkfile('01.Org_Net_Tiny1'); #(1)

UNMS_10.py

(1): Provide a string of the workfile name as an argument. Runinng the script will activate
the workfile specified.

4.2 Using NetMiner Analysis session

Scripts for using NetMiner analysis module sessions under Script Workbench are
automatically generated through the process tab of the script generator. As the control panel
of the script generator is organized at the same way as the per-session process tab of
NetMiner, it provides a very convenient environment in writing scripts for processing
sessions.

To process sessions the environment has to set up and executed. Output session reports
can be added and saved. In addition, process logs can be managed.

4.2.1 Types of analysis sessions

1) General session

① What is a general session?

A general session is made up of the following components: Transform, Analyze,

Statistics, Visualize, Layout, Drawing, and Chart.

66
Using NetMiner Script

The control panel for controlling processing sessions (General) of NetMiner obeys the
following rules in general.

1. There is always a process tab for all module sessions.

2. A process tab has five items: Filter, Input, Pre-process, Main process, Post-process,
and Output.

3. Filter, Input, and Output are present for all sessions, while other items are dependent
on a particular session.

4. According to the output report of a session, the items of Display, Select, Inspect are
activated except the process tab.

② Environment configuration session

The script generator of a general session is segmented into two parts, an area for selecting
a session and a process tab specialized for the particular session. The process tab has the
following items: Filter, Input, Pre-process, Main process, Post-process, and Output.

67
 4. Using NetMiner Script

※ The process tab of the script generator is set up differently at session by session;
unnecessary items are omitted.

2) Visualization session

① What is a visualization session?

A visualization session is made up of a session that excludes Layout and Drawing items of
Visualize.

68
Using NetMiner Script

The control panel for controlling processing sessions (Visualization) of NetMiner obeys
the following rules in general.

1. When a session is selected, Run Processing is done automatically; in 2-mode, Run

Processing is done manually after selecting a 2-mode network in the process tab.

2. Every module session has the following components: Process, Display, and Select
Tab.

3. Filter of the process tab exists in every session (Visualization); the input item exists
only in 2-mode.

4. In the output report of a session, only the map report is shown.

② Environment configuration session

The script generator of a visualization session is made up of a part for selecting the
desired session and a display tab specialized for the particular session under the layout
environment settings. The display tab is made up of Filter, Network, and Layout. Comparing
to the visualization session control panel in NetMiner, style definition is to miss in the Script
Generator.

- Automatically-entered scripts are different according to how the options are set up
in the display tab.
69
 4. Using NetMiner Script

- If default settings are used without changes, the relevant option may not be written
as a script.

- Function arguments that are automatically entered can be changed according to the
user’s needs.

4.2.2 Creating analysis session scripts and their make-up

1) Creating analysis session scripts using the script generator

This is a tool that aids in writing scripts for each analysis module. It supports all modules
in Transform, Analyze, Statistics, Visualize and Chart of the main menu of NetMiner.

After selecting an analysis module and setting options through a user interface that is the
same as the control panel, the corresponding script is automatically generated. It can be
executed in the 'Script >> Script Generator' menu. The script generator can be run only
while a project is open.

Step 1: Selecting modules and settings session variable names

If the name of analysis is entered in ‘Module Name’, the corresponding list of analysis
modules is displayed right below it. On the bottom of a module list, there are buttons called
‘Expand All’ and ‘Collapse All’. If ‘Expand All’ is clicked, all category structures of each
module are displayed; if ‘Collapse All’ is clicked, only the root category of each module is
70
Using NetMiner Script

displayed. ‘Session Variable Name’ sets variable name which is used at the session
generated by the script generator (variable whose datatype is session).

Step 1: Setting module options

The control panel of a selected module is displayed. Set the options via the control panel
UI and press OK. A corresponding script will be generated

The generated script is shown below.

71
 4. Using NetMiner Script

2) Structure of analysis session scripts

Shown below is a session script that performs degree analysis which was generated by the
script generator.
Contents of scripts generated via the script generator are classified into four parts: session
creation, session options configuration, session execution, and session report calling.

session1 = _NM.Session.createSession("Analyze>Neighbor>Degree"); --- session

creation

session1.setInputAdjacencyName("work interact");
session1.setAlgorithmRadioList(1); --- session options
configuration

session1.run(); --- session

execution

report1 = session1.getMainReport("[R] Main");

report2 = session1.getTableReport("[T] Degree");
report3 = session1.getTableReport("[T] Node Type");
report4 = session1.getMapReport("[M] Spring"); --- session report
calling

(1) Creating and calling an analysis session

-Creation-

72
Using NetMiner Script

The first line of an analysis script generated via the script generator in Script Workbench is
the function to create the session. The path to the analysis module used in NetMiner is the
argument to the function, as seen in the degree analysis session script.
The variable ‘session1’ which was assigned as a return value is in session datatype that
performs degree analysis. Accordingly ‘session1’ data can not call a function like ‘report’ at
succeeding statement, if it is not set up or performed with equicalent options.

(2) Setting options for an analysis session

Functions for setting options of a session differ by particular analysis module. The options
that can be set correspond to the ones set in the session helper. In addition, options that are
set by default may be omitted in the script. That is, when default settings are used, functions
for setting options are not shown through the session helper; but when settings other than
defaults are used, the functions are shown in the script.
In the degree analysis session script above, two options are set.
One is (session1.setInputAdjacencyName) to select which 1-mode network to use while the
other (session1.setAlgorithmRadioList) is the measure option of the main process to set.

Notice that the option setAlgorithmRadioList can be omitted if the default value (measure: #
of links) is used. However, if a setup value (measure: sum of weight) is used, the script will
be generated as above.
In addition, after the user sets up the desired option and completes the script via the session

73
 4. Using NetMiner Script

helper, the user can insert and use.

(3) Running an analysis session

To run a session, the function ‘run’ must be used. A session where the run function is used
performs the same as pressing the [Run Process] button in NetMiner.
Also, only after the session datatype is executed by the run function, it can call a report
datatype.

(4) Calling a result report of an analysis session

The session that finished performing ‘Run’ function can call analysis report accordingly to
its retrival result. There are four types of reports: Main Report, Table Report, Map Report,
and Chart Report. The corresponding functions for getting the reports are getMainReport,
getTableReport, getMapReport, and getChartReport respectively.
The arguments to report functions are the names of the tabs in which the results will be
shown. As shown below, the tab names, given as arguments to the report getter functions,
are [R] Main, [T] Degree, [T] Node Type, and [M] Spring.

74
Using NetMiner Script

report1 = session1.getMainReport("[R] Main");

report2 = session1.getTableReport("[T] Degree");
report3 = session1.getTableReport("[T] Node Type");
report4 = session1.getMapReport("[M] Spring");

4.2.3 Managing analysis sessions

If the script is run after completing an analysis session script via the script generator, the
corresponding session will be saved in NetMiner. You can call the session, get the name or
change the name after running the session.

1) Getting and changing the analysis session name

- Getting the session name-

For a module that has been analyzed using the script generator, the analysis session name is
put in the Sessions item of NetMiner. The name of the analysis session can be retrieved
using a script, as shown below, which is needed as an argument when calling the analysis
session.
sessionName = session1.getSessionName( )

The session name corresponding to Session1 is returned. Using ‘session1’ of ‘Degree

Analysis Session’’ above, you can get the ‘Degree’ session name.

- Changing session name-

Changing the session name is the same as renaming the analysis session name in the
Sessions item. When the corresponding analysis session has been written as a script, the
session datatype can be used right away. For a previously analyzed session, the session
datatype can be retrieved by referencing the analysis session call below and using the
function below.
session1.setSessionName(‘desired session name’)

75
 4. Using NetMiner Script

2) Calling an analysis session

Whenever you do analysis via the program, various kinds of analysis are done. In case you
what to call previously analyzed session data again, the function to use for this is
_NM.Session.openSession.

newSession1 = _NM.Session.openSession(“session name”)

The session name can be retrieved using the name getter function for an analysis session, as
is discussed above. You can also call the desired session by looking at session tabs in
NetMiner.

For the Degree analysis session above, it will be _NM.Session.openSession(“Degree”).

The retrieved session has a session datatype with the corresponding session name.

3) Opening, closing and deleting analysis sessions

We’ll work with the process log (sessions) of the current workfile. The process log items
include Session, Query Set, and Selections. Only the Session item will be examined here.
Query Set will be examined in detail in Section 4.3.

To manage the process log, the file ‘01.Org_Net_Tiny1.nmf’ is open and several sessions
are on.

76
Using NetMiner Script

Session management functions include functions that open, close, and delete sessions and
a function that returns the name of the session shown in NetMiner.

① Functions that open or close previously created sessions

Assuming that two sessions ‘Degree’ and ‘Spring 2D’ are running in the file
‘01.Org_Net_Tiny1.nmf’, run the following script under the condition that the session
window is not open.

_NM.Session.openSession('Degree');
UNMS_11.py

77
 4. Using NetMiner Script

◆ Result

-Before

- After

78
Using NetMiner Script

On the other hand, running the ‘closeSession’ function will close the session. You can
also get the session currently shown on the screen, open the session, and use the ‘close’
function of the session object.

_NM.Session.closeSession('Degree');
# or
session1 = _NM.Session.getFocusedSession();
session1.close();

UNMS_12.py

② Function that deletes a session

The_NM basic data class provides the function NM.deleteSession(‘session name’) for
deleting a session. With the ‘close’ function, you can also delete a session by using the
‘delete’ function of a session object.

_NM.Session.deleteSession('Degree');
# or
session1 = _NM.Session.openSession('Degree');
session1.delete();

UNMS_13.py

◆ Result

Before running script After running script

4) Using Save Output Tables

79
 4. Using NetMiner Script

The function ‘saveOutputTables’ saves the results of a report to a new workfile. It

performs the same thing as is done through Data >> Save Output Tables. Notice that this
function is not a function for the table report but one that is dependent on the session itself.
That is, the table report runs a function on a session with a report for which Save Output
Tables can be performed.

The following script is an example of using functions on a session for which Save Output
Tables can be performed. It is run while the file ‘01.Org_Net_Tiny1.nmf’ is open.

###-- Auto generated code by Script generator : Analyze>Position>Blockmodel (Conventional) : Begin --

session1 =_ NM.Session.createSession("Analyze>Position>Blockmodel
(Conventional)"); #(1)
session1.setInputAdjacencyName("work interact"); #(2)
session1.setInputVectorName("Education"); #(3)
session1.setPostDichotomize(True); #(4)
session1.run(); #(5)
report1 = session1.getMainReport("[R] Main"); #(6)
report2 = session1.getTableReport("[T] Block Image Matrix"); #(7)
report3 = session1.getTableReport("[T] Block Density Matrix"); #(8)
report4 = session1.getTableReport("[T] Block Sum Matrix"); #(9)
report5 = session1.getTableReport("[T] Block-Node Affiliation Matrix"); #(10)
report6 = session1.getTableReport("[T] # Nodes"); #(11)
report7 = session1.getTableReport("[T] Block Role Typology"); #(12)
report8 = session1.getMapReport("[M] Clustered"); #(13)
###-- Auto generated code by Script generator : Analyze>Position>Blockmodel (Conventional) : End --
session1.saveOutputTables("Block Matrix"); #(14)
UNMS_14.py

(1)~(13): This is ‘Analyze>Position>Blockmode (Convectional)’ execution script

automatically generated by the script generator.

(14): This function saves the table report of the current session as a data set of a new
workfile.

80
Using NetMiner Script

4.3 Post processing of NetMiner analysis report

After running a session, a report object can be created by using a ‘getReport’ type of
function in the session object. There are four types of reports: Main Report, Table Report,
Map Report, and Chart Report. Report objects can be created for reports that can be obtained
according to the object creation and output option settings.

The script below shows functions that create report objects, assuming ‘session1’ print out
every type of reports.

mainReport = session1.getMainReport(); #(1)

tableReport = session1.getTableReport(); #(2)
mapReport = session1.getMapReport(); #(3)
chartReport = session1.getChartReport(); #(4)

The argument to ‘getReport’ functions is the output report name of the session. If omitted,
the first report of the corresponding type is returned.

(1): Function that gets a main report item of the specified name.

(2): Function that gets a table report item of the specified name.

81
 4. Using NetMiner Script

(3): Function that gets a map report item of the specified name.

(4): Function that gets a chart report item of the specified name.

1) Main report

Using the function getMainReport, a report item is returned to a report object. Two report
formats are available, which can be set by using a function of a main report object.

① getStringTable(dataName)

This function returns a specific table in the main report in the form of a string table. The
arguments include ‘Information’ or a string that describes the table or a value, which is
shown on top of the table or value. This string is in gray, and is underlined.

82
Using NetMiner Script

The script below returns the contents of the information table as a string table by
providing ‘Information’ as the argument.

report1 = session1.getMainReport("[R] Main");

mainTable = report1.getStringTable('Information');

The following functions can be called by the object returned in string table. String table is
classified into two, which are ‘save to’ function that exports to an Excel or a text (csv) file
and ‘set’ function that manages the exported contents.

The following script exports the main report of ‘Node Betweenness Centrality’ as an
Excel file. Before running the script, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

83
 4. Using NetMiner Script

###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : Begin --

session1 = _NM.Session.createSession("Analyze>Centrality>Betweenness>Node");
#(1)
session1.setInputAdjacencyName("work interact"); #(2)
session1.run(); #(3)
report1 = session1.getMainReport("[R] Main"); #(4)
report2 = session1.getTableReport("[T] Node Betweenness Centrality Vector"); #(5)
report3 = session1.getMapReport("[M] Spring"); #(6)
report4 = session1.getMapReport("[M] Concentric"); #(7)
###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : End --
infoString = report1.getStringTable('Information'); #(8)
scoreString = report1.getStringTable('DISTRIBUTION OF NODE BETWEENNESS
CENTRALITY SCORES'); #(9)
filePath = r'%UserProfile%SampleData\stringSample1.xls'; #(10)
sheet = 'sample'; #(11)
infoString.saveToExcel(filePath, sheet); #(12)
scoreString.saveToExcelAttachBottom(filePath, sheet); #(13)

UNMS_15.py

(1)~(7): This automatically-generated script by the script generator runs ‘Node Betweenness
Centrality’.

(8)~(9): This creates an object that has a report in the form of string.

(10)~(11): This specifies the path at which the Excel file is saved, as well as the sheet name.

(12): This saves the report of (8) as an Excel file.

(13): Add the report of (9) to the Excel file saved in (12). When you open the file, you can
see that it is appended to the results of (8).

84
Using NetMiner Script

◆ Main Report ◆ Saved Excel file

② getHtmlData( )

This function converts the contents of the main report to HTML data. The argument is the
same as the stringTable function and if omitted, the entire report is converted to HTML. The
object converted to HTML mode can be viewed through ‘openHtmldialog’. The script below
is provided as an example. The file ‘01.Org_Net_Tiny1.nmf’ must be open before running.

###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : Begin --

session1 =_ NM.Session.createSession("Analyze>Centrality>Betweenness>Node"); #(1)
session1.setInputAdjacencyName("work interact"); #(2)
session1.run(); #(3)
report1 = session1.getMainReport("[R] Main"); #(4)
report2 = session1.getTableReport("[T] Node Betweenness Centrality Vector"); #(5)
report3 = session1.getMapReport("[M] Spring"); #(6)
report4 = session1.getMapReport("[M] Concentric"); #(7)
###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : End --
htmlData = report1.getHtmlData(); #(8)
_SYS.Dialog.openHtmlDialog(htmlData); #(9)

UNMS_16.py

85
 4. Using NetMiner Script

(1)~(7): This automatically-generated script by the script generator runs ‘Node Betweenness
Centrality”.

(8): Returns the main report as HTML code.

(9): Opens the HTML dialog box.

Running the script will open the HTML dialogu box as shown below.

2) Table report

Using the function ‘getTableReport’ you can return a report item to ‘tableReport’ object,
and using the object’s functions you can add to a data set or export to an Excel or text file
(csv).

86
Using NetMiner Script

① ‘addTo’ function

The ‘addTo’ function performs the same thing as is done through Data>>Add Output
Tables. Each ‘addTo’ function is determined by data set the current report is added to, and
the function can be used for sessions with a table report.

The script below shows how to add a table report as an attribute of a node set. Before
running the script, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : Begin --

session1 =_ NM.Session.createSession("Analyze>Centrality>Betweenness>Node"); #(1)
session1.setInputAdjacencyName("work interact"); #(2)
session1.run(); #(3)
report1 = session1.getMainReport("[R] Main"); #(4)
report2 = session1.getTableReport("[T] Node Betweenness Centrality Vector"); #(5)
report3 = session1.getMapReport("[M] Spring"); #(6)
report4 = session1.getMapReport("[M] Concentric"); #(7)
###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : End --
nameList = report2.getAttributeNames(); #(8)
report2.addToNodeAttribute(nameList[0]); #(9)
UNMS_17.py

87
 4. Using NetMiner Script

(1)~(7): This automatically-generated script by the script generator runs ‘Node Betweenness
Centrality’.

(8): As the argument to (9), the attribute name of the output table must be entered, but as it is
not known the names of users and how many they are, only data are received.

(9): The table report of ‘Betweenness Centrality’ is calculated based on each node, so add as
an attribute of the main node set. The argument is the attribute name of the table report. Here,
as there is only one attribute, it is given as ‘nameList[0]’, the first item of the list retrieved in
(8).

The script below shows how to add a report to a 1-mode network. Before running the
script, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

###-- Auto generated code by Script generator : Analyze>Connection>PFnet : Begin --

session1 = _NM.Session.createSession("Analyze>Connection>PFnet"); #(1)
session1.setInputAdjacencyName("work interact"); #(2)
session1.run(); #(3)
report1 = session1.getMainReport("[R] Main"); #(4)
report2 = session1.getTableReport("[T] PFnet"); #(5)
report3 = session1.getMapReport("[M] Map"); #(6)
###-- Auto generated code by Script generator : Analyze>Connection>PFnet : End --
report2.addTo1modeNetwork('PFNet'); #(7)
UNMS_18.py

(1)~(6): This automatically-generated script by the script generator runs ‘PFNet’. The table
report from (5) is used.

(7): Add the table report of (5) to a 1-mode network. The table report of PFNet is matrix
data. As the argument to ‘addTo1modeNetwork’, the name of the network added is given.

After running the script, you can see that the network ‘PFNet’ has been added.

88
Using NetMiner Script

※ Other ‘addTo’ functions can be used in the same way as the above.

② getStringTable( )

This function is the same as the one of the main report. It is used when a table report is
exported to an Excel or a text (csv) file. The script below shows how to export the table
report of ‘Node Betweenness Centrality’ to an Excel file. Before running the script, the file
‘01.Org_Net_Tiny1.nmf’ must be open.

###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : Begin --

session1 = _NM.Session.createSession("Analyze>Centrality>Betweenness>Node"); #(1)
session1.setInputAdjacencyName("work interact"); #(2)
session1.run(); #(3)
report1 = session1.getMainReport("[R] Main"); #(4)
report2 = session1.getTableReport("[T] Node Betweenness Centrality Vector"); #(5)
report3 = session1.getMapReport("[M] Spring"); #(6)
report4 = session1.getMapReport("[M] Concentric"); #(7)
###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : End --
stringTable = report2.getStringTable(); #(8)
stringTable.setTitle('Node Betweenness Centrality'); #(9)
stringTable.saveToExcel(r'%UserProfile%SampleData\stringSample2.xls','Sheet'); #(10)

UNMS_19.py

89
 4. Using NetMiner Script

(1)~(7): This automatically-generated script by the script generator runs ‘Node Betweenness
Centrality’. The table report from (5) is used.

(8): Returns the table report of (5) as a string table.

(9): Function that sets the title of the table report string table.

(10): Function that exports the string table as an Excel file.

3) Map report

The report item is returned to the report object using the getMapReport function. The
functions of the mapReport object are as follows.

90
Using NetMiner Script

The map report provides functions for saving a map to an image, for setting the type of
layout and drawing of a map, for setting the styling according to node attributes, and for
creating a node list which allows access to the nodes in order.

① saveToImage

This function performs the same thing as is done through Map >> Capture Map >> To
File of NetMiner. The results are saved as an image file at the specified path. The script
below is provided as an example. Before running the script, the file ‘01.Org_Net_Tiny1.nmf’
must be open.

###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : Begin --

session1 = _NM.Session.createSession("Analyze>Centrality>Betweenness>Node"); #(1)
session1.setInputAdjacencyName("work interact"); #(2)
session1.run(); #(3)
report1 = session1.getMainReport("[R] Main"); #(4)
report2 = session1.getTableReport("[T] Node Betweenness Centrality Vector"); #(5)
report3 = session1.getMapReport("[M] Spring"); #(6)
report4 = session1.getMapReport("[M] Concentric"); #(7)
###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : End --
report3.saveToImage(r'%UserProfile%SampleData\stringSample1.bmp'); #(8)
UNMS_20.py

91
 4. Using NetMiner Script

(1)~(7): This automatically-generated script by the script generator runs ‘Node Betweenness
Centrality’.

(8): This saves the map report of (6) as an image. The arguments are the path at which the
file is saved and the resolution. The resolution can be omitted, in which case the default
resolution of 1024x768 is used.

② nodeAttributeStyling

Using this function you can set the shape, color, and size according to the partition by
referring to the main node set attributes. The script below is provided as an example and to
be run under the condition that the file ‘01.Org_Net_Tiny1.nmf’ is open.

###-- Auto generated code by Script generator : Visualize>Spring>2D : Begin --

session1 = _NM.Session.createSession("Visualize>Spring>2D"); #(1)
session1.run(); #(2)
report1 = session1.getMapReport("[M] Spring 2D"); #(3)
report1.setLayerAdjcencyList(["work interact"]); #(4)
report1.setLayoutAlgorithmGroupOptionName("Spring"); #(5)

report1.setLayoutAlgorithmName("Kamada & Kawai");

options = {};
options["Max # Iterations"] = 500;
options["EPS"] = 0.0001;
options["Natural Length Coefficient"] = 1.0;
options["Between Component Factor"] = 2;
report1.setLayoutAlgorithmOptionValues(options);
report1.layout();
###-- Auto generated code by Script generator : Visualize>Spring>2D : End --
report1.nodeAttributeStyling('Gender','shape'); #(14)
report1.redraw(); #(15)

UNMS_21.py

92
Using NetMiner Script

(1)~(13): This automatically-generated script by the script generator runs ‘Spring 2D’.

14): This function changes the shape of node by referring to the node partition of ‘Gender’
attribute. ‘Male’ is shown as a triangle while ‘Female’ is shown as a circle.

(15): The map is redrawn to reflect the new node styling. The function ‘Redraw’ must be
executed for node shapes to change on the map.

③ getNodeList

This function returns a list of nodes so that they can be accessed in order. The return value
can be used in array form or through applying iteration onto components of a list, that is
each node.

93
 4. Using NetMiner Script

The ‘Node’ object functions are segmented into two groups: ‘get’ functions and ‘set’
functions. The ‘get’ functions return such things as the index of a node, label, label display
position, and whether a node is selected. The ‘set’ functions set such things as the label of a
node, label display position, node size, color and shape. In addition, a specific node on the
map can be selected.

The example script below shows how to use the above functions in a comprehensive way.
According to the gender, which is a node attribute, the label of nodes is changed to either
‘Male’ or ‘Female’, the shape of nodes either a square or circle, and the color of nodes either
black or white. Furthermore, nodes with the name ‘Anna’ are selected on the map. Before
running the script, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

###-- Auto generated code by Script generator : Visualize>Spring>2D : Begin --

session1 = _NM.Session.createSession("Visualize>Spring>2D"); #(1)
session1.run(); #(2)
report1 = session1.getMapReport("[M] Spring 2D"); #(3)
report1.setLayerAdjcencyList(["work interact"]); #(4)
report1.setLayoutAlgorithmGroupOptionName("Spring"); #(5)
report1.setLayoutAlgorithmName("Kamada & Kawai"); #(6)
options = {}; #(7)
options["Max # Iterations"] = 500; #(8)
options["EPS"] = 0.0001; #(9)
options["Natural Length Coefficient"] = 1.0; #(10)
options["Between Component Factor"] = 2; #(11)
report1.setLayoutAlgorithmOptionValues(options); #(12)
report1.layout(); #(13)
###-- Auto generated code by Script generator : Visualize>Spring>2D : End --

nodeList = report1.getNodeList(); #(14)

genderList = _NM.Dataset.getMainAttributeValues('Gender'); #(15)

for node in nodeList: #(16)

94
Using NetMiner Script

if node.getLabel() == 'Anna': #(17)

annaIndex = node.getIndex(); #(18)
break;
for index in range(len(nodeList)): #(19)
if genderList[index] == 'Female': #(20)
nodeList[index].setLabel('Female'); #(21)
nodeList[index].setColor(255, 250, 250); #(22)
nodeList[index].setShape('circle'); #(23)
else:
nodeList[index].setLabel('Male'); #(24)
nodeList[index].setColor(0,0,0); #(25)
nodeList[index].setShape('square'); #(26)

if nodeList[index].getIndex() == annaIndex: #(27)

nodeList[index].setSelection(True); #(28)
report1.redraw(); #(29)

UNMS_22.py

(1)~(13): This automatically-generated script by the script generator runs ‘Spring 2D’.

(14): This function returns a list of nodes.

95
 4. Using NetMiner Script

(15): This function returns a list of node genders for the main node set. The indexes are
consistent with those of the node list in (14). Using this list each node can be set according
to its gender.

(16)~(18): This returns the index of a node with the label ‘Anna’.

(19)~(28): This sets the node styles according to the gender by using the functions of the
‘node’ object.

(29): The contents are redrawn to reflect the node styles set. Only after calling the ‘Redraw’
function the node shapes will be changed on the screen.

4) Chart report

The chart report returns the report item to the ‘report’ object using the getChartReport
function. The function of the chartReport object saves the chart as an image, as shown below.

① saveToImage

This function perfoms the same thing as is done through Map >> Capture Map >> To File
of NetMiner. The script below is provided as an example. Before running the script, the file
‘01.Org_Net_Tiny1.nmf’ must be open.

96
Using NetMiner Script

###-- Auto generated code by Script generator : Chart>Pie Chart : Begin --

session1 = _NM.Session.createSession("Chart>Pie Chart"); #(1)
session1.setInputVectorName("Gender"); #(2)
session1.run(); #(3)
report1 = session1.getChartReport("[C] Pie Chart"); #(4)
###-- Auto generated code by Script generator : Chart>Pie Chart : End --
report1.saveToImage(r'%UserProfile%\NetMiner\SampleData\stringSample1.bmp'); #(5)

UNMS_23.py

(1)~(4): This automatically-generated script by the script generator runs ‘Pie-Chart’. The
report from (4) is used.

(5): This function saves the chart report as an image file. The arguments are the path at
which the image file is saved and the resolution. The resolution can be omitted, in which
case the default resolution of 1024x768 is used.

97
 4. Using NetMiner Script

4.4 Using query sets

4.4.1 Creating and writing query sets

The query functions used in the script performs the same thing as is done through
‘Tools>>Query Composer’ from the NetMiner menu. The query functions corresponding to
‘Query Composer’ are shown below.

Write a script for writing and creating a query that the user wants. The procedures for
creating a query set are as follows.

Step 1: Create a query object using the ‘createQuerySet’ function.

query1 = _NM.Query.createQuerySet('Age >= 30'); #(1)

(1): Create a query object with the name ‘Age >= 30’.

98
Using NetMiner Script

Step 2: Set the query of the data set using the ‘set’ functions of the query object.

query1 = _NM.Query.createQuerySet('Age >= 30'); #(1)

query1.setMainNodeQuery(' "Age" >= 30.0 '); #(2)

(2): The argument to the function ‘setQuery’ is the query statement used when writing a
query in ‘Query Composer’. The query is enclosed by single quotations (‘ ’ ).

After running the above script, you can see that a query with the name ‘Age>=30’ has
been added to the query set.

4.4.2 Using the written query set

99
 4. Using NetMiner Script

There are two ways of using a created query set: using the filter of the session module;
and creating a new node set workfile corresponding to the query conditions using the
‘runQuerySet’ function.

1) Using as a session filter

Create a query set and use it in the filter. Before running the script, the file
‘01.Org_Net_Tiny1.nmf’ must be open.

query1 = _NM.Query.createQuerySet('Age >= 30'); #(1)

query1.setMainNodeQuery(' "Age" >= 30.0 '); #(2)
###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : Begin --
session1 = _NM.Session.createSession("Analyze>Centrality>Betweenness>Node"); #(3)
session1.setFilteringQuerySet("Age >= 30"); #(4)
session1.setInputAdjacencyName("work interact"); #(5)
session1.run(); #(6)
report1 = session1.getMainReport("[R] Main"); #(7)
report2 = session1.getTableReport("[T] Node Betweenness Centrality Vector"); #(8)
report3 = session1.getMapReport("[M] Spring"); #(9)
report4 = session1.getMapReport("[M] Concentric"); #(10)
###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : End --

UNMS_24.py

(1)~(2) : Create and set a query set.

(3)~(10) : This automatically-generated script by the script generator runs ‘Betweenness

Centrality’. A query set function is added to the location of (4). The argument is the name of
the query set to be created.

Results of running the script: Only the nodes that meet the query criteria are processed.

100
Using NetMiner Script

2) Creating a new workfile

Using the ‘runQuerySet’ function, which corresponds to ‘run’ of ‘Query Composer’, on

the node set to be queried, a new workfile for the node set can be created.

query1 = _NM.Query.createQuerySet('Age >= 30'); #(1)

query1.setMainNodeQuery(' "Age" >= 30.0'); #(2)
query1.runQuerySet('newWorkFile'); #(3)

UNMS_25.py

(3): A new workfile with the name ‘newWorkFile’ is created, which is only composed of
data sets of the nodes that meet the criteria.

Results of running the script:

101
 5. Scripting with matrix data

5. Scripting with matrix data

5.1 Characteristics of matrix data
Apart from the characteristics of NetMiner unique data, matrix data is a new data area
which has the advantage of matrix calculation in itself. Matrix data can be linked with
NetMiner data, so the user can take NetMiner data to matrix data in order to perform desired
calculations and analyses, and then add to NetMiner data again. As matrix data in NetMiner
is inherently used by NetMiner, it is not compatible with other forms of matrix data brought
by other external libraries.
The basic data class of matrix data is _MAT.

5.1.1 Output form of matrix data

If NetMiner matrix data is taken output by a print statement, it is shown as below.
Below is a 3x3 matrix containing random values between 0 and 1.

0.4 1.0 0.9

0.2 0.6 0.6
0.4 0.3 0.3

There is a space between the values.

You can also view a saved matrix in the variables screen in NetMiner Script Workbench.

The (3,3) in Table(3,3) indicates that the currently declared matrix is a 3x3 matrix.
If you click Table(3,3) above, you can view the contents of the matrix.

102
Using NetMiner Script

5.1.2 Matrix data representation

0.7 0.9 0.8

0.8 0.1 0.2
0.4 0.3 0.5

When the matrix data above have been created as ‘mat’, the indexes and element values of
the rows and columns can be represented as follows.

mat[0,0] mat[0,1] mat[0,2]

mat[1,0] mat[1,1] mat[1,2]
mat[2,0] mat[2,1] mat[2,2]

That is, if ‘print mat[0,0]’ is executed, the value at the first row and the first column, is
printed to ‘0.7’. As the index begins at 0, the first row and the first column have index of 0.

5.2 Creating Matrix data

_MAT provides functions that deal with matrix data, including those that create basic
matrixes like unit matrixes and zero matrixes (_MAT.Create), and those that create matrixes
from the network of the current data set or from node attributes (_MAT.FromNM).

5.2.1 Making new matrix data

103
 5. Scripting with matrix data

1) Unit matrix

Create a unit matrix of size NxN in which diagnoals have the value of 1 and the others
have thevalue of 0.

matrix = _MAT.Create.IdentityMatrix(4); #(1)

print matrix #(2)

UNMS_26.py

(1) : Create a unit matrix of size NxN where N is 4.

(2) : Print the created matrix.

Log window results)

2) Zero matrix

Create a zero matrix of the specified row and column size, whose elements have the
value of 0.

matrix = _MAT.Create.ZeroMatrix(3,5); #(1)

print matrix; #(2)

UNMS_27.py

(1) : Create a zero matrix whose row size is 3 and column size is 5.

(2) : Print the created matrix.

Log window results)

104
Using NetMiner Script

3) Random matrix

A matrix is created with the specified row and column sizes, and its elements are filled
with random numbers in the range between 0 and 1.

Matrix = _MAT.Create.RandomMatrix(4,3); #(1)

print matrix; #(2)

UNMS_28.py

(1) : Create a random matrix whose row size is 4 and column size is 3.

(2) : Print the created matrix.

Log window results)

4) Diagonal matrix

Given that the size of the specified vector is N, a NxN matrix is created and the specified
vector is used for diagonal elements while the other elements are filled with 0.

diagonal = _MAT.Create.ZeroMatrix(3,1); #(1)

diagonal[0,0] = 1; #(2)
diagonal[1,0] = 2; #(3)
diagonal[2,0] = 3; #(4)

matrix = _MAT.Create.DiagonalMatrix(diagonal); #(5)

print matrix; #(6)

UNMS_29.py

(1) : Create a zero matrix of size 3x1.

(2)~(4) : Set the 3x1 vector with values [1,2,3].

(5) : Make a matrix that uses [1,2,3] as its diagonal values.

105
 5. Scripting with matrix data

(6) : Print the created matrix.

Log window results)

5.2.2 Getting NetMiner data sets

1) Getting node sets

A main node set or sub node set is returned so that it can be used in the form of a
matrix in scripting.

- getMainNodeAttribute : Get a main node set.

- getSubNodeAttribute : Get a sub node set.

Before running the script below, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

106
Using NetMiner Script

nameList = _NM.Dataset.getMainAttributeValues('@LABEL'); #(1)

jobRanking = _MAT.FromNM.getMainNodeAttribute('Job-ranking'); #(2)
gender = _MAT.FromNM.getMainNodeAttribute('Gender'); #(3)
member = _MAT.FromNM.getSubNodeAttribute('Clubs', 'Members'); #(4)
print 'JobRanking : Gender'; #(5)
for index in range(len(nameList)):
print ''+str(jobRanking[index])+':'+str(gender[index]); #(6)
print '------------------------'
print 'Members';
print memeber; #(7)

UNMS_30.py

(1): Return a name list of node set attributes.

(2): Return the ‘job-ranking’ attribute of the main node set as to a Nx1 matrix.

(3): Return the ‘Gender’ attribute of the main node set as to a Nx1 matrix. If the value is
data, not number, same number is assigned to the same data.

e.g.) [‘Male’, ‘Female’, ‘Female’, ‘Male’] = [1, 2, 2, 1]

(4): Return the ‘Members’ attribute of a sub node set ‘Clubs’ as a matrix.

(5)~(7): Print the returned matrix.

Main node set data Sub node set data (Club)

Log window results: Consistent with NetMiner node data set.

107
 5. Scripting with matrix data

2) Getting networks

A 1-mode network or a 2-mode network is returned in matrix form so that it may be used
in a script.

- get1modeNetwork : Get 1-mode network data.

- get2modeNetwork : Get 2-mode network data.

Before running the script below, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

matrix = _MAT.FromNM.get2modeNetwork('Interest Items', 'Interested In'); #(1)

print matrix; #(2)

UNMS_31.py

(1): Return the ‘Interested In’ network of the ‘Interest Items’ sub node set as a matrix.

※ When get1modeNetwork( ) is used, the name of the 1-mode network is the only
argument.

(2): Print the returned matrix.

108
Using NetMiner Script

◆ Network data (Interest Items > Interested In) ◆ Log window results

5.2.3 Exporting to NetMiner data sets

To add a matrix as a data set of a workfile, the workfile must be open.

1) Adding to a node set

When adding a Nx1 matrix as a node set of the current workfile, N and the main node set
size must be equal in the case of adding to the main node set. On the other hand, N and the
sub node set size must be equal in the case of adding to the sub node set.

Before running the script below, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

matrix = _MAT.Create.RandomMatrix(22,1); #(1)

matrix.addToMainNodeAttribute('randomAtt'); #(2)

UNMS_32.py

(1) : Create a random matrix of Nx1 where N is 22. N must equal to the size of the main
node set.
109
 5. Scripting with matrix data

(2) : Add the random matrix created in (1) as a main node set attribute.

Results)

2) Adding to networks

When adding a matrix as a network data set of the current workfile, there are some
limitations. In the case of 1-mode networks, only NxN matrixes where the size of the main
node set is N can be added. In the case of 2-mode networks, only matrixes that have the
same row and column sizes as the 2-mode network can be added.

Before running the script below, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

matrix = _MAT.Create.RandomMatrix(22,22); #(1)

matrix.addTo1modeNetwork('randomElement'); #(2)

UNMS_33.py

110
Using NetMiner Script

(1): Create a random NxN matrix where N is 22. N must equal to the size of the main node
set.

(2): Add the random matrix to a 1-mode network.

Results)

5.3 Matrix data analysis

5.3.1 Matrix data basic information

1) ‘get’ functions

The size of matrixes is returned or the sum of the elements of a matrix is calculated
and returned. Before running the script below, the file ‘01.Org_Net_Tiny1.nmf’ must
be open.

matrix = _MAT.FromNM.get1modeNetwork('work interact'); #(1)

rowSize = matrix.getRowSize(); #(2)
colSize = matrix.getColumnSize(); #(3)
totSize = matrix.getMatrixSize(); #(4)

111
 5. Scripting with matrix data

cardinality = matrix.getCardinality(); #(5)

element1 = matrix.getElement(0,2); #(6)

element2 = matrix[0,2]; #(7)

totSum = matrix.getMatrixSum(); #(8)

lowerSum = matrix.getLowerSum(); #(9)
upperSum = matrix.getUpperSum(); #(10)

diagonalVector = matrix.getDiagonalVector(); #(11)

rowSumVector = matrix.getRowSum(); #(12)
colSumVector = matrix.getColumnSum(); #(13)

print 'rowSize : ', rowSize;

print 'colSize : ', colSize;
print 'totSize : ', totSize;
print 'cardinality : ', cardinality;
print 'element1 : ', element1;
print 'element2 : ', element2;
print 'totSum : ', totSum;
print 'lowerSum : ', lowerSum;
print 'upperSum : ', upperSum;
print 'diagonalVector : \n', diagonalVector;
print 'rowSumVector : \n', rowSumVector;
print 'colSumVector : \n', colSumVector;

UNMS_34.py

(1): Get ‘work interact’, a 1-mode network data set, as matrix data.

(2): Return the matrix row size.

(3): Return the matrix column size.

(4): Return the row size x column size of the matrix.

(5): Return the number of elements whose value is not 0.

(6): Return the value at row 0 and column 2 of the matrix. Zero-based index is used.

(7): (6) has been expressed in a different form. Return the value of the element at row 0 and
column 2.
112
Using NetMiner Script

(8): Return the sum of all elements of the matrix.

(9): Return the sum of all elements below the diagonal of the matrix.

(10): Return the sum of all elements above the diagonal of the matrix.

(11): Return a vector containing elements of the diagonal of the matrix.

(12): Return a vector containing the sum of each row of the matrix.

(13): Return a vector containing the sum of each column of the matrix.

Log window results

2) Matrix iterator

Using a function that creates an iterator that iterates through elements whose value is not
0, matrix elements can be returned or set.

Before running the script below, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

113
 5. Scripting with matrix data

matrix = _MAT.FromNM.get2modeNetwork('Interest Items', 'Interested In'); #(1)

itertor = matrix.getFullIterator(); #(2)
for elem in itertor: #(3)
rowIndex = elem[0]; #(4)
colIndex = elem[1]; #(5)
value = elem[2]; #(6)
print rowIndex,':',colIndex,':',value; #(7)

UNMS_35.py

(1): Get ‘Interested In’, a 2-mode network data set, as matrix data.

(2): Create an iterator that will iterate through non-zero elements of the matrix.

(3): Items provided by the iterator are row index, column index, and value.

(4)~(6): Return the row index, column index, and value to each respective variable.

(7): Iterate through elements whose value is not 0 and print the row index, column index,
and value.

Log window results: Row index, column index, and value of elements whose value is not 0
are printed.

3) Editing matrix data

This section describes how to change the element value of a matrix.

Before running the script below, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

114
Using NetMiner Script

matrix = _MAT.FromNM.get2modeNetwork('Interest Items', 'Interested In'); #(1)

matrix.setElement(0, 0, 2.0); #(2)
matrix[0,1] = 2.0; #(3)
print matrix; #(4)

UNMS_36.py

(1): Get ‘Interested In’, a 2-mode network data set, as matrix data.

(2): Change the value of the element at row 0 and column 0 to 2.0.

(3): This is another way of changing the value of an element. The value of the element at
row 0 and column 1 is changed to 2.0.

(4): Print the matrix.

Log window results

5.3.2 Matrix transformations and operations

1) Matrix transformations

The following functions transform a matrix.

- Dichotomization of matrix elements: matrix.dichotomize( )

115
 5. Scripting with matrix data

- Matrix symmetrization: matrix.symmetrize( )

- Matrix transposition: matrix.transpose( )
- Matrix inverse: matrix.inverse( )

2) Matrix operators

Basic matrix operations is performed on a matrix using operators such as +, -, and *. The
‘elementWise’ function perform operations between pair of elements.

mat1 = _MAT.Create.ZeroMatrix(3,3); #(1)

mat1[0,0] = 1; mat1[0,1] = 2; mat1[0,2] = 3; #(2)
mat1[1,0] = 4; mat1[1,1] = 5; mat1[1,2] = 6; #(3)
mat1[2,0] = 7; mat1[2,1] = 8; mat1[2,2] = 9; #(4)
mat2 = _MAT.Create.ZeroMatrix(3,3); #(5)
mat1[0,0] = 9; mat1[0,1] = 8; mat1[0,2] = 7; #(6)
mat1[1,0] = 6; mat1[1,1] = 5; mat1[1,2] = 4; #(7)
mat1[2,0] = 3; mat1[2,1] = 2; mat1[2,2] = 1; #(8)
sumMat = mat1 + mat2; #(9)
difMat = mat1 - mat2; #(10)
dotMat = mat1 * mat2; #(11)
elemMult = mat1.elemWiseMult(mat2); #(12)
elemDiv = mat1.elemWiseDiv(mat2); #(13)
elemPow = mat1.elemWisePow(2); #(14)
print 'Sum of Matrix: \n', sumMat; #(15)
print 'Difference of Matrix: \n', sumMat; #(16)
print 'Dot product of Matrix: \n', sumMat; #(17)
print 'Element pair/Multiply: \n', sumMat; #(18)
print 'Element pair/Division: \n', sumMat; #(19)
print 'Element pair/Square: \n', sumMat; #(20)

UNMS_37.py

116
Using NetMiner Script

(1)~(4) : Create mat1

1 2 3
(5)~(8) : Create mat2
4 5 6
(9) : Addition (+) operation

(10) : Subtraction (-) operation 7 8 9

(11) : Dot product operation Mat1

(12) : Multiplication of pairs of element

(13) : Division of pairs of elements 9 8 7

(14) : Squaring of pairs of elements
6 5 4
(15)~(19) : Print results
3 2 1

Mat2

Log window results

5.3.3 Example of analysis using matrix data

117
 5. Scripting with matrix data

Let’s put network data into a matrix, perform operations, and change the resultant matrix
to network data again. The analysis process is as follows.

1) Matrix Calculation: Multiple 1-mode networks.

2) Estimate Average: Add all elements of the matrix obtained in 1) and divide by the
number of links (not 0) to get the average.

3) Use average value as a threshold: Among the elements of the matrix obtained in 1),
those with values less than the average found in 2) are processed as 0 and added to the
1-mode network.

4) Community analysis: Perform community analysis on the 1-mode network created in 3).

Step1: Open the file '01.Org_Net_Tiny1.nmf'.

Step2: Run Script Workbench.

Step3: Write the following script.

118
Using NetMiner Script

networkList = _NM.Dataset.get1modeNetworkNames(); #(1)

matrixSum = _MAT.FromNM.get1modeNetwork(networkList[0]); #(2)

for network in networkList[1:5]:

matrixSum = matrixSum + _MAT.FromNM.get1modeNetwork(network);

totSum =matrixSum.getMatrixSum(); #(4)

cardinality = matrixSum.getCardinality(); #(5)
average = totSum / cardinality; #(6)

iterator = matrixSum.getFullIterator(); #(7)

for elem in iterator: #(8)

row = elem[0];
col = elem[1];
value = elem[2];
if value < average:
matrixSum[row, col] = 0.0;

matrixSum.addTo1modeNetwork('average_weight2'); #(9)

###-- Auto generated code by Script generator : Analyze>Cohesion>Community>Modularity : Begin

-- #(10)
session1 = _NM.Session.createSession("Analyze>Cohesion>Community>Modularity");
session1.setInputAdjacencyName("average_weight2");
session1.run();
report1 = session1.getMainReport("[R] Main");
report2 = session1.getTableReport("[T] Community Partition");
report3 = session1.getMapReport("[M] Clustered");
###-- Auto generated code by Script generator : Analyze>Cohesion>Community>Modularity : End --

UNMS_38.py

119
 5. Scripting with matrix data

(1): Save the file names of imported 1-mode networks to the variable ‘networkList’ as a list
type.

(2): Save the matrix of the first 1-mode network to matrixSum.

(3): Add the elements of the remaining four 1-mode networks to matrixSum.

(4): Find the total sum of the elments of matrixSum from (3).

(5): Return the number of elements from matrixSum whose value is not 0.

(6): Divide the results of (4) by the results of (5) to find the average.

(7): Get an iterator of elements of the matrix whose value is not 0.

(8): If any of the elements of matrixSum has a value that is less than the average of (6), it is
treated as 0.

(9): Add the matrixSum of (8) to the 1-mode network as the main.

(10): Using the session helper, do community analysis of the 1-mode network of (9).

You can obtain the following analysis results after running the script.

[ 1-mode network that was added as the main in (9) ]

120
Using NetMiner Script

[ Results of community analysis performed in (10) ]

121
 6. Using Python

6. Using Python
NetMiner Script is designed based on Python for programming. It allows you to write
algorithms using Python, as well as programs that make use of Python features. In addition
to that, NetMiner’s analysis features can be used for a complementary purpose. For details
on programming with Python, refer to Appendix C.

6.1 Python’s conditionals and loops

6.1.1 Conditionals

1) if statement

The if statement includes logic expressions that compare data. A decision is made based
on the results of the comparison.

Syntax: If the condition is true, the statement is executed.

if condition:
statement

2) if - else statement

The else statement is used in combination with the if statement. The else statement
includes a block of code that gets executed if the condition is 0 or False.

Syntax of if – else statement:

If the condition is true, ‘statement1’ gets executed; if false, ‘statement2’ gets executed.

if condition:
statement1
else condition:
statement2

122
Using NetMiner Script

a=4
b = a,' is not 3'
if ( a == 3 ):
print a
else:
print b
UNMS_39.py

3) elif statement

The elif statement checks against multiple conditions for True. As soon as a condition is
True, the corresponding statement gets executed.

Syntax of if-elif-else statement: Each statement is evaluated in turn.

if condition:
statement1
elif condition:
statement2
else condition:
statement3

123
 6. Using Python

score = 100
if score == 200:
print "1 st grade! "
print score
elif score == 150:
print "2 nd grade!"
print score
elif score == 100:
print "3 rd grade!"
print score
else:
print "etc...."
print score
UNMS_40.py

6.1.2 Loops

1) while statement

The while statement repeatedly executes a statement until the condition is evaluated as
false. The condition is a logical condition, which can be True or False.

Syntax of while statement:

while condition:

statement

124
Using NetMiner Script

i=1
while (i <= 7):
print i
i=i+1
UNMS_41.py

Results))

2) for statement

Using the for statement, you can process items in a sequence such as a list or a string.

Syntax of for statement:

for target in sequence:

statement

Initially, ‘target’ is assigned with the first item in ‘sequence’ and the statement is executed.
Then ‘target’ is assigned with the second item in ‘sequence’ and the statement is executed,
and then it is assigned with the third item, and so in.

e.g.:

for x in [0,1,2,3,4]
print x

UNMS_42.py

125
 6. Using Python

Results:

3) Use of break and continue in loops

If break or continue is used inside of a while or for loop, the loop is either exited or the
current iteration is skipped, respectively.

Exiting out of a loop:

if condition:
statement
break

Skipping the current iteration:

if condition:
statement
continue

i = 0;
while (i <= 7):
i=i+1
if (i == 4):
continue
if (i == 6):
break
print i
UNMS_43.py

126
Using NetMiner Script

6.1.3 Usages in NetMiner Script

1) Usage: Performing the same analysis

When multiple network data sets are analyzed, a list of network data can be returned and can
be iterated through using a loop to perform the same analysis on different types of network
data.
The script below performs ‘Degree’ analysis on five different imported network data sets.

networkNameList = _NM.Dataset.get1modeNetworkNames() #(1)

for networkName in networkNameList: #(2)

###-- Auto generated code by Script generator : Analyze>Neighbor>Degree : Begin --
session1 = _NM.Session.createSession("Analyze>Neighbor>Degree");
session1.setInputAdjacencyName(networkName); #(3)
session1.run();
report1 = session1.getMainReport("[R] Main");
report2 = session1.getTableReport("[T] Degree");
report3 = session1.getTableReport("[T] Node Type");
report4 = session1.getMapReport("[M] Spring");
###-- Auto generated code by Script generator : Analyze>Neighbor>Degree : End --

UNMS_44.py

(1) The variable ‘networkNameList’ is a list of all imported network names in the currently
focused workfile. It is in the form of [‘work interact’, ‘personal friend’, ‘personal help’, ‘personal
knows’, ‘work help’].

(2) A for loop is executed on a list data to perform the same analysis.
127
 6. Using Python

The variable ‘networkName’ is assigned ‘work interact’, ‘personal friend’, ‘personal help’, ‘personal
knows’, and ‘work help’ each time through the loop.

(3) This sets the network input option. Using the variable ‘networkName’, the degree
analysis is done on the five sets of network data.
The results of running the above script are as follows.

Degree analysis sessions are created for the five networks.

Name of the network data used as input data of the main report.

2) Usage: Importing multiple external files

128
Using NetMiner Script

To import multiple external data at once, Python syntax needs to be put to use. This section
shows how easily the user can import multiple external data of the same format by using a
script.

First, the data to import are edge list in a csv file, as shown below.

Given that there are 10 sets of network data in the form as above, in files Network1.csv,
Network2.csv, …. Network10.csv, the script below is written.

path = r'C:\sample'
fileName = 'Network'
fileType = 'csv'

for num in range(1,11): #(1)

filePath = path + '\\' +fileName + str(num) + '.' + fileType #(2)
importer = _NM.Import.createTextImporter(filePath) #(3)
importer.setHeaderOption(False, True) #(4)
importer.set1modeEdgeListMode(fileName+'_'+str(num)) #(5)
importer.runImport() #(6)
UNMS_45.py

(1) As the network files are named from 1 to 10, range(1,11) is used so that it retuns the
variable ‘num’ from 1 to 10 in order. Here, range(1,11) is the same as a list of
[1,2,3,4,5,6,7,8,9,10].

(2) The ‘num’ variable is used to increment number of filename in sequence like
‘Network1.csv’, ‘Network2.csv’. The total string is returned to the variable ‘filepath’.

129
 6. Using Python

(3) ~(6) This is for importing data to NetMiner. Refer to (2) of Section 4.1.1 for details.

3) Usage: Individual node styling

Using loops and conditionals appropriately, you can style individual nodes. The script
below examines nodes one at a time in the network and if the gender attribute is male, it is
colored blue, and if female, it is colored red.

###-- Auto generated code by Script generator : Visualize>Spring>2D : Begin -- #(1)

session1 = _NM.Session.createSession("Visualize>Spring>2D");
session1.run();
report1 = session1.getMapReport("[M] Spring 2D");
report1.setLayerAdjcencyList(["personal friend"]);
report1.setLayoutAlgorithmGroupOptionName("Spring");
report1.setLayoutAlgorithmName("Kamada & Kawai");
options = {};
options["Max # Iterations"] = 500;
options["EPS"] = 0.0001;
options["Natural Length Coefficient"] = 1.0;
options["Between Component Factor"] = 2;
report1.setLayoutAlgorithmOptionValues(options);
report1.layout();
###-- Auto generated code by Script generator : Visualize>Spring>2D : End --
130
Using NetMiner Script

nodeList = report1.getNodeList() #(2)

genderList = _NM.Dataset.getMainAttributeValues('Gender') #(2)

index = 0;
for node in nodeList: #(3)
gender = genderList[index]
index = index + 1;
if gender == 'Male':
node.setColor(0, 0, 255)
else:
node.setColor(255,0,0)
UNMS_46.py

(1) With the file ‘01.Org_Net_Tiny1.nmf’ open, draw Spring Map using the script
generator.

(2) Return a list of nodes on the map to nodeList and return a list of genders of the nodes
to genderList.

(3) Use a for loop so that a conditional can be performed on each node in the list. Inside
of the for loop, if the gender of the node is male, the node’s color is made blue; if not,
it is made red.

131
 6. Using Python

6.2 Python function

6.2.1 Function definition

The ‘def’ statement is a compound construction that creates a new function, and that
defines a block of code to be executed when the function is called with its name and
arguments.

def function():

statement

According to the definition above, the desired function name is given after ‘def’ and in the
brackets there are arguments if any. In addition, in Python, the statement that goes inside the
function is on the next line to the function name declaration and is tabbed.

The script below prints Fibonacci numbers below the value of ‘n’ in order. A function
named ‘fibonacci’ is used, and ‘n’ as an argument. Here, ‘n’ is used as a variable so that
numbers less than ‘n’ are printed.

def fibonacci(n):
a, b = 0, 1
while a < n:
print a,
a, b = b, a+b

fibonacci(2000)
UNMS_47.py

The below is the results of running the script.

132
Using NetMiner Script

6.2.2 Calling functions and returning a value

To call a function, just enter the function name and the arguments inside the brackets. If
there are no arguments, just write as ‘()’; if there are arguments, provide arguments of the
appropriate datatypes.

function()

When a function is called, there may be a value returned by the function.

The return value is the result of calling the function.

def function():

statement

return value

For example, the function ‘sum’ below can be written manually and used.

def sum(a,b):

return a + b  return a + b

x = sum(3,4)  x gets 3+4; that is, x=7.

print x

UNMS_48.py

Running the script will print ‘7’ in the log window.

133
 6. Using Python

6.3 Using external Python modules

6.3.1 Calling external Python modules

In Python, you can use pre-written modules that are in files in the form ‘module_name.py’.
To use objects defined in a module, load the module using ‘import’ statement as shown
below.
Notice that ‘.py’ is omitted and only the module name is entered.

import ‘module name’

When importing an external module, if the external module file exists in the same folder
as the script file currently being written, the import will take place successfully. But if the
module is at a path where Python doesn’t know about, you need to specify the path manually.

If an external module to import is at a specific arbitrary path, you can call it as shown below.

import sys
sys.path.append(r”module filepath ”)
import module

As shown in the above script, you can set the import path using the ‘sys.path.append’
function on the second line. In addition, to use ‘sys’, ‘import sys’ line must be added on top.

6.3.2 Using functions of external modules

Once an external module has been imported as described in Section 6.3.1, you can use
classes or functions in the external module.
For example, let’s suppose the functions of the external module are as follows.

def sum(a,b):
return a+b

134
Using NetMiner Script

def multiplication(a,b)
return a*b
UNMS_49.py

To call the module and use the functions, write ‘testModule.sum(a,b)’ or

‘testModule.multiplication(a,b)’.

An example of calling the ‘testModule.py’ module in a new script and using the ‘sum’
function of ‘testModule’ is given below.
import UNMS_49

x = UNMS_49.sum(3,4)
print x
UNMS_50.py

Running the above script will print ‘7’.

135
 7. Advanced using NetMiner Script

7 Advanced Using NetMiner Script

7.1 Using basic tools of NetMiner

7.1.1 Using dialog boxes

It is convenient for the user to use dialog boxes via NetMiner script functions for entering
file path and variables and printing messages and html data.

1) File selection dialog box

A dialog box is opened, which returns the path of the selected file.

filePath = _SYS.Dialog.openFileOpenDialog('Select NetMiner File', ['*.nmf'], ['NetMiner File']);

#(1)
_NM.Project.openProject(filePath); #(2)

UNMS_51.py

(1): Return the path to ‘filePath’ using the ‘openFileOpenDialog’ function.

(2): The path in ‘filePath’ is provided as an argument to open the corresponding file.

① Running the script will open a dialog box in which a file can be selected, as shown
below.

② When a file is selected, a project will open.

136
Using NetMiner Script

2) Directory selection dialog box

Open a dialog box, which returns the selected directory.

directory = _SYS.Dialog.openDirectoryDialog(); #(1)

print directory; #(2)

UNMS_52.py

(1): Return a user-specified directory to the variable ‘directory’.

(2): Print the returned variable using a ‘print’ statement to check the directory name.

Log window results

137
 7. Advanced using NetMiner Script

3) Message box

This function opens a message box with a specified message. The title and contents of the
message box can be specified. One of ‘normal’, ‘yesno’, ‘alert’, or ‘error’ must be specified
as the type. Only the ‘yesno’ type will return true for ‘yes’ and false for ‘no’ according to
the user’s choice.

① ‘normal’ type

_SYS.Dialog.openMessageBox('Write Message', 'Write Title', 'normal');

UNMS_53.py

Running the script will open a message box as shown below.

② ‘yesno’ type

yesno = _SYS.Dialog.openMessageBox('Write Message', 'Write Title', 'yesno');

UNMS_53.py
Running the script will open a message box as shown below.

138
Using NetMiner Script

③ ‘alert’ type

alert = _SYS.Dialog.openMessageBox('Write Message', 'Write Title', 'alert');

UNMS_53.py

Running the script will open a message box as shown below.

④ ‘error’ type

error = _SYS.Dialog.openMessageBox('Write Message', 'Write Title', 'error');

UNMS_53.py

Running the script will open a message box as shown below.

4) User-defined dialog boxes

139
 7. Advanced using NetMiner Script

The user can define a dialog box, such as the one that opens a file or that sets variables.

The basic steps of writing a script for user-defined dialog boxes are as follows.

Step 1: Create a user-defined dialog box object.

Step 2: Use a function of the created object and add the desired variable to be returned.

Step 3: A user-defined dialog box can be opened using the ‘open’ function. The results
will be returned as a list, with each result item added in order.

Step 4: Use the results returned in the form of a list in other code.

customDialog = _SYS.Dialog.createCustomDialog(); #(1)

variable = customDialog.addComboBoxVariable('variable',['A','B','C']); #(2)
filePath = customDialog.addFileOpenVariable('File Open');
x = customDialog.addIntegerVariable('x');
y = customDialog.addIntegerVariable('y');
name = customDialog.addStringVariable('name');
resultList = customDialog.open()
for result in resultList:
print result;

UNMS_54.py

① Running the script will open a user-defined dialog box as shown below.

140
Using NetMiner Script

② After entering values or making a choice, look at the results in the log window.
You can see that the same values as those set by the user have been printed.

7.1.2 Status dialog box

You can open a dialog box that will show the current status. It can be used when you want
to know the current progress of the script. When you run the script, the Script Workbench
window will disappear, which means you can’t check the current progress in the log window.
But by using the dialog box you can check it.

Before running the script below, the file ‘01.Org_Net_Tiny1.nmf’ must be open.

141
 7. Advanced using NetMiner Script

mat = _MAT.FromNM.get1modeNetwork('work interact');

for i in range(10000):
if i < 5000:
mat2 = mat *mat;
_SYS.Dialog.showStatusDialog('process :'+str(i)); #(1)
else:
mat2 = mat * mat;
_SYS.Dialog.closeStatusDialog(); #(2)

UNMS_55.py

(1) : The number of matrix multiplication operations is received by ‘i’ and shown in the
status dialog box.

(2) : If the number of operations is above 5000, the status dialog box is closed.

When running the script, you will see a dialog box that prints the number of operations,
which increments accordingly.

7.1.3 Opening HTML documents

142
Using NetMiner Script

You can show stringTable converted to HTML data or HTML code in a HTML dialog
box.

###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : Begin --

session1 = _NM.Session.createSession("Analyze>Centrality>Betweenness>Node"); #(1)
session1.setInputAdjacencyName("work interact"); #(2)
session1.run(); #(3)
report1 = session1.getMainReport("[R] Main"); #(4)
report2 = session1.getTableReport("[T] Node Betweenness Centrality Vector"); #(5)
report3 = session1.getMapReport("[M] Spring"); #(6)
report4 = session1.getMapReport("[M] Concentric"); #(7)
###-- Auto generated code by Script generator : Analyze>Centrality>Betweenness>Node : End --
htmlData = report1.getHtmlData('Information'); #(8)
_SYS.Dialog.openHtmlDialog(htmlData); #(9)

UNMS_56.py

(1)~(7): This automatically-generated script by the script generator runs ‘Node Betweenness
Centrality’.

(8) : This converts ‘Information’ of the main report to HTML code and returns it.

(9) : This shows the converted code in a HTML dialog box.

Running the script will show converted HTML data in a HTML dialog box.

7.2 Calling NetMiner scripts using external scripting languages

143
 7. Advanced using NetMiner Script

You can call NetMiner scripts using an external scripting language, according to the
following flow of execution.

Notice that the external script must have a function that can run ‘NetMiner 4.exe’.

The following sections describe how to run ‘NetMiner 4.exe’ in the DOS prompt and how to
run it using a Python script.

7.2.1 Running NetMiner scripts in the DOS prompt

“NetMiner 4.exe path” “path of the nmf file to be imported” -s “path of the py
script file” -x

When the above is executed in the command prompt, if NetMiner runs with a specific nmf
file open, the selected script file (.py) will run.

The basic options used here are –s and –x.

-s : A script file given following –s will run in NetMiner.

-x : If this option is added last, NetMiner will terminate after running the script.

7.2.2 Linking with external scripts

144
Using NetMiner Script

NetMiner Script can run with options in the DOS prompt, as described in Section 7.2.1.
Using these options, you can link with external programming languages (Python, Perl, batch
files) for execution in more diverse environments.
The following chapter gives a brief description on batch file programming and describes a
way of using NetMiner Script with Python and batch file programming.

1) Batch file programming

(1) What is a batch file?

Batch files have the extension ‘bat’. They can be used to perform various tasks in the
command prompt. As it supports practical programming constructs such as if and dir
statements, it is the simplest and easiest programming. To be precise, writing a batch file is
not exactly programming per se but with its high practicality, it is sometimes classified as
such.
The program Notepad is commonly used for writing batch files. They can also be written
using ‘copy con’ command in the command prompt.

(2) Batch file commands

There are help pages for batch programming in the command prompt.
Type ‘help’ in the command prompt and press enter to see a description on commands and
brief explanations. See as follows.

145
 7. Advanced using NetMiner Script

If you type ‘help command_name’ and press enter, you can see a more detailed description
of the command.

In this section we’ll take a brief look at a few of the most commonly used commands by
looking at examples.

- echo
echo on(default): Shows commands executed in the batch file.
echo off: Does not show commands executed in the batch file; only the results of the
commands are shown.

Example of ‘echo on’ (test.bat)

echo on
dir
After running:
C:\>echo on
C:\>dir
dir contents

Example of ‘echo off’ (test.bat)

echo off
146
Using NetMiner Script

dir
After running:
C:\>echo off
dir contents
If ‘echo off’ is changed to ‘@echo off’, even the ‘echo off’ command itself is hidden.

Using echo to print a message

C:\>echo Echo Test!
Echo Test!

- pause
The ‘pause’ command waits for the user to hit any key.

- argument
You can provide arguments for the batch file. For example, ‘test.bat [a] [b]’.
This is equivalent to arguments of Python functions.

Example of using arguments (test.bat)

@echo off
echo %1
dir %2
After executing test.bat aaaa *.exe
C:\test.bat TestMessage *.exe
TestMessage
(dir *.exe contents ...)

- if statement
This is similar to the ‘if’ statement in Python. When the condition is true, the commands

147
 7. Advanced using NetMiner Script

inside the brackets are executed.

Example of using ‘if’ (test.bat)

@echo off
if "%1" == "w" (
dir /w
) else (
dir /p
)
After executing ‘test.bat w’
Results of executing ‘dir/w’

- for statement
Example of using ‘for’ (test.bat)
@echo off
for %%i in ("*.bat") do (
echo %%i
)
After executing ‘Test.bat’
A list of ‘.bat’ files is printed.

2) Processing multiple nmf files using a batch file

When analyzing multiple nmf files, if multiple data sets can’t be imported at once due to
memory constraints or analysis has to be done with multiple nmf files already, using a batch
file can be useful.

To run NetMiner scripts in the command prompt, you need two files below, as with Section
7.2.1.
- The nmf file to import
- The script file to use

148
Using NetMiner Script

NetMiner 4.exe" “nmf file to import” -s “script_file.py “ -x

To repeatedly perform the above processing, write a batch file using a for loop.

multiple_nmf.bat
@echo off

for %%i in ("c:\sample\*.nmf") do (

"%UserProfile%NetMiner 4.exe" %%i -s "c:\sample\testPy.py" -x
)
The ‘%%i’ gets names of nmf files in the folder ‘c:\sample’ one at a time. Therefore, using
‘%%i’ you can perform analysis on multiple nmf files.

3) Script scheduling by using Python programming.

Based on running NetMiner from the DOS prompt, you can make a script scheduling
program by using Python to run desired data at a desired time.
You can make a Python scheduling program that runs a batch file at a specified time.
The following is a bare-bones scheduling program written in Python.
import os
import time

class ScheduleRunClass():
def start(self):
print "==================================="+'\n'
print "Set the time to run the script."+'\n'
print "==================================="+'\n'
print "What day to run every week? " +'\n'
print "(0: Monday, 1: Tuesday, 2: Wednesday, 3: Thursday, 4: Friday, 5:
Saturday, 6: Sunday)? : "
s_wday = int(raw_input())
print "Which hour to run? : "

149
 7. Advanced using NetMiner Script

s_hour = int(raw_input())
print "Which minute to run? : "
s_min = int(raw_input())

while(True):
print '===== Scheduling work began ======'
local_hour = time.localtime()[3]
local_min = time.localtime()[4]
local_wday = time.localtime()[6]
if local_wday == s_wday:
if local_hour == s_hour:
if local_min == s_min:
print '====Program is being run ====='
cmd = r'C:\sample\multiple_nmf.bat
os.system(cmd)
print '===== Program ended ======'

ScheduleRunClass().start()
UNMS_56.py

The above script measures the current time continuously (using local_hour, local_min, and
local_wday in the while statement) and if the time matches the user-specified time (s_hour,
s_min, s_wday), shaded ‘multiple_nmf.bat’ file is run.

150
Using NetMiner Script

7.3 Plug-in

7.3.1 What is a plug-in?

The user can add an analysis module to the NetMiner menu. Manually-written scripts or
Python files written by others can be converted to a NetMiner plug-in and added, or pre-
existing plug-in files can be registered to NetMiner for use. Using the plug-in feature, scripts
can be run without opening Script Workbench.

7.3.2 Creating a plug-in file

Step 1: Write a script as follows.

Step 2: To make a plug-in, the script file has to be saved. If Plug-in >> Make is clicked in
the Script Workbench menu without first saving the script, an error will occur, as follows.

Save the written script to a desired path.

Step 3: After writing a script, select Plug-in >> Make to bring up a window in which a plug-
in can be created. ‘Source Files’ shows the name of the Python file for creating a plug-in file
and the path at which it is saved. In ‘Plugin Option’, you can enter the path at which the

151
 7. Advanced using NetMiner Script

created plug-in file will be saved, plug-in file name, author, version, and description. Also,
the run mode can be selected. The created plug-in file will have the extension ‘nmx’.

Click ‘OK’ will create the plug-in file.

7.3.3 Registering and running plug-in files

Created plug-in files or existing nmx files can be registered to NetMiner.

Step 1: To register a plug-in file to NetMiner, select Plug-in Manager.

152
Using NetMiner Script

Step 2: When the Plug-in Manager window comes up, press the Add Plug-in button.

A file selection window for selecting an nmx file will come up. Select the file ‘Plug1.nmx’
created in Section 7.3.2.

Step 3: After selecting a file, you can see information of the plug-in file in the Plug-in
Information section of the Plug-in Manager window. Press the Close button to finish
registering the plug-in.

153
 7. Advanced using NetMiner Script

When the mouse cursor is brought to Tools >> Plug-ins of the menu, you will see that a
plug-in item called ‘Plug1’ has been created. Clicking this will run the plug-in.

154