Insight network: Difference between revisions

Revision as of 13:01, 2 October 2018

This page is a knowledge crystal of subtype method. The page identifier is Op_en3861
Moderator:Jouni (see all)

Upload data {{#opasnet_base_link:Op_en3861}}

Insight networks are graphical representations of a particular situation, where the objects described are causally related to each other. In addition, the diagrams contain non-causal elements such as value judgements or inferences based on data. Insight networks utilise the ideas of directed acyclic graphs, but they have additional features.

Question

What notation is simple and flexible enough so that it can be used to represent all major issues related to a policy situation? It must be usable in both graphical and data formats.

Answer

+ Show code - Hide code

# This is code Op_en3861/ on page [[Insight network]]

############### Create global variables at file global.R

library(OpasnetUtils)

objects.latest("Op_en3861", code_name="insightNetwork") # [[Insight network]] insightNetwork

# If you want to use alternative objects, fetch them here.

insightNetwork <- EvalOutput(insightNetwork,verbose=TRUE)

cat("This code uses the following objects:\n")
oprint(insightNetwork@dependencies)

cat("The newtork data comes from these sources:\n")
oprint(meta)

insightTables <- makeInsightTables(meta) # You can update (part of) insightTables by rerunning with (partial) meta.

graphTable <- makeGraphTable(verbose=FALSE) # Produces a table in standard format

gr <- makeInsightGraph(graphTable) # Creates a DiagrammeR graph object

ui <- makeUi() # Shiny user interface

shinyApp(ui, server)

For examples of using insight networks, see op_fi:Ympäristöterveysindikaattori.

Rationale

Process

**The parameters of an argument and possible combinations.**
Id	Title	Content	Sign	Target	Type	Paradigm	Relation	Result	Comment
arg1234	Short title for display	Actual argument	Signature	arg9876	relevance	science	attack	1	If paradigm changes (all else equal), relation may change, although typically only the result changes.
arg1234	Short title for display	Actual argument	Signature	arg5555	relevance	science	comment	0
arg1234	Short title for display	Actual argument	Signature	arg6666	truth	science	defense	1	Truth refers to the truth of the target
arg1234	Short title for display	Actual argument	Signature	arg1234	selftruth	science	attack	0	Selftruth refers to the truth of the argument itself, unlike other types that refer to the target.
arg1234	Short title for display	Actual argument	Signature	arg9876	relevance	toldya	comment	0
arg1234	Short title for display	Actual argument	Signature	arg5555	relevance	toldya	defense	1
arg1234	Short title for display	Actual argument	Signature	arg6666	truth	toldya	attack	0
arg1234	Short title for display	Actual argument	Signature	arg1234	selftruth	toldya	comment	1	The relation in case of type=selftruth is irrelevant and is ignored.
									These are unique to an argument
									These are unique to an argument-target pair
									These are unique to a triple of argument-target-paradigm

Insight networks have been described in a scientific article manuscript From open assessment to shared understanding: practical experiences#Insight networks. Objects and their relations used in open policy practice are described on page Open policy ontology.

There is a need for methods facilitating the flow of information and understanding between science and policy. The principle is to describe a risk situation in a formal manner. Insight networks contain items along a causal pathway (or network) from e.g. abatement strategies to emissions to dispersion to exposure to effects. They have been designed to describe also non-causal connections such as non-causal reasoning, values, preferences, and arguments.

These diagrams use graph theory with vertices (or nodes) and arcs (or arrows). They are used to describe and define all the pieces needed for a description of the situation under scrutiny. Diagrams may be produced with any graphics software, providing that calculation functions are not required. If calculations are needed, we recommend the use of R software and OpasnetUtils package.

**Parameter properties**
Parameter	Css selector (Opasnet page scraping)	Requirements
Id	.argument attr=id	Must start with a letter
Title	.argument .title	Short text. Is shown on insight graph as node label
Content	.argument .content	Text, may be long. Is shown with hover on graph
Sign	.argument .sign a:first-of-type	Must contain a link to participant's user page. Is shown with hover on graph
Target	NA	Previous argument one level up, or the statement for arguments on the first level
Type	.argument i.type	One of the three: relevance, truth, or selftruth (or "both", which is depreciated)
Paradigm	.argument .paradigm	Each paradigm should be described on a dedicated page. The rules implemented must be clear
Relation	.argument .relation	Is one of these: attack, defense, comment. "Branches" are typically uninteresting and ignored.
Result	relevance= .argument .relation attr=color. Gray= 0 (irrelevant), other=1 (relevant). truth= .argument .relation attr=color. Gray=0 (untrue), other=1 (true) selftruth= .argument .selftruth attr=color. Gray=0 (untrue), other=1 (true)	Truthlikeness of the relation. Either 1 or 0

This is the process how data flows into insight diagrams:

List of data tables of different insight diagrams is found from https://yhteistyotilat.fi/wiki08/x/1oGxAg. It has the following columns:
- Ilmio: Name of the phenomenon. This will become the name of a csv data file.
- Id: Identifier of the phenomenon. This will be used in Oldid of the items and relations.
- Tyyppi: Type of the table. In practice, it defines the columns that the data table has. Different types are listed on #Types of insight network tables.
- URL: Location of the data table. If the URL contains "google.com", it is assumed to be a google sheet. If the type (Tyyppi) is "keskustelu", it is assumed to be an Opasnet page with discussions. Otherwise, it is assumed to be a table on a web page that can be scraped with read_html() function.
- Taulu: If the data is a table on a web page, it is the number of the table on that page. If the data is a discussion, it is the number of discussion; missing value means that all discussions on that page are read.
- Alkurivi: In case of google sheets, it is the first row with actual data.
- Kuvaus: Description of the table, with possible links to relevant description page.

All data tables and discussions are listed, formatted and saved as csv files in a zip file called op_fi:File:Näkemysverkkojen tietotauluja.zip. From there, the data can be accessed from within Opasnet Rtools. (The code scraping web pages does not work in Opasnet, although it is stored there.) Little formatting is done here, mainly the column titles are standardised. But the number and type of columns is not changed.

In the next phase, each csv file is opened, interpreted, and defined as items and relations. This is done in code Op_fi5810/graphs on page op_fi:Ympäristöterveysindikaattori. All these are saved as a DiagrammeR graph, and each topic may be separately selected as a subgraph.

0094: . Are Tehtäväkokonaisuus, Osiotyyppi, JHS-luokka actually types of objects, or are they just indices. Yes, they should be indices and the objects relate to them with "has index". Correct table 4. --Jouni (talk) 20:46, 17 July 2018 (UTC) (type: ; paradigms: science: relevant attack)

Data

Graphical properties of objects and relations

Graphical properties of objects and relations(-)
Obs	Property	Value	Parameter	Result	Description
1	default	default	node.shape	circle	Default values unless something else is specified
2	default	default	node.sides	4
3	default	default	node.skew	0
4	default	default	node.fillcolor	white
5	default	default	node.fontsize	11
6	default	default	node.height	0.5
7	default	default	node.width	0.5
8	default	default	node.color	brown
9	default	default	node.penwidth	2
10	default	default	node.fontcolor	black
11	default	default	node.distortion	0
12	default	default	edge.color	grey
13	default	default	edge.fontsize	10	Not currently used
14	default	default	edge.fontcolor	grey
15	default	default	edge.style	dotted
16	default	default	edge.penwidth	2
17	default	default	edge.arrowsize	1	Not currently used
18	type	unknown	node.fillcolor	yellow	This formatting is used if there are undefined objects
19	type	unknown	node.color	green
20	type	substance	node.shape	circle	Substantive type object
21	type	substance	node.fillcolor	skyblue2	Substantive type object
22	type	knowledge crystal	node.color	gold	Knowledge crystal type object (including ovariables and key ovariables)
23	type	option	node.color	palevioletred	Option for a decision
24	type	option	node.fillcolor	white	Option for a decision
25	type	index	node.shape	polygon	Index or other classifying determinant
26	type	index	node.sides	4
27	type	index	node.skew	0.5
28	type	index	node.fillcolor	purple1
29	type	index	node.height	0.3
30	type	graph	node.shape	polygon	Index or other classifying determinant
31	type	graph	node.sides	3
32	type	graph	node.fillcolor	pink
33	type	assessment	node.shape	polygon	Assessment
34	type	assessment	node.sides	8
35	type	assessment	node.fillcolor	purple1
36	type	stakeholder	node.shape	hexagon	Stakeholder type object
37	type	stakeholder	node.fillcolor	khaki1	Stakeholder type object
38	type	stakeholder	node.width	0.8	Stakeholder type object
39	type	method	node.shape	polygon	Method type object
40	type	method	node.sides	6	Method type object
41	type	method	node.fillcolor	purple1	Method type object
42	type	process	node.shape	pentagon	Process type object
43	type	process	node.fillcolor	purple1	Process type object
44	type	action	node.fillcolor	pink	Process type object
45	type	task 1	node.color	brown	Illustration of the responsible organisation of the task
46	type	task 2	node.color	yellow	Illustration of the responsible organisation of the task
47	type	task 3	node.color	blue	Illustration of the responsible organisation of the task
48	type	task 4	node.color	green	Illustration of the responsible organisation of the task
49	type	task 5	node.color	red	Illustration of the responsible organisation of the task
50	type	decision	node.shape	rectangle	Decision type object
51	type	decision	node.fillcolor	red	Decision type object
52	type	data	node.shape	rectangle	Data type object
53	type	data	node.fillcolor	gold	Data type object
54	type	objective	node.shape	diamond	Objective type object
55	type	objective	node.fillcolor	yellow	Objective type object
56	type	objective	node.width	0.8	Objective type object
57	type	publication	node.fillcolor	gray	Publication type object
58	type	statement	node.shape	polygon	Argument type object
59	type	statement	node.sides	4	Argument type object
60	type	statement	node.width	0.8	Argument type object
61	type	statement	node.distortion	-0.5	Argument type object
62	type	true statement	node.fillcolor	gold	Argument type object
63	type	false statement	node.fillcolor	gray	Argument type object
64	type	fact opening statement	node.fillcolor	lightskyblue1	Argument type object
65	type	value opening statement	node.fillcolor	palegreen1	Argument type object
66	type	fact closing statement	node.fillcolor	skyblue	Argument type object
67	type	value closing statement	node.fillcolor	springgreen	Argument type object
68	type	fact discussion	node.fillcolor	skyblue	Argument type object. Not neede?
69	type	value discussion	node.fillcolor	springgreen	Value judgement type object. Not needed?
70	type	risk factor	node.color	pink	Additional information about object class
71	type	indicator	node.color	brown	Additional information about object class
72	type	indicator	node.fillcolor	gold	Additional information about object class
73	type	arviointikriteeri	node.color	orange	Not quite clear what criteria objects are: indicators or value statements, or something else
74	type	task	node.color	green	Additional information about object class
75	type	data	node.color	orange	Additional information about object class
76	type	health organisation	node.color	yellow	Additional information about object class
77	Relation	causal link	edge.color	black	Causal link
78	Relation	causal link	edge.style	solid	Causal link
79	Relation	positive causal link	edge.fontcolor	green	Causal link
80	Relation	negative causal link	edge.fontcolor	red	Causal link
81	Relation	participatory link	edge.color	purple	Participatory link
82	Relation	participatory link	edge.style	dashed	Participatory link
83	Relation	operational link	edge.color	black	Operational link
84	Relation	operational link	edge.style	dashed	Operational link
85	Relation	evaluative link	edge.color	green	Evaluative link
86	Relation	relevant attack	edge.color	red	Attacking argument
87	Relation	relevant defense	edge.color	green	Defending argument
88	Relation	relevant comment	edge.color	blue	Commenting argument
89	Relation	irrelevant argument	edge.color	gray	Invalid argument
90	Relation	argumentative link	edge.style	dotted	Argumentative link
91	Relation	argumentative link	edge.penwidth	4	Argumentative link
92	Relation	referential link	edge.color	red	Referential link
93	Relation	referential link	edge.style	dashed	Referential link

Types of insight network tables

Table types(-)
Obs	Type	Column names	Dummy
1	oletus	type, Item, label, Relation, Object, Description, URL	1
2	sotearv	Ikaryhma, AHVK, Item, Teema, Ulottuvuus, Osiotyyppi, Tietolahde, KUVA id, Sotkanet id, JHS-luokka, Ryhman perustelut	1
3	hnh2035	Teema, Oldid, Item, Ohjelma, Vastuu, Aikajanne, Vaativuus, Kustannukset, Kust.kaupungille, Hyodyt.kaupungille, Kust.muille, Hyodyt.muille, Paastovahenema, Muut.vaikutukset, Seurantaindikaattori, Esimerkki, Description	1
4	kuvaind	Oldid, Item, Teema, Aihe2, Aihe3, Tietopaketti1, Tietopaketti2, Tietopaketti3, Mita.mittaa, Mitta-arvo ja muodostaminen, Tietolahde, Tietolahde ja tausta, Tuotannossa, Tietotarpeen taso, Tuottamistaso, Kansainvaliset tietotoimitukset, Muut kayttotarkoitukset, Description	1
5	sitra100	Item, Suuruus, Teema, URL	1
6	hvkertomus	Oldid, Item, Teema, Vaestoryhma, Lahde ja muodostaminen, Mita mittaa, KUVA-mittarissa, Hyte-kertoimessa, Arviointiraportissa, Hyvinvointikertomuksessa, Perustelut	1
7	hnhos	Oldid, type, Item, Description	1
8	keskustelu	Oldid, type, Item, label, Relation, Object, Description, URL	1
9	arviointi	Oldid, type, Item, Relation, Object, Description, URL	1

Calculations

Making insight graphs

+ Show code - Hide code

# This is code Op_en3861/splizzeria on page [[Insight network]]
library(OpasnetUtils)

#' Split cells contents into vectors
#' 
#' splizzeria function takes a data.frame and splits entries in cells of certain columns into separate rows. The idea is to make entries easier.
#' 
#' @param df data.frame to be splitted
#' @param cols names of columns that have the splittable contents
#' @param split splitting character that separates individual entries in the cells 
#' @return data.frame with the same columns but (possibly) more rows than df.

splizzeria <- function(
  df,
  cols,
  split=","
) {  
  require(reshape2)
  for(i in cols) {
    d <- as.character(df[[i]])
    d[d==""] <- NA # Because "" is incorrectly strsplitted
    d <- melt(strsplit(d, split=split), value.name=i)
    df$L1 <- 1:nrow(df)
    df <- merge(df[colnames(df)!=i], d)
    df[[i]] <- trimws(df[[i]])
    df[is.na(df[[i]]),i] <- ""
    df$L1 <- NULL
  }
  return(df)
}

objects.store(splizzeria)
cat("Function splizzeria stored.\n")

+ Show code - Hide code

# This is code Op_en3861/fillprev on page [[Insight network]]
library(OpasnetUtils)

#' Filling empty cells
#' 
#' fillprev fills empty cells in a data.frame by using content from the previous row.
#' 
#' @param df data.frame to be filled
#' @param cols vector of column names or positions to be filled.
#' @return Returns a data.frame with the same shape as df.

fillprev <- function(df, cols) {
  out <- df
  for(i in cols) { 
    for(j in 2:nrow(out)) {
      if(out[j,i] %in% c("", NA)) out[j,i] <- out[j-1,i]
    }
  }
  return(out)
}

objects.store(fillprev)
cat("Function fillprev stored.\n")

+ Show code - Hide code

# This is code Op_en3861/grspec on page [[Insight network]]
library(OpasnetUtils)

#' Updating graph properties
#' 
#' grspec (graph specifier) replaces the default properties with the item-specific ones
#' 
#' @param df data.frame whose properties are to be replaced
#' @param Parameter name of parameter as defined in prop_spec
#' @param prop_spec data.frame with specific properties
#' @return data.frame with the shape of df with an additional column whose name comes from Parameter

grspec <- function(df, Parameter, prop_spec) { 
  out <- prop_spec[prop_spec$Parameter==Parameter,]
  coln <- ifelse("Object" %in% colnames(df), "Relation","Item")
  out <- out$Result[match(df[[coln]], out$Item)]
  return(as.character(out))
}

objects.store(grspec)
cat("Function grspec stored.\n")

+ Show code - Hide code

# This is code Op_en3861/makeInsightGraph on page [[Insight network]]
library(OpasnetUtils)

#' Making insight network graph object
#' 
#' makeInsightGraph is a function for fetching data for insight networks and making a graph object
#'
#' @param a is data.frame defining nodes and edges with at least columns: Oldid, type, Item, label, Relation, Object, Description. Other columns for nodes such as URL are allowed.
#' @return list of two data.frames: nodes_df and edges_df. These can be directly given as parameters for DiagrammeR::create_graph.

makeInsightGraph <- function(a) {
  require(OpasnetUtils)
  require(DiagrammeR)
  
  for(i in 1:ncol(a)) {
    a[[i]] <- gsub("[\"']", " ", a[[i]])
  }
  
  # First fetch the graphical styles of properties from [[Insight network]]
  
  prop_gen <- opbase.data(
    "Op_en3861", # [[Insight network]]
    subset="Graphical properties of objects and relations"
  )
  prop_gen <- splizzeria(prop_gen, c("Property","Value"))
  
  dbltst <- duplicated(prop_gen[c("Property","Value","Parameter")])
  if(any(dbltst)) {
    cat("There are double definitions in Insight networks/Graphical properties of objects and relations.\n")
    oprint(prop_gen[dbltst,])
  }
  
  ## Replace default setting with additional class info
  
  clas <- splizzeria(
    opbase.data("Op_en7783", subset="Hierarchies"), # [[Open policy ontology]]
    c("Class","Result")
  )[-1]
  # Clas for nodes (type)
  clas_n <- merge(a, clas, by.x="type", by.y="Result")
  clas_n <- unique(data.frame( # Currently looks at immediate, not recursive, hierarchies only.
    Item = rep(clas_n$Item,2),
    Class = c(clas_n$type,clas_n$Class),
    stringsAsFactors = FALSE
    #    clas_n[c("type","Item")],
    #    data.frame(type=clas_n$Class,Item=clas_n$Item)
  ))
  # Clas for edges (Relation)
  clas_e <- merge(a, clas, by.x="Relation", by.y="Result")
  clas_e <- unique( # Currently looks at immediate, not recursive, hierarchies only.
    data.frame(
      Relation=rep(clas_e$Relation,2),
      Class=c(clas_e$Relation,clas_e$Class),
      stringsAsFactors = FALSE
    )
  )
  
  # Create nodes  
  
  a$label <- ifelse(is.na(a$label), ifelse(is.na(a$Item), a$Oldid, substr(a$Item,1,30)), a$label)
  
  # Find Oldid that matches the Object based on Item, label, Oldid, or none (in this order)
  tmp  <- a$Oldid[match(a$Object, a$Item)]
  tmp2 <- a$Oldid[match(a$Object, a$label)]
  tmp  <- ifelse(is.na(tmp),tmp2,tmp)
  tmp2 <- a$Oldid[match(a$Object, a$Oldid)]
  tmp  <- ifelse(is.na(tmp), tmp2,tmp)
  tmp  <- ifelse(is.na(tmp), a$Object,tmp)
  a$Object <- tmp
  
  nodes <- orbind(
    a[!colnames(a) %in% c("Relation","Object")],
    data.frame(
      Oldid=a$Object,
      Item=a$Object,
      label=substr(a$Object,1,30),
      stringsAsFactors = FALSE
    )
  )
  
  nodes <- nodes[!(duplicated(nodes$Item) | is.na(nodes$Item) | nodes$Item==""),]
  nodes$id <- 1:nrow(nodes)
  nodes$tooltip <- paste0(
    nodes$label, ". ",
    ifelse(nodes$label == nodes$Item, "", paste0(nodes$Item, ". ")), 
    ifelse(is.na(nodes$Description), "", paste0("\n", nodes$Description)),
    nodes$Description,
    " (", nodes$Oldid, "/", nodes$id,")"
  )
  
  # Create edges and flip unpreferred relations to their inverse relations
  
  inver <- opbase.data("Op_en7783", subset="Inverse relations")
  
  cols <- intersect(c("Oldid","Item","Relation","Object","Description","Edgedescription"),colnames(a))
  edges <- a[!(is.na(a$Object) | a$Object=="") , cols]
  flip <- edges$Relation %in% inver$Result
  tmp <- edges$Oldid
  edges$Oldid[flip] <- edges$Object[flip]
  edges$Object[flip] <- tmp[flip]
  edges$Relation[flip] <- as.character(inver$Preferred[match(edges$Relation, inver$Result)][flip])
  edges$id <- 1:nrow(edges)
  edges$from <- match(edges$Oldid, nodes$Oldid)
  edges$to <- match(edges$Object, nodes$Oldid)
  edges$rel<-edges$Relation # Not clear what rel is used for
  edges$label <- edges$Relation
  edges$labeltooltip <- paste0(edges$label, "(", edges$Oldid, "/", edges$id, ")")
  
  # Create a data.frame containing item-specific graph settings
  
  prop_spec <- merge(
    data.frame(Item = union(nodes$Item, edges$Relation)),
    prop_gen[prop_gen$Property=="default",c("Parameter","Result")]
  )
  
  # Replace default settings with property-specific settings
  for(i in 1:nrow(prop_gen)) {
    if(prop_gen$Property[i] != "default") {
      tst <- union( # Names of items that should have the property replaced
        nodes$Item[nodes[[prop_gen$Property[i]]]==prop_gen$Value[i]],
        c(edges$Relation[edges[[prop_gen$Property[i]]]==prop_gen$Value[i]],
          clas_n$Item[clas_n$Class == prop_gen$Value[i]],
          clas_e$Relation[clas_e$Class == prop_gen$Value[i]]
        )
      )
      prop_spec$Result[prop_spec$Item %in% tst & prop_spec$Parameter==prop_gen$Parameter[i]] <- prop_gen$Result[i]
    }
  }
  
  # Apply item-specific settings to nodes and edges
  nodes$fillcolor <- grspec(nodes,"node.fillcolor", prop_spec)
  nodes$color <- grspec(nodes,"node.color", prop_spec)
  nodes$fontcolor <- grspec(nodes,"node.fontcolor", prop_spec)
  nodes$fontsize <- as.numeric(grspec(nodes,"node.fontsize", prop_spec))
  nodes$shape <- grspec(nodes,"node.shape", prop_spec)
  nodes$sides <- as.numeric(grspec(nodes,"node.sides", prop_spec))
  nodes$width <- as.numeric(grspec(nodes, "node.width", prop_spec))
  nodes$height <- as.numeric(grspec(nodes,"node.height", prop_spec))
  nodes$penwidth <- as.numeric(grspec(nodes, "node.penwidth", prop_spec))
  nodes$orientation <- as.numeric(grspec(nodes,"node.orientation", prop_spec))
  nodes$skew <- as.numeric(grspec(nodes,"node.skew", prop_spec))
  nodes$distortion <- as.numeric(grspec(nodes, "node.distortion", prop_spec))
  edges$fontcolor <- grspec(edges,"edge.fontcolor", prop_spec)
  edges$penwidth <- grspec(edges,"edge.penwidth", prop_spec)
  edges$color <- grspec(edges,"edge.color", prop_spec)
  edges$style <- grspec(edges,"edge.style", prop_spec)
  
  return(
    create_graph(
      nodes_df=nodes,
      edges_df=edges
    )
  )
}

objects.store(makeInsightGraph)
cat("Function makeInsightGraph stored.\n")

Fetch data from the web: makeInsightTables function

+ Show code - Hide code

# This is code Op_en3861/makeInsightTables on page [[Insight network]]
library(OpasnetUtils)

#' @title makeInsightTables is a function for scraping web sources given in meta table and convert those to data.frames for further use.
#' @param meta table containing information about the tables, assessments, and discussions to scrape. Typically contains columns Name, Id, Type, URL, Table, Firstrow, Description.
#' @param types table with standardized column names that will be used. meta$Type matches with Type column. Other required columns: Column names.
#' @param savecsv TRUE if the created tables are to be saved as csv files. Default is FALSE.
#' @return a list of data.frames, including the original meta table as $meta.

makeInsightTables <- function(
  meta,
  types = opbase.data("Op_en3861", subset="Table types"),
  savecsv = FALSE
) {
  require(OpasnetUtils)
  
  # Call Op_fi5849/inaightNetwork first so you don't need these.
  #  objects.latest("Op_en3861",code_name="scrape.functions") # [[Insight network]] scrape.discussion .gssheet .webtable
  #  objects.latest("Op_en3861",code_name="scrape.assessment") # [[Insight network]] scrape.assessment
  
  if(!exists("insightTables")) insightTables <- list() # Existing insightTale can be updated partly or wholly

  if("ovariable" %in% class(meta)) meta <- meta@data # meta is originally an ovariable
  for(i in 1:ncol(meta)) meta[[i]] <- as.character(meta[[i]])
  for(i in c("Table","Firstrow")) meta[[i]] <- as.numeric(meta[[i]])
  meta$Name <- gsub("[Öö]","o",gsub("[ÄÅäå]","a",meta$Name))
  
  for(i in 1:nrow(meta)) {
    cat(i, meta$Name[i],"\n")
    if(grepl("google.com", meta$URL[i])) {
      out <- scrape.gssheet(meta$URL[i], meta$Firstrow[i])
    } else {
      if(meta$Type[i]=="keskustelu") {
        if(is.na(meta$Table[i])) j <- NULL else j <- as.numeric(meta$Table[i])
        out <- scrape.discussion(meta$URL[i], j)[[1]]
      } else {
        if(meta$Type[i] %in% c("arviointi","assessment")) {
          tmp <- strsplit(meta$URL[i], split="/")[[1]]
          objects.latest(tmp[1],tmp[2])
          dummy <- EvalOutput(get(tmp[3]))
          out <- scrape.assessment(get(tmp[3]))
          rm(dummy)
        } else {
          out <- scrape.webtable(meta$URL[i],meta$Table[i])
        }
      }
    }
    coln <- trimws(strsplit(as.character(types$`Column names`[types$Type==meta$Type[i]]),split=",")[[1]])
    if(colnames(out)[1]=="Obs") coln <- c("Oldid",coln)
    colnames(out) <- coln
    insightTables[[meta$Name[i]]] <- out
    
    #    if(savecsv) {
    #      wr#ite.csv(
    #        out,
    #        paste0(meta$Name[i],".csv"),
    #        quote=TRUE, row.names=FALSE, fileEncoding="UTF-8"
    #      )
    #    }
  }
  
  #  if(savecsv) {
  #    wr#ite.csv(meta, "meta.csv",fileEncoding = "UTF-8")
  #    # Zippaus ei jostain syystä toimi minun uudella koneella
  #    zip("~/Näkemysverkkojen tietotauluja.zip", paste0(c("meta",meta$Name),".csv"))
  #  }
  insightTables$meta <- meta
  return(insightTables)
}

objects.store(makeInsightTables)
cat("Function makeInsightTables stored.\n")

Insight network

This is an overall ovariable that automatically fetches all dependencies.

+ Show code - Hide code

# This is code Op_en3861/insightNetwork on page [[Insight network]]
library(OpasnetUtils)

insightNetwork <- Ovariable(
  "insightNetwork",
  dependencies = data.frame(
    Name = c(
      "meta",
      "seeds",
      "objtypes",
      "makeInsightTables",
      "scrape.discussion","scrape.gssheet","scrape.webtable",
      "scrape.assessment",
      "makeGraphTable",
      "fillprev",
      "splizzeria",
      "grspec",
      "makeInsightGraph",
      "makeUi",
      "server"
    ),
    Ident = c(
      "Op_fi5849/meta",
      "Op_fi5849/seeds",
      "Op_fi5849/objtypes",
      "Op_en3861/makeInsightTables",
      rep("Op_en3861/scrape.functions",3), # These will be moved to OpasnetUtils package
      "Op_en3861/scrape.assessment",
      "Op_fi5849/makeGraphTable",
      "Op_en3861/fillprev",
      "Op_en3861/splizzeria",
      "Op_en3861/grspec",
      "Op_en3861/makeInsightGraph",
      "Op_en3861/makeUi",
      "Op_en3861/server"
    ),
    Description = c(
      "Contains metadata for the data tables and discussions to be fetched. Source: [[:op_fi:Näkemysverkko]]",
      "Seed nodes to be used as starting points for different graphs. Source: [[:op_fi:Näkemysverkko]]",
      "List of object types that you may deselect from the shiny graph. Source: [[:op_fi:Näkemysverkko]]",
      "Makes insight tables with minimal formatting. Source: [[Insight network]]",
      "Fetches data from a discussion", "Fetches data from a google sheet", "Fetches data from a regular webtable",
      "Fetches data from an assessment ovariable",
      "Converts insight tables to standard formatting. Source: [[:op_fi:Näkemysverkko]]",
      "Fills empty cells with content from a previous cell in that column. Source: [[Insight network]]",
      "Splits cell contents from a splitting character so that all other cells in that row multiply. Source: [[Insight network]]",
      "Updates generic graph formatting to object-specific formatting. Source: [[Insight network]]",
      "Creates DiagrammeR graph from data in standard structure. Source: [[Insight network]]",
      "Shiny user interface. Usage: ui <- makeUi(). Source: [[Insight network]]",
      "Shiny server code. Source: [[Insight network]]"
    )
  ),
  formula=function(...) {
    require(DiagrammeR)
    require(shiny)

    return(data.frame(Result=0))
  }
)

objects.store(insightNetwork)
cat("Ovariable insightNetwork stored.\n")

Shiny server

+ Show code - Hide code

# This is code Op_en3861/makeUi on page [[Insight network]]
library(OpasnetUtils)

################ Create Shiny user interface at file ui.R

ui <- function(request) {
  basicPage(
    sidebarLayout(
      sidebarPanel(
        selectInput("topic","Topic",unique(seeds@data$Topic)),
        selectizeInput(
          "addnodes",
          "Add seed nodes by label",
          sort(gr$nodes_df$label),
          selected = NULL,
          multiple = TRUE,
          options = NULL
        ),
        selectizeInput(
          "addnodesByOldid",
          "Add seed nodes by Oldid",
          sort(gr$nodes_df$Oldid),
          selected = NULL,
          multiple = TRUE,
          options = NULL
        ),
        selectizeInput(
          "removenodes",
          "Remove branches starting from nodes",
          sort(gr$nodes_df$label),
          selected = NULL,
          multiple = TRUE,
          options = NULL
        ),
        selectizeInput(
          "ignoreobj",
          "Ignore these object types",
          sort(unique(gr$nodes_df$type)),
          selected=NULL,
          multiple=TRUE,
          options=NULL
        ),
#        selectizeInput( # Commented out because does not have a final idea of how it should be implemented.
#          "ignorerel",
#          "Ignore these edge types",
#          sort(unique(gr$edges$rel)),
#          selected=NULL,
#          multiple=TRUE,
#          options=NULL
#        ),
        checkboxGroupInput("formatting", "Format graph", c(
          "Hide node labels",
          "Hide edge labels",
          "Show legend nodes",
          "Remove branches only"
        )),
        sliderInput("steps", "Number of steps:",  
                    min = 0, max = 5, value = 0),
        bookmarkButton()
      ),
      mainPanel(
#        p("Used object types: "), textOutput("objs"),
#        p("Used edge types: "), textOutput("rels"),
#        as.character(textOutput("remobj")),
#        strsplit(as.character(textOutput("remobj")),split=","),
#        html_nodes(textOutput("remobj"), css="div.shiny-text-output"),
        grVizOutput("plot1")
      )
    )
  )
}

makeUi <- 0

objects.store(ui, makeUi)
cat("Function ui stored (makeUi is dummy). Usage: shinyApp(ui, server, enableBookmarking = 'url')\n")

+ Show code - Hide code

# This is code Op_en3861/server on page [[Insight diagram]].
library(OpasnetUtils)

#### Create shiny server at file server.R

server <- function(input, output, session) {
# grr <- reactive({
  output$plot1 <- renderGrViz({
    nods <- union(c(
      match(seeds@data$Node[seeds@data$Topic==input$topic], gr$nodes_df$Oldid),
      match(input$addnodes, gr$nodes_df$label)),
      match(input$addnodesByOldid, gr$nodes_df$Oldid)
    )
    nods <- nods[!is.na(nods)]
    gr <- deselect_nodes(gr, get_selection(gr))
    gr <- select_nodes_by_id(gr, nods)
    if(input$steps>0) {
      for(i in 1:input$steps) {
        gr <- deselect_nodes(gr,match(input$removenodes, gr$nodes_df$label))
        gr <- trav_both(gr,add_to_selection = TRUE)
      }
      if("Remove branches only" %in% input$formatting) {
        gr <- select_nodes_by_id(gr,match(input$removenodes, gr$nodes_df$label))
      } else {
        gr <- deselect_nodes(gr,match(input$removenodes, gr$nodes_df$label))
      }
    }
    if("Show legend nodes" %in% input$formatting) {
      gr <- select_nodes_by_id(gr, match(seeds@data$Node[seeds@data$Topic=="Selitykset"], gr$nodes_df$Oldid))
    }
    gr <- deselect_nodes(gr, match(input$ignoreobj, gr$nodes_df$type))
#    gr <- deselect_nodes(gr, union( # This should find the INTERCEPT of from is selected AND to is selected and rel  %in% ignorerel.
# However, it is more complicated than that, because we may not want both from and to to disappear, only the one who is further away from core.
# Therefore, we may want to perform this inside the step loop in the same way as cutting branches.
#      tmp$edges_df$from[tmp$edges_df$rel %in% input$ignorerel],
#      tmp$edges_df$to[tmp$edges_df$rel %in% input$ignorerel]
#    ))
    gr
#  })

# output$plot1 <- renderGrViz({
#   gr2 <- grr()
    gr2 <- gr
    gr2$nodes_df$label <- gsub("(.{1,18})(\\s|$)", "\\1\n", gr2$nodes_df$label) # Cut labels to max 18 characters long on one line (except if a word is longer)
    # Alternative possibility is to use strwrap function from {base} or stri_wrap from stringi.
    if("Hide node labels" %in% input$formatting) gr2$nodes_df$label <- ""
    if("Hide edge labels" %in% input$formatting) gr2$edges_df$label <- " "
    
    grViz(generate_dot(transform_to_subgraph_ws(gr2)))
  })
#  output$objs <- reactive({
#    tmp <- grr()
#    sort(unique(tmp$nodes_df$type[tmp$node_selection$node]))
#  })
#  output$rels <- reactive({
#    tmp <- grr()
#    sort(unique(tmp$edges_df$rel[union(
#      tmp$edges_df$id[tmp$edges_df$from %in% tmp$node_selection$node],
#      tmp$edges_df$id[tmp$edges_df$to %in% tmp$node_selection$node] #   )]))
#   })
}

objects.store(server)
cat("Function server stored.\n")

Scrape functions

These functions will be placed in the OpasnetUtils package. For now, it must be manually copied to your code.

+ Show code - Hide code

# This is code Op_en3861/scrape.functions on page [[Insight network]]
library(OpasnetUtils)

#' Scrape structured (pragma-dialectical) discussions
#'
#' scrape.discussion is a function that takes a discussion in Opasnet and converts it to a standard graph table.
#' 
#' @param page URL for the page to read.
#' @param n number of discussion on the page. If NULL, all discussions on the page will be read.
#' @return a list of two data.frames. The first has standard headings for a graph table. The second has columns id, type, title, content, sign, target, type, paradigm, relation, and Result; and is ready for creating ovariables from arguments.

scrape.discussion <- function(page, n=NULL) {
  require(rvest)
  require(xml2)
  require(reshape2)
  discall <- html_nodes(read_html(page), css="div.discussion")
  if(is.null(n)) n <- 1:length(discall)
  out <- list(data.frame(),data.frame())
  for(k in n) {
    disc <- discall[[k]]
    opeS <- html_text(html_nodes(disc, css=".openingStatement"), trim=TRUE)
    cloS <- html_text(html_nodes(disc, css=".closingStatement"), trim=TRUE)
    resd <- html_text(html_nodes(disc, css=".resolved"), trim=TRUE)
    title<- html_text(html_nodes(disc, css="b.title"), trim=TRUE)
    type <- tolower(trimws(substr(html_text(html_nodes(disc, css="font.type")),1,5)))
    type <- gsub("arvok", "value", type)
    type <- gsub("fakta", "fact", type)
    id <- html_attr(disc, "id")
    disc.id <- paste(id, c("openingStatement","closingStatement"),sep=".")
    
    # Make argument and paradigm id's specific to argument-target pairs.
    nods <- html_nodes(disc, css=".argumentation .argument")
    tmp <- html_attr(nods,"id")
    tmp <- paste(tmp, 1:length(tmp),sep="£££")
    xml_attrs(nods) <- lapply(tmp, function(x) {c(class="argument",id=x)})
    for(l in 1:length(tmp)) {
      nodtmp <- html_nodes(nods[[l]], css=".paradigm")
      xml_attrs(nodtmp) <- rep(list(c(id=tmp[l], class="paradigm")), length(nodtmp))
    }
    
    tmp <- data.frame(
      Oldid = disc.id,
      type = paste(type,c("opening statement","closing statement")),
      Item = disc.id,
      label = c(".",title),
      Relation = c("produces",""),
      Object = c(disc.id[2],""),
      Description = c(opeS, cloS),
      URL = paste(page, id, sep="#"),
      stringsAsFactors = FALSE
    )
    if(nrow(out[[1]])==0) out[[1]] <- tmp else out[[1]] <- orbind(out[[1]], tmp)
    
    ######## arg: Find parameters that are unique within the id-target pairs
    #   "id"  "title" "type"  "content" "sign"  "target"   "overtarget"
    
    arg <- data.frame(
      id = html_attr(html_nodes(disc, css=" .argument"), "id"),
      title = html_text(html_nodes(disc, css=" .argument .title")),
      type = html_text(html_nodes(disc, css=".argument i.type ")),
      content = html_text(html_nodes(disc, css=" .argument .content")),
      sign = html_text(html_nodes(disc, css=" .argument .sign a:first-of-type")),
      stringsAsFactors = FALSE
    )
    
    # Find the previous argument that is one level higher, i.e. the target argument, and the overtarget.
    findtarget <- function(arg, disc) {
      
      level <- rep(0,nrow(arg))
      for(j in 0:8) {
        level[arg$id %in% html_attr(html_nodes(disc, css=paste(paste(rep("dd", j), collapse=" ")," .argument")),"id")] <- j
      }
      test <- 1:length(level)
      arg$target <- rep("", length(level))
      for(j in test) {
        arg$target[j] <-  arg$id[max(c(-Inf,test[level == level[j]-1 & test < j]))]
        arg$overtarget[j] <- arg$id[max(c(-Inf,test[level == level[j]-2 & test < j]))]
      }
      arg$target[is.na(arg$target)] <- disc.id[1]
      arg$overtarget[is.na(arg$overtarget) & level == 1] <- disc.id[1]
      return(arg)
    }
    
    arg <- findtarget(arg, disc)
    
    ######### targ: find parameters that are unique in id-target-paradigm triples
    #  "id"        "paradigm"  "relation"  "relevance" "selftruth" "truth"  
    
    targ <- data.frame(
      id = html_attr(html_nodes(disc, css=" .argument .paradigm"), "id"),
      paradigm = html_text(html_nodes(disc, css=" .argument .paradigm")),
      relation = html_text(html_nodes(disc, css=" .argument .relation")),
      relevance = html_attr(html_nodes(disc, css=" .argument .relation"), "color"),
      selftruth = html_attr(html_nodes(disc, css=" .argument .selftruth"), "color"),
      stringsAsFactors = FALSE
    )
    
    targ$relation  <- c("attack","defense","comment","branch")[match(substr(targ$relation,1,3), c("\U21E4--","\U2190--","---","--\U2192"))]
    targ$truth     <- ifelse(targ$relevance=="gray",0,1)
    targ$relevance <- ifelse(targ$relevance=="gray",0,1)
    targ$selftruth <- ifelse(targ$selftruth=="gray",0,1)
    targ <- findtarget(targ, disc)[-8] # Remove redundant overtarget
    
    ### Create another data.frame with full argument structure for ovariable formation
    
    tmp <- arg # Add rows for selftruth
    tmp$type <- "selftruth"
    tmp <- rbind(arg,tmp)
    tmp <- tmp[!duplicated(arg$id, arg$type) , ]
    
    arg2 <- melt(
      targ,
      measure.vars = c("relevance","truth","selftruth"),
      variable.name="type",
      value.name="Result"
    )
    arg2 <- merge(tmp, arg2)
    out[[2]] <- rbind(out[[2]], arg2)
    
    # Produce a vector with the same nrow as arg but all paradigms combined.
    
    arg1 <- merge(arg,targ)
    selftruth <- c("false","true")[arg1$selftruth+1]
    tmp <- sapply(tapply(
      paste(arg1$paradigm, selftruth, sep=": "),
      arg1["id"], paste),function(x) paste(x, collapse="; "))
    tmp <- data.frame(id = names(tmp), par = tmp, stringsAsFactors = FALSE)
    arg1 <- merge(arg1,tmp) # Merge instead of cbind in case tapply mixes the order of arguments.
    arg1$id <- gsub("£££.*", "", arg1$id) # Replace argument-target-specific id's again with argument id's.
    arg1$target <- gsub("£££.*", "", arg1$target)
    
    out[[1]] <- orbind(out[[1]], data.frame(  ### Arguments
      Oldid = paste(id,arg1$id,sep="."),
      type = paste(selftruth,"argument"),
      Item = arg1$id,
      label = arg1$title,
      Relation = paste(c("irrelevat","relevant")[arg1$relevance+1], arg1$relation),
      Object = arg1$target,
      Description = paste(arg1$content, "| paradigms:", arg1$par),
      URL = paste(page, arg1$id,sep="#"),
      stringsAsFactors = FALSE
    ))
  }
  out[[1]]$label <- ifelse(out[[1]]$label==".",substr(out[[1]]$Description, 1, 30),out[[1]]$label)
  for(i in 1:ncol(out[[1]])) out[[1]][[i]] <- gsub("['\"]", "", out[[1]][[i]])
  
  return(out)
}

#' Scrape google sheets
#' 
#' scrape.gssheet is a function for scraping google sheets and making data.frames
#' 
#' @param page character vector with the URL of the google sheet
#' @param firstrow atom vector with the number of the first data row on the gsheet
#' @return a data.frame

scrape.gssheet <- function(page, firstrow) {
  require(gsheet)
  
  out <- gsheet2tbl(page)
  if(firstrow>2) out <- out[-(1:(firstrow-2)) , ]
  return(out)
}

#' Scrape tables on a webpage
#' 
#' scrape.webpage is a function for scraping data from a table on a webpage.
#' 
#' @param page URL of the page to be scraped.
#' @param table number of table on the page to be scraped.
#' @return a data.frame

scrape.webtable <- function(page, table) {
  require(rvest)
  out <- html_table(read_html(page),fill=TRUE)[[table]]
  return(out)
}

objects.store(scrape.discussion, scrape.gssheet, scrape.webtable)
cat("Functions scrape.discussion, scrape.gssheet, scrape.webtable stored.\n")

+ Show code - Hide code

# This is code Op_en3861/scrape.assessment on page [[Insight network]]

library(OpasnetUtils)

#' Create URLs for objects
#' 
#' makeurl creates a unique URL based on wiki page id and object name. Used to create hyperlinks to the knowledge crystal pages.
#' @param page wiki_page_id: character vector format "Op_en7748" 
#' @param name name of the knowledge crystals: character vector
#' @return character vector of URLs

makeurl <- function( 
  page, 
  name 
) {
  if(is.null(page)|is.null(name)) return(NA) else
    out <- paste0(
      c(
        en = "http://en.opasnet.org/w/index.php?curid=",
        fi = "http://fi.opasnet.org/fi/index.php?curid="
      )[substr(page, 4,5)], # is it en or fi?
      substr(page, 6,11), # id
      "#", gsub(" ", "_", name)
    )
  out <- ifelse(is.na(page)|is.na(name), NA, out)
  return(out)
}

#' Scrape ovariables and other objects in an assessment
#' 
#' scrape.assessment makes standard data.frame for insight diagram out of all ovariables, odecisions, and data.frames and their dependencies in the global environment.
#' 
#' @param assessment ovariable that contains other assessment objects as dependencies
#' @param objectives names of ovariables that are objectives in the model
#' @return a list of two data.frames. The first one is for making insight diagrams, the second for making discussion ovariables for analysis (the latter part not implemented yet)

scrape.assessment <- function(
  assessment,
  objectives = character()
) {
  #  require(DiagrammeR)
  require(OpasnetUtils)
  nod <- data.frame()
  ova <- character()
  dec <- character()
  dat <- character()
  plo <- character()
  dep <- assessment@dependencies
  URLass <- assessment@meta$wiki_page_id
  
  #### Find all objects (decisions, ovariables, data.frames and graphs)
  objs <- list()
  for(i in dep$Name) {
    cl <- class(get(i))
    if("ovariable" %in% cl) ova <- c(ova, i)
    if("odecision" %in% cl) dec <- c(dec, i)
    if("data.frame" %in% cl) dat <- c(dat, i)
    if(any(c("ggplot","dgr_graph") %in% cl)) plo <- c(plo, i)
    if(is.list(get(i))) objs <- c(objs, list(get(i))) else objs <- c(objs, get(i))
  }
  names(objs) <- dep$Name

  ###### Add all decisions and options
  
  for(i in dec) { 
    deci <- objs[[i]]@dectable
    if(nrow(deci)>0) {
      tst <- !duplicated(deci[c("Option","Decision")])
      nod <- rbind(
        nod,
        data.frame(
          Oldid = paste("Opt", match(i, dec), sep=""),
          type = "option",
          Item = as.character(deci$Option[tst]),
#          label = as.character(deci$Option[tst]),
          Relation = "is option for",
          Object = as.character(deci$Decision[tst]),
          Description = if(is.null(deci$Description)) NA else
            as.character(deci$Description[tst]),
          URL = makeurl(URLass, deci$Option)[tst],
          stringsAsFactors = FALSE
        )
      )
      
      tst <- !duplicated(deci[c("Decision","Variable")])
      nod <- rbind(
        nod,
        data.frame(
          Oldid = paste("Dec", match(i, dec), sep=""),
          type = "decision",
          Item = as.character(deci$Decision[tst]),
#          label = as.character(deci$Decision[tst]),
          Relation = "affects",
          Object = as.character(deci$Variable[tst]),
          Description = if(is.null(deci$Description)) NA else
            as.character(deci$Description[tst]),
          URL = makeurl(URLass, deci$Decision)[tst],
          stringsAsFactors = FALSE
        )
      )
    }
  }
  
  ####### Add all ovariables
  
  for(i in ova) {
    obj <- objs[[i]]
    nod <- rbind( # Add dependencies
      nod,
      data.frame(
        Oldid = paste("Ova",match(i,ova),sep=""),
        type = "ovariable",
        Item = obj@name,
#        label = obj@name,
        Relation = "is affected by",
        Object = if(nrow(obj@dependencies)==0) NA else as.character(obj@dependencies$Name),
        Description = if(is.null(obj@meta$Description)) NA else
          obj@meta$Description,
        URL = makeurl(obj@meta$wiki_page_id, obj@name),
        stringsAsFactors = FALSE
      )
    )
    tmp <- colnames(obj@output)[                          # Add indices
      obj@marginal &
        !grepl("Source$", colnames(obj@output)) &
        ! colnames(obj@output) %in% c(deci, "Iter")
      ]
    if(length(tmp)>0) {
      nod <- rbind(
        nod,
        data.frame(
          Oldid = paste0("Ova",match(i,ova),tmp),
          type = "index",
          Item = tmp,
#          label = tmp,
          Relation = "is index for",
          Object = obj@name,
          Description = NA,
          URL = makeurl(URLass, tmp),
          stringsAsFactors = FALSE
        )
      )
    }
  }
  
  ### Add graphs
  
  nod <- orbind(
    nod,
    data.frame(
      Oldid = paste0("Plo", 1:length(plo)),
      type = "graph",
      Item = plo,
#      label = plo,
      stringsAsFactors = FALSE
    )
  )
  
  # V(dag)$Size[V(dag)$name == i] <- nrow(obj@output)     # Size
  # vertex.size = log(V(dag)$Size)+2, # Vertex size is (non-linearly) relative to rows in output.
  
  ### Add data.frames 
  
  nod <- orbind(
    nod,
    data.frame(
      Oldid = paste("Dat", 1:length(dat), sep=""),
      type = "data",
      Item = dat,
#      label = dat,
      stringsAsFactors = FALSE
    )
  )
  
  # Retype objectives and assessments if available
  nod$type[nod$Item %in% objectives] <- "objective"
  nod$type[nod$Item %in% assessment@name] <- "assessment"
  
  # Add info from Page column if available and doesn't exist already
  if(!is.null(dep$Page)) {
    tst <- is.na(nod$Description)
    nod$Description[tst] <- as.character(dep$Description[match(nod$Item, dep$Name)][tst])
    tst <- is.na(nod$URL)
    nod$URL[tst] <- makeurl(
      dep$Page[match(nod$Item[tst], dep$Name)],
      dep$Name[match(nod$Item[tst], dep$Name)]
    )
  }
  tst <- is.na(nod$Description)
  nod$Description[tst] <- nod$type[tst]
  
  #Add info (with force) from type column in dep if available
  if(!is.null(dep$type)) {
    tst <- dep$Name[!(is.na(dep$type) | dep$type=="")]
    nod$type[match(tst,nod$Item)] <- as.character(dep$type[match(tst,dep$Name)])
  }
  
  # Add relations defined by hand on assessment@dependencies
  tst <- dep$Name[!(is.na(dep$Child) | dep$Child=="")]
  if(length(tst)>0) { # Does nothing if column Child does not exist
    nod <- orbind(
      nod,
      data.frame(
        Oldid = as.character(nod$Oldid[match(tst,nod$Item)]),
        Item = as.character(tst),
        Relation = c(
          rep("indirectly affects",3),
          "is data for",
          "describes"
        )[match(nod$type[match(tst,nod$Item)],c("ovariable","key ovariable","objective","data","graph"))],
        Object = as.character(dep$Child[match(tst,dep$Name)])
      )
    )
  }
  return(nod) 
}

objects.store(scrape.assessment, makeurl)
cat("Functions scrape.assessment, makeurl stored.\n")

Copy descriptions to ovariables

The function assessmentDescriptions scans through an assessment ovarible that has all relevant assessment objects as parents. Dependencies slot may also have additional information, such as the following.

Name: name of parent (obligatory)
Ident: Opasnet page identifier and code name where the parent object can be loaded (e.g. Op_en7748/hia). Note: This is typically the code for the whole assessment, not the individual codes for the objects.
Token: Token for the model run where the parent object can be loaded (e.g. xxNsLw5hWdM6xyYp)
Description: A short description about what the object is. This is typically shown when cursor hovers over the object on an online insight diagram.
Page: Opasnet page identifier for the object's knowledge crystal page, which contains the research question, answer, and description of the object, together with discussion, if any. Typically this is empty for ovariables, because this information can be found from ovariable@meta slot and there is no need to duplicate it here.
Child: An object to which this object links. This is typically needed for objects such as graphs and data.frames that do not contain this information in their own structure, unlike ovariables. The direction of a relation is away from this object because then this object is the subject in triple sentences and can be given other parameters as well in other columns. A typical sentence is "graph describes ovariable", but for illustrative purposes this is inversed on insight networks so that the arrow points from an ovariable to a graph ("ovariable is described by graph").
Other columns are allowed.

+ Show code - Hide code

# This is code Op_en3861/ on page [[Insight network]]

assessmentDescriptions <- function( # Adds descriptions to ovariables.
  assessment # Ovariable or assessment whose dependencies will be given descriptions.
) {
  dep <- assessment@dependencies
  for(i in dep$Name) {
    tmp <- get(i)
    if("ovariable" %in% class(tmp)) {
      desc <- as.character(dep$Description[dep$Name==i])
      if(is.null(tmp@meta$Description)) {
        tmp@meta$Description <- desc
      } else {
        tmp@meta$Description <- paste0("1) ", desc, ". 2) ", tmp@meta$Description)
        warning("There already was ", i, "@meta$Description. The two were concatenated.\n")
      }
      assign(i, tmp, envir = .GlobalEnv)
    }
  }
  return(cat("Done.\n"))
}

Old notation

⇤--#: . Look at the table below together with Open policy ontology and merge. Decide which things should be on this page and which should be on the other. --Jouni (talk) 06:55, 24 April 2018 (UTC) (type: truth; paradigms: science: attack)

Object	Colour code in Analytica	Comments
General variable	8R3B (automatic)	This is a deterministic function of the quantities it depends on.
Chance variable	11L4B (autom)	This is a variable which is uncertain and uncontrollable (in a direct sense).
Data-driven variable	3R1B	A general variable where the result is mostly driven by data (observations or literature).
Author judgement variable	4R2B	A general variable where the result is mainly driven by author judgement (estimates with poor or no data).
Decision variable	9L3B	This is the variable that a decision-maker has the power to control. The decision variable should always be at the top of the chain of causality, even if this is a subchain i.e. it should not have any parent variables. Essentially the decision variable should be regarded as a decision that has to be made; since many factors affect all decisions it is not (in the case of INTARESE) an efficient use of resources to attempt to model what leads a decision-maker to make his decision.
Indicator	1R3B (autom)	This is a variable of special interest. One of the indicators in an assessment may be the quantitative criterion that you are trying to optimize. A particularly important variable in relation to the interests of the intended users of the assessment output (i.e. it must be a means of effective communication of assessment results). It must be in causal connection to the endpoints of the assessment and thus address causality throughout the full chain. It should reflect the use/purpose of the assessment. It should address and be adapted according to the target audience. It should be the ‘leading component’ in the assessment process.
Value judgement variable	8L4B	A preference or value that a person or a group assigns to a particular condition or state of the world.
Index (or dimension)	5R2B (autom)	This identifies the dimensions of the variable to which it is linked. Note that these dimensions do not have to be numeric, but can also be classes etc.
Risk assessment	8R3B (autom)
Scope	6R1B	The scope of the object
Conclusion	6L3B	A conclusion of the risk assessment (Result/Conclusion attribute).
Module	6R3B (autom)	A group of variables that are put together for illustrative or other practical reasons.
Data	2L3B (autom)	Contents of the Definition/Data attribute of a variable. If the Result attribute of a variable is used as Data for another variable, the first variable is called a proxy, and this node is used in the diagram. If an arrow or line is drawn between these objects, it must be noticed that this is NOT a causal link but an inference link. The direction of the arrow would be from the proxy to the variable.
Argument	8R2B	A piece of argumentation related to an object (variable, risk assessment, or class)
Formula	9L3B	Contents of the Definition/Formula attribute of a variable.
Class	1L2B	A class object (a set of objects that share a particular property).
Function	4R2B (autom)	A special kind of class. The particular property that is shared contains a full description of the Scope and the Definition attributes with given parameters.
Causal arrow		This states a causal relationship (or influence) of one variable onto another. Note that causal arrows can only exist between two arrows; any arrows to or from non-causal objects are non-causal inference arrows.
Non-causal arrow		This states an inference relationship between two objects. This means that the object where the arrow starts from is in the Data attribute of the other object. It is thus used to infer something about the value of the result of the latter object. Either object can be a variable or a non-variable. Note that Analytica is only able to show one kind of arrows, so in some cases the nature of the arrow (causal or inference) must be concluded from the context.

Previous notations

Insight networks have previously been called pyrkilo diagrams, extended causal diagrams, and factor-effect-value networks. These names are no longer in active use. An archived version of the notation can be found from an earlier version of this page.

References

Insight network: Difference between revisions

Revision as of 13:01, 2 October 2018

Contents

Question

Answer

Rationale

Process

Data

Graphical properties of objects and relations

Types of insight network tables

Calculations

Making insight graphs

Fetch data from the web: makeInsightTables function

Insight network

Shiny server

Scrape functions

Copy descriptions to ovariables

Old notation

Previous notations

See also

References

Navigation menu