download pdf in mvc : .Net convert pdf to tiff Library application API .net azure html sharepoint IMA09_RiskPaths_MS1-part333

Martin Spielauer                                                                                The RiskPaths teaching model 
11 
A special type of micro-data output is the graphical display of individual careers. This can be a 
helpful feature, as it provides users with a window to the simulated individuals, and thus a way to 
see the operation of the statistical models. This can also be useful for model developers as it 
supports model debugging. Since RiskPaths is a training tool, we are interested in displaying how 
individual biographies result  from  statistical processes. Thus, besides life  course  events,  we 
might also want to see how the risks of the alternative events change over time and life course 
situations.  
3.2.3  User interface and documentation 
So far, we have formed expectations about the content, display, and organization of model input 
and output data. From the user perspective, do we just have to add a start button to complete the 
microsimulation application? Almost all contemporary software applications contain help files. 
As users of microsimulation models, we should expect access to detailed online help, not only on 
the  use  of  the  modeling  software  itself  but  also  on  the  model’s  specific  elements  and  the 
interrelationships amongst those elements.  
 Exploring the Modgen application RiskPaths 
In the remainder of this discussion we provide a quick explorative tour of the visual interface 
provided by Modgen for the RiskPaths model. To run RiskPaths, both the Modgen Prerequisites 
application and the RiskPaths executable have to be installed on your computer. As is true for all 
Modgen applications, RiskPaths contains a help system including documentation on the (model-
independent) Modgen user interface and the actual RiskPaths model itself. Accordingly, in the 
description below, we concentrate on the central steps of running RiskPaths, leaving it to you to 
explore the model and software in depth with the assistance of the detailed help files.  
4.1  The user interface 
All Modgen applications have the same graphical user interface (Figure 1) which consists of the 
following parts: 
 a menu bar and a toolbar to administer and run scenarios, as well as to get help  
 a selection window containing a hierarchically  grouped list of all model parameters  and 
output tables 
 a frame in which all corresponding parameters or tables can be displayed  
When starting the RiskPaths.exe application, the selection window and table frame are empty, as 
we first have to load (or create) a simulation scenario. To do so, follow the following steps: 
.Net convert pdf to tiff - Library application API:C# PDF Convert to Tiff SDK: Convert PDF to tiff images in C#.net, ASP.NET MVC, Ajax, WinForms, WPF
Online C# Tutorial for How to Convert PDF File to Tiff Image File
www.rasteredge.com
.Net convert pdf to tiff - Library application API:VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.net, ASP.NET MVC, Ajax, WinForms, WPF
Free VB.NET Guide to Render and Convert PDF Document to TIFF
www.rasteredge.com
Martin Spielauer                                                                                The RiskPaths teaching model 
12 
 Open the simulation scenario ‘base.sce’. This can b e done by clicking the ‘Open’ button or by 
selecting ‘Open… … ’ from the ‘Scenario’ menu.  
 Choose  the  scenario  settings--the  settings  dialog  box  can  be  accessed  by  clicking  the 
‘Settings’ button or by selecting ‘Settings…
’ from the ‘Scenario’  menu. Specify  a  small 
number of simulated cases (e.g. 10,000) so that your first model runs quickly. Also, ensure 
that ‘MS Access tracking’ is switched on. This will  allow you to view individual biographies 
using the BioBrowser tool that comes with Modgen  
 Save your scenario under a new name by selecting ‘S ave as… … ’ from the ‘Scenario’ menu.  
Figure 1: The RiskPaths application 
Run the simulation
Parameters 
organized in 
parameter groups
Open a simulation 
scenario
Output tables 
organized in table 
groups
Scenario Settings
4.2  Parameter tables 
Users of  a  Modgen  application  have  control over  all  parameters contained  in  the  model’s 
parameter tables. An individual parameter table can be selected by clicking its list entry in the 
selection window. The table is then displayed in the display frame in which it can also be edited. 
Modgen parameter tables can have any number of dimensions, ranging from a parameter with a 
single checkbox to parameters with numerous characteristics or dimensions (e.g. region, sex, age, 
time).  
Library application API:VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Our PDF to HTML converter library control is a 100% clean .NET document image solution, which is designed to help .NET developers convert PDF to HTML webpage
www.rasteredge.com
Library application API:Online Convert PDF file to Tiff. Best free online PDF Tif
Using this .NET PDF to TIFF conversion control, C# developers can render and convert PDF document to TIFF image file with no loss in original file quality.
www.rasteredge.com
Martin Spielauer                                                                                The RiskPaths teaching model 
13 
Figure 2: Parameterization of first union formation risks 
4.3  Performing a simulation run 
Click the ‘Run/resume’ button or select ‘Run/resume ’ from the ‘Scenario’ menu. The progress of 
the simulation is displayed in a progress dialog box. A small sample of 10,000 actors takes 
around 20 seconds to run. After the model run is complete, all output tables will have been 
updated by Modgen. 
4.4  Table output: aggregates and distributions 
Simulation results are written to predefined output tables. Note that the values displayed in the 
output table represent only one of several possible views on the results. By right-clicking a table, 
a properties sheet for the table can be accessed. Among other things, this allows the display of 
distributional  information  (standard  errors  and  the  coefficient  of  variation)  of  all  simulated 
values. Table contents can also be copied and pasted. You have the choice to copy the table as 
displayed, or all dimensions of the table at once (if there are more than two dimensions).  
4.5  Model help and documentation 
As is true with all Modgen applications, RiskPaths provides help files of various types. Two are 
related to Modgen itself--a general user guide for the visual interface plus release notes for 
Modgen. The other help files are model-specific. All Modgen applications contain a detailed 
encyclopaedic  model  documentation  file.  This  documentation  is  automatically  created  from 
properly commented code.  
Figure 3: Model documentation 
Library application API:VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.
Create PDF from PowerPoint; VB.NET: Create PDF from Tiff; VB.NET: Convert PDF to Word; VB.NET: Convert PDF to Tiff; VB.NET: Convert PDF
www.rasteredge.com
Library application API:VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
VB.NET PDF - Convert PDF to MS Office Word in VB.NET. VB.NET Tutorial for How to Convert PDF to Word (.docx) Document in VB.NET. Best
www.rasteredge.com
Martin Spielauer                                                                                The RiskPaths teaching model 
14 
4.6  Graphical output of individual histories 
The Modgen Biography Browser (BioBrowser) application is a tool for the graphical display of 
individual  life  courses.  This  view  on  the  simulation  results  is  especially  useful  for  model 
debugging. In order to use the tool, the tracking feature has to be switched on in the scenario 
settings. The list of variables to be tracked also has to be declared by the model developer in the 
model code via a tracking statement. Modgen than tracks all changes of those variables included 
in the tracking statement for a sample of simulated actors (where the size of this sample is 
specified as one of the scenario settings).  
To display biographies created by RiskPaths, just start the BioBrowser application and load the 
tracking-file of your simulation scenario, e.g. Base(trk).mdb.  
Figure 4: BioBrowser 
Add variables
Right-click for 
context menu: 
display data, 
delete, etc.
Navigate to 
next/previous 
first/last biography
Double-click 
graphs to change 
appearance
Part II: The RiskPaths Code 
 The Modgen programming environment 
When installed on a computer, Modgen integrates itself into the (required) Microsoft Visual 
Studio C++ environment. The visual components of Modgen are a separate toolbar as well as 
additional items under the Tools and Help menus of Visual Studio. Modgen also appears as an 
option in the file dialog box for creating a new project as well as in the dialog box for adding a 
file to an existing project.  
Figure 5 displays a screenshot of  the programming interface  as it appears after opening  the 
Modgen application ‘RiskPaths.sln’. The Modgen tool bar consists of several icons for running 
Modgen, accessing help, opening the BioBrowser tool, and switching the language (between 
English and French).  
Library application API:C# WPF Viewer: Load, View, Convert, Annotate and Edit Tiff
Create PDF from PowerPoint; VB.NET: Create PDF from Tiff; VB.NET: Convert PDF to Word; VB.NET: Convert PDF to Tiff; VB.NET: Convert PDF
www.rasteredge.com
Library application API:C# WinForms Viewer: Load, View, Convert, Annotate and Edit Tiff
Create PDF from PowerPoint; VB.NET: Create PDF from Tiff; VB.NET: Convert PDF to Word; VB.NET: Convert PDF to Tiff; VB.NET: Convert PDF
www.rasteredge.com
Martin Spielauer                                                                                The RiskPaths teaching model 
15 
Modgen code is organized into several files, each with the file extension .mpp. As can be seen in 
the Solution Explorer window (Figure 5), RiskPaths consists of eight .mpp files grouped in the 
“Models (mpp)” folder. These are the essential file s of RiskPaths, i.e. the files containing all 
Modgen code written by the model developer.  
Figure 5: The programming interface 
The Modgen tool to be 
run before compiling 
the model
Model parameters
The model code 
organized in .mpp files
Modgen output: error 
messages, etc.
When invoking the Modgen tool (which can be accessed from the toolbar, or from the first item 
under the “Tools” menu), these .mpp files are trans lated into C++ code. Thus Modgen acts as a 
pre-compiler, creating one .cpp source code file for each .mpp file and putting the resulting .cpp 
files  in  the  “C++  Files”  folder.  The  Modgen  tool  al so  adds  model-independent  C++  code 
components to the “C++ Files” folder; these additio nal files
1
should not be changed by the model 
developer and are essential in order to use the C++ compiler to build the Modgen application.  
The model parameters are contained in one or more .dat files organized in a folder labelled 
“Scenarios”. These files are loaded at runtime and  contain the actual values assigned to  the 
parameters.  
When running the Modgen tool, Modgen – like the C++  compiler - produces log output that is 
displayed in the Output window. Any error messages are also displayed in this window, and 
clicking on a particular error message leads you directly to the corresponding Modgen code that 
produced the error.  
1
ACTORS.CPP, ACTORS.H, app.ico, model.h, model.RC, PARSE.INF, TABINIT.CPP, TABINIT.H. 
Library application API:C# PDF Convert to SVG SDK: Convert PDF to SVG files in C#.net, ASP
C#.NET PDF SDK - Convert PDF to SVG in C#.NET. C#.NET PDF DLLs and Demo Code: Convert PDF to SVG in C#.NET. Add necessary references:
www.rasteredge.com
Library application API:RasterEdge XDoc.Tiff for .NET - SDK for Tiff Document Imaging
Tiff viewer for .NET. Fully featured HTML5 Tiff Viewer. Fully featured WinForms Tiff Viewer. Able to view and edit Tiff rapidly. Convert. Convert Tiff to PDF.
www.rasteredge.com
Martin Spielauer                                                                                The RiskPaths teaching model 
16 
Two steps are required to create a Modgen application from the Visual Studio environment. First, 
Modgen has to translate the Modgen code in the .mpp files; this is done when invoking the 
Modgen tool. Second, the resulting C++ application has to be built and started. This can be done 
in one step by selecting “Start Debugging” in the “ “ Debug” menu or by clicking the corresponding 
icon at the toolbar. 
 Basic Modgen Concepts 
Actor: An actor is the entity whose life is simulated in a Modgen model. A model’s actor is often 
 person,  although  this  is  not  a  requirement--other  models  have  been  developed  that  use 
dwellings or occupations as actors. Nevertheless, in RiskPaths, the actor is a person or more 
specifically, a female (since it is a model for the study of childlessness) 
State: States describe the characteristics of a model’s actors. Some states can be continuous, such 
as age, whereas others are categorical, such as gender. For categorical states, the actual categories 
or levels are defined via Modgen’s classification command. 
Overall, there are two major kinds of states in Modgen— — simple states and derived states, both 
of which are used by RiskPaths and both of which are declared within an actor declaration. A 
simple state is a state whose value can be initialized and changed by the code that a model 
developer creates. Simple states are changed by explicitly declared events. A derived state, on the 
other hand, is a state whose value is given as an expression which is normally derived from or 
based  on  other  states.  A  derived  state’s  values  are   automatically  maintained  by  Modgen 
throughout a simulation run. A useful Modgen concept is the self-scheduling derived state. This 
is a state which changes in a predefined time sequence, such as integer age which will change at 
each birthday. 
Event: In Modgen, simulation takes place through the execution of events. Each event consists of 
two functions: a time function to determine the time of the next occurrence of the event, and an 
implementation function to determine the consequences when the event happens. RiskPaths has 
several events, including a mortality event, union formation and dissolution events, and a first 
pregnancy event. 
Parameter: Parameters are used to give model users a degree of control over the simulations 
they run. The ability to change different hazards or probabilities that affect various aspects of a 
simulation allows different scenarios to be explored. Parameters can have many dimensions (such 
as age, gender, and year) and are stored in .dat data files. In RiskPaths, there is one parameter 
file, Base(RiskPaths).dat, which stores parameters such as death probabilities by age and risks of 
first pregnancy by age group. More complex models will usually incorporate more than one .dat 
file. 
Table: Modgen has a powerful cross-tabulation facility built in to report aggregated results in the 
form of tables. There are two central elements of a table declaration—its captured dimensions 
Martin Spielauer                                                                                The RiskPaths teaching model 
17 
(defining when an actor enters and leaves a cell) and its analysis dimension (recording what 
happens while an actor is in that cell). When running simulations, the tabulations to fill a table 
are created on the fly, thus removing the need to create and write to large temporary interim files 
for subsequent reporting.  Several examples of  table declarations  will be shown  later in  this 
chapter for RiskPaths.  
 Organization of files 
The Modgen code of RiskPaths is organized into eight separate .mpp files, while all RiskPaths 
parameter values (because RiskPaths is a simple model) are contained in just a single .dat file. In 
principle, a model developer has complete freedom to decide how to organize the Modgen code 
in different files, but a modular organization as found in RiskPaths is recommended.  
Figure 6: RiskPaths file organization 
General modules 
Filename 
Simulation engine 
RiskPaths.mpp 
Core actor file 
PersonCore.mpp 
Table definitions 
Tables.mpp 
Output tracking 
Tracking.mpp 
French language translations 
RiskPathsFR.mpp 
Behavioural modules 
Filename 
Mortality 
Mortality.mpp 
Fertility 
Fertility.mpp 
Union formations and dissolutions 
Unions.mpp 
Parameter file 
Filename 
Parameters of Baseline Scenario 
Base(RiskPaths).dat 
Note that the .mpp code files often contain comments that resemble labels. Such comments are 
placed beside the declarations of symbols such as states, state levels, parameters, tables and table 
dimensions. Modgen does in fact interpret these comments as labels and subsequently uses them 
when tables or parameters are displayed within Modgen’s visual interface. These labels are also 
used in the model’s automatically generated encyclo paedic help file. Code comments that are 
used as labels begin with a two-character language identifier, e.g. //EN Union status. Many such 
comments can be seen in the code examples that follow for RiskPaths. 
Fore more detailed descriptions of modules, functions and events, notes following the following 
syntax example can be placed in the code. These notes – besides documenting the code - are used 
in the automatically generated encyclopaedic help file.   
/*NOTE(Person.Finish, EN) 
The Finish function terminates the simulation of an actor. 
*/ 
Martin Spielauer                                                                                The RiskPaths teaching model 
18 
7.1  RiskPaths.mpp (the main simulation file) 
This  file  contains  the  code  essential  for  the  definition  of  the  model  type  (e.g.  case-based, 
continuous time) as well as the simulation engine, i.e. the code that runs the whole simulation. 
Because RiskPaths is a case-based model, the simulation engine code loops through all cases and 
processes the event queues of each case. The file also identifies the languages of the model. The 
code of this file is mostly model independent within a class of models (e.g. continuous time, 
case-based) and a version of it is provided automatically when using Modgen’s built-in wizards 
to start a new Modgen project.  
For the development of our case-based, continuous time cohort RiskPaths model with an actor 
‘Person’ the code provided by the wizard requires v ery few modifications. The full code of this 
.mpp file is less than one page in length.  
7.2  PersonCore.mpp  
The only actor in RiskPaths is a person. In the file PersonCore.mpp, we have organized the code 
which is part of the actor declaration but not directly related to a specific behaviour. The file 
contains two age clocks defined as self-scheduling states (integer_age and age_status) and two 
actor functions, Start() and Finish(), which are performed at the creation of an actor and at her 
death, respectively.  
In the Start() function we initialize the states time and age to 0. Both states are automatically 
created and maintained by Modgen and can only be changed in the Start() function. Their types 
depend on the model type; because RiskPaths is a continuous time model, time and age are 
continuous states.  
The Finish() function must be called at the death event of an actor. Its role is to remove the actor 
from tables and from the simulation, and to recuperate any computer memory used by the actor.  
All states and actor functions are declared in an “ “ actor Person { };” block. To allow modularity in 
the organization of code by different life course domains, there can be multiple actor blocks in a 
project, typically one for each behavioural file. 
The first code section of this module contains three type definitions. We first define a range 
LIFE.  
range LIFE   
//EN Simulated age range 
0,100 
}; 
Range is a Modgen type which defines a range of integer values. RiskPaths limits the possible 
age range of persons to 100 years. This type will be used to declare a derived state containing the 
age of a person in completed years. The second type definition will be used to divide continuous 
age into 2.5 year age intervals starting at age 15.   
Martin Spielauer                                                                                The RiskPaths teaching model 
19 
partition AGEINT_STATE  
//EN 2.5 year age intervals 
15, 17.5, 20, 22.5, 25, 27.5, 30, 32.5, 35, 37.5, 40 
}; 
The  third  definition  is  a  classification  of  union  types.  In  general,  if  a  range,  partition,  or 
classification is used in several files, it is good practice to define it in the core actor file.   
classification UNION_STATE  
//EN Union status 
US_NEVER_IN_UNION, 
//EN Never in union 
US_FIRST_UNION_PERIOD1,  
//EN First union < 3 years 
US_FIRST_UNION_PERIOD2,  
//EN First Union > 3 years 
US_AFTER_FIRST_UNION, 
//EN After first union   
US_SECOND_UNION,   
//EN Second union 
US_AFTER_SECOND_UNION 
//EN After second union 
};
In the following code segment we declare two derived actor states and two functions. The derived 
states for time intervals are used to change the values of parameters that vary over time. In our 
model integer_age is needed because mortality risks are dependent on age in years, whereas 
age_status comes into play because baseline risks for first conception and first union formation 
are  modelled  to change in  2.5 year  intervals after  the  15th birthday.  Both  integer_age  and 
age_status have to be maintained over the simulation. The Modgen concept of derived states 
allows us to have them maintained automatically. Both are derived from the state age (which is a 
special state, as it is generated and maintained automatically by Modgen).  In order to split up age 
into the time intervals defined in the AGEINT_STATE partition, we make use of the Modgen 
function self_scheduling_split. The second derived state, integer_age, could be directly obtained 
using the Modgen function self_scheduling_int. In order to ensure that its value stays in  the 
possible  range of  LIFE we  convert it  to  type LIFE, which  is done  by  the Modgen  macro 
COERCE.   
actor Person  
//EN Current age interval 
int age_status = self_scheduling_split(age, AGEINT_STATE); 
//EN Current integer age 
LIFE integer_age = COERCE( LIFE, self_scheduling_int(age) ); 
//EN Function starting the life of an actor 
void Start(); 
//EN Function finishing the life of an actor 
void Finish(); 
}
Martin Spielauer                                                                                The RiskPaths teaching model 
20 
The remaining code of this module is the implementation of the Start() and Finish() functions. 
The  Finish()  function  is  left  empty  as  we  do  not  require  any  actions,  other  than  those 
automatically performed by Modgen, to take place when an actor dies.  
void Person::Start() 
// Age and time are variables automatically maintained by  
// Modgen. They can be set only in the Start function 
age = 0; 
time = 0; 
/*NOTE(Person.Finish, EN) 
The Finish function terminates the simulation of an actor. 
*/ 
void Person::Finish() 
// After the code in this function (if any) is executed, 
// Modgen removes the actor from tables and from the simulation. 
// Modgen also recuperates any memory used by the actor. 
7.3  Behavioural Files 
In  RiskPaths  we  distinguish  three  groups  of  behaviours:  mortality,  fertility  and  union 
formation/dissolution.  Accordingly  we  have  organized  the  code  into  three  .mpp  files: 
Mortality.mpp, Fertility.mpp and Unions.mpp. Behavioural files are typically arranged in three 
sections: 
 Declaration of parameters 
 Declarations of actor states and events 
 Implementation of events 
7.3.1  Mortality.mpp 
This file defines the mortality event that ends the life of the simulated actor. Mortality.mpp is a 
typical behavioural module, and we follow a standard organization of the code: type definitions, 
parameter declarations, actor declarations and event implementations.  
Parameter declarations 
Mortality is parameterized by death probabilities by age; thus, the probability to survive another 
year changes at each birthday. We also introduce a parameter which allows us to ‘switch off’ 
mortality. When it is used, every actor reaches the maximum age of 100 years (which can be 
useful for some types of fertility analysis). Figure 7 displays the mortality parameter tables of the 
RiskPaths application.  
Documents you may be interested
Documents you may be interested