Influence of Transcription Network on Cell Function

No preview image

1 collaborator

Default-person Peter Winter (Author)

Tags

(This model has yet to be categorized with any tags)
Model group EECS-372 Spring 2009 | Visible to everyone | Changeable by everyone
Model was written in NetLogo 4.1beta3 • Viewed 249 times • Downloaded 12 times • Run 8 times
Download the 'Influence of Transcription Network on Cell Function' modelDownload this modelEmbed this model

Do you have questions or comments about this model? Ask them here! (You'll first need to log in.)


WHAT IS IT?

**What is this model doing?**

This model is loosely based off of transcription networks and the affect that transcription networks have on the life process of a cell. The model creates a random transcription network, applies rules mimicking cell life, and tests if the network can keep the cell alive past a time limit. If the network does not survive past the time limit, a new random network is generated and the process starts over. Once a network survives the time limit once, the robustness of the network is measured by recording how many times the cell survives ten repeated tests.

By looking at what kinds of networks survive and contrasting them against the other random networks generated we can hope to see trends in which networks are selected for and which networks are selected against.

**What are the nodes in the network?**

Each node represents both a protein and the gene that encodes that protein. So the two main properties of each node are the amount of protein present and the chance that more of that protein will be created. The amounts of each protein are shown on a graph, and the chance of transcription is represented by the size of each node.

**What are the edges in the network?**

(In this model, but not in biology) every protein is a potential transcription factor, which means that it influences the chance another protein is transcribed. Blue (or positive) edges are used to show which proteins increase the chance that another protein is transcribed. Red (or negative) edges show which proteins reduce that chance.

**What are the rules that mimic cell life?**

In this simplified cell, there are three types of proteins: life-critical, metabolism, and blank. The survival of the cell depends on how well it uses its metabolism to create new proteins and how well it balances the transcription chances for each kind of protein.

Every turn, each protein has an equal chance of being degraded. The cell dies if the amount of any life-critical protein drops to zero. The only way to create new proteins is by converting metabolites from one into the other. 'A' is converted into 'B' then into 'C' and then into a new protein. This conversion process is dependent on the amounts of each metabolism protein.

HOW IT WORKS

**Random Network Creation**

There is a fixed chance (chance-of-edge) that an edge will be created from any one node to another node. Whether the edge is either positive or negative is randomly selected based off of a fixed probability (chance-edge-positive).

**Creating new proteins (Cell Metabolism)**

There are three kinds of metabolites 'A', 'B' and 'C' and three metabolism proteins. One protein converts 'A' to 'B', another converts 'B' to 'C', and the last creates new proteins out of 'C'. Each step in this system is calculated in an identical manner.

The quantity of 'A' converted to 'B' in any tick depends on both the amount of metabolism protein and amount of 'A' present. The amount of protein determines how many tries the cell has to convert one 'A' to one 'B'. The amount of 'A' influences the chance that a conversion attempt will succeed.

The chance of conversion is determined by two variables Max-Conv-Chance and Conv-sensitivity.

The type of new protein created is determined by the chance of transcription.

**Calculating the Chance of Transcription**

Every node has a number, called the transcription-number, that is used to calculate the chance of transcription. Every time a protein is transcribed the amount of that protein is increased by one.

X = L + (A + B) * M

Where:

X = Transcription-number

L = transcription-basis

M = regulation-factor

A = The protein amount of all positive transcription factors (from positive inward edges)

B = The protein amount of all negative transcription factors (from negative inward edges)

L and M, the transcription-basis and regulation-factor can be changed from the interface.

Finally when a new protein is created, the chance of any given node transcribing the new protein is:

Y = ( X1 / Xt ) * 100%

Where:

Y = % Chance of transcription for node 1

X1 = Transcription-number for node 1

Xt = Sum of transcription-numbers from all nodes

HOW TO USE IT

Network Generation

- num-nodes - this changes the number of nodes in your network

- chance-of-edge - this changes the chance that a an edge will be going from any one node to another node

- chance-edge-positive - if a new edge is created, this determines the chance that the new edge will be positive

Run Options

General

- time-limit - this is how many ticks the cell needs to survive

- Repeats-Threshold - If the same network is tested 10 times, how many times must a network survive. If the Repeats-Threshold is not met, a new random network will be generated.

- Show-Notifications? - this displays user messages every time it finds a network that has survived.

Protein Options

- initial-protein-amt - this is the starting amount of each type of protein

- degrade-chance - this is the chance that any particular protein will degrade this tick

Metabolism

- feed-rate - how much metabolite 'A' is added every tick

For more information on max-conv-chance and conv-sensitivity, look in the How It Works section

- max-conv-chance - this is the maximum metabolism conversion chance. When there is an excess of 'A' present, each of the proteins that convert 'A' to 'B' will have this chance of converting one 'A' this tick.

- conv-sensitivity - This variable determines how sensitive the conversion chance is to the amount of metabolite. Specifically, this number is the amount of metabolite that will have a conversion chance that is half the size of the maximum conversion chance.

Example:

max-conv-chance = 80%

conv-sensitivity = 10

If there is 100 'A' present, the conversion chance will be close to 80%

If there is 10 'A' present, the conversion chance will be 40%

If there is 1 'A' present, the conversion chance will be close to 2%

Transcription

For more information on regulation-factor and transcription-basis, look in the How It Works section. Both of these variables play a role in how much affect the transcription factors have on the chance of transcription.

- regulation-factor - This controls how strong the regulation from positive and negative edges will be.

- transcription-basis - This controls how easily a node is influenced by regulation from positive and negative edges.

THINGS TO NOTICE

Every aspect of this model depends on random chance to the point where it is often difficult to show any striking trends without running lots of repetitions, recording the results, and analyzing them.

Robust networks typically have repeated fluctuations in the Protein-Amounts Graph.

By looking at the levels of different metabolites, you can tell which metabolism protein was limiting the production of at which part of the simulation. Example: If the levels of 'B' increased, but 'C' stayed consistently low. Than the protein that converted 'B' to 'C' was limiting step in the metabolism.

THINGS TO TRY

By looking at how many tries the model takes to create a stable network,

Change number of nodes. Can you notice a difference in the number of tries the model needs to generate a stable network? How about if you change the regulation factor?

Increasing the number of nodes decreases the chance that a new protein will be a life-critical or a metabolism protein.

By increasing the strength of the regulation factor it should take more tries to create a stable network. This is because most randomly generated networks have a negative effect on survival. By increasing the strength of the edges, you are increasing the negative effects.

EXTENDING THE MODEL

Most of the features I wish I could add have to do with analysis. I would have liked to look at more network properties.

Another great feature would be to create more graph friendly output.

NETLOGO FEATURES

create-temporary-plot-pens

CREDITS AND REFERENCES

By Peter Winter

Comments and Questions

Please start the discussion about this model! (You'll first need to log in.)

Click to Run Model

globals
[
  ; variables used to keep track of metabolism in cell
  fooda
  foodb
  foodc
  newprot
  
  ; variables used to keep 
  protein-pens ; a list of all the temporary plot pens
  tries        ; how many attempts the model has made to reach a stable setup.
  
  ; variables used for network analysis
  av-clustering-coef
  component-size          ;; number of turtles explored so far in the current component
  ;giant-component-size    ;; number of turtles in the giant component
  ;giant-start-node        ;; node from where we started exploring the giant component
  
  
  ; for feed forward analysis
  number-of-ff-loops
  number-of-fb-loops
  types-of-ff-loops
  who-in-ff-loops
  who-in-fb-loops
  two-node-ps-feedback
  two-node-ng-feedback
  two-node-dn-feedback
  
  ; to test for robustness
  repeats
  repeats-survived
  try-repeats
]
turtles-own
[
  ;; this is used to mark turtles we have already visited
  ;explored?
  transcription-number
  metabolism
  life-critical
  protein-amt
  check
  clustering-coef
]
 directed-link-breed [positive-edges  positive-edge] ; sjfs
 directed-link-breed [negative-edges  negative-edge] ; dfs
;;;;;;;;;;;;;;;;;;;;;;;;
;;; Setup Procedures ;;;
;;;;;;;;;;;;;;;;;;;;;;;;

to setup
  ca
  set tries 1
  set repeats 1
  set repeats-survived 0
  set try-repeats false
  another-try
end 

to another-try
  make-metabolites
  make-turtles
  specialize-turtles
  ;repeat num-edges [make-edges]
  make-edges3
  set protein-pens []
  make-protein-pens
  plot-protein-amount 
end 

to make-metabolites
  set fooda 20
  set foodb 30
  set foodc 40
  set newprot 0
  plot-metabolites
end 

to make-turtles
  set-default-shape turtles "circle"
  ;set-default-shape links "myarrow"
  crt num-nodes
  [
    set color white
    set protein-amt initial-protein-amt
    set metabolism 0
    set life-critical 0
    set check 0
  ]
  layout-circle turtles max-pxcor - 1
end 

to specialize-turtles
  ask turtle 1 [set metabolism 1 set color orange]
  ask turtle 2 [set metabolism 2 set color orange]
  ask turtle 3 [set metabolism 3 set color orange]
  ask turtle 4 [set life-critical 1 set color yellow]
  ask turtle 5 [set life-critical 1 set color yellow]
  ask turtle 6 [set life-critical 1 set color yellow]
end 

to rerun-this-setup
    reset-ticks
    ;set tries 1
    set-current-plot "Metabolites"
    clear-plot    
    set-current-plot "Protein-Amounts"
    clear-plot
    set-current-plot "Metabolite-Conversion-Chance"
    clear-plot
    ask turtles [set protein-amt initial-protein-amt]
    set protein-pens []
    make-metabolites
    make-protein-pens
end 
;;;;;;;;;;;;;;;;;;;;;;
;;; Main Procedure ;;;
;;;;;;;;;;;;;;;;;;;;;;

to go
  ; stop if you've repeated enough
  if tries > 1000
  [
      display
      user-message ( word  "No networks meet your requirements for robustness")
      stop
  ]    
  
  if repeats > 10
  [
        if Show-Notifications? = True
        [
          display
          user-message ( word  "Network survived " repeats-survived " of 10 repeated trials.")
        ]
        
        ; If the network survived a sufficient number of repeats, then stop. If not make new network and try again.
        ifelse repeats-survived >= Repeats-Threshold
        [ stop ]
        [
          reset-ticks
          set-current-plot "Metabolites"
          clear-plot    
          set-current-plot "Protein-Amounts"
          clear-plot
          set-current-plot "Metabolite-Conversion-Chance"
          clear-plot
          clear-links 
          clear-turtles  
          set tries ( tries + 1)
          set repeats 1
          set repeats-survived 0
          set try-repeats false
          another-try
        ]
  ]  
  
  ; time limit check
  if ticks > time-limit
  [
    ; if this is the first time this network survived the time limit, prepare for repeated trials
    ifelse try-repeats = false
    [
      set try-repeats true
      ; since we do 10 trials, there are 9 repeats after the initial sucess.
      ; so I start my repeats counter at 2 and go until it reaches 10
      set repeats 2
      set repeats-survived 1
      ; if the user wants notifications tell him a network survived the time limit.
      if Show-Notifications? = True
      [
        display
        user-message ( word  tries " tries untill network survived. Now checking robustness.")
      ]
      rerun-this-setup
    ]
    ; if this is one of the repeated trials, record sucess, carry on.
    [    
      set repeats (repeats + 1)
      set repeats-survived (repeats-survived + 1)
    ]
  ]
 ; kills the cell if there aren't any life-critical proteins
 if ([protein-amt] of turtle 4) <= 0 or ([protein-amt] of turtle 5) <= 0 or ([protein-amt] of turtle 6) <= 0
 [
    reset-ticks
    set-current-plot "Metabolites"
    clear-plot    
    set-current-plot "Protein-Amounts"
    clear-plot
    set-current-plot "Metabolite-Conversion-Chance"
    clear-plot
    
    ; if this wasn't a repeated trial, try a new network
    if try-repeats = false 
    [
      clear-links 
      clear-turtles  
      set tries ( tries + 1)
      another-try
    ]
    ; if this was a repeated trial, don't record sucess, carry on.
    if try-repeats = true 
    [
      set repeats ( repeats + 1 ) 
      rerun-this-setup
    ]
  ]
    
  ;fooda ( or Metabolite 'A' ) is added
  set fooda (fooda + feed-rate)
  run-metabolism ; this is where all the conversions between metabolites takes place
  plot-metabolites
  plot-protein-amount
  degrade-protein
  ; turtles raise or lower each others transcription chance, degrade some proteins, missing: plot their protein concentrations, 
  ; turtles adjust their size in relation to transcription chance
  ; transcribe-protein. all in this subroutine:
  node-specific-operation
  tick
end 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Subroutines for Main Procedure ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; every protein from every node rolls a dice to see if it dies.

to degrade-protein
  ask turtles
  [
     let i 0
     ; every protein has the same chance to degrade, so repeat this for every protein
     repeat protein-amt 
     [ 
         if random 100 < degrade-chance 
         [ 
             set i (i + 1) 
             set protein-amt (protein-amt - i)
         ]
     ]
     if protein-amt < 0 [set protein-amt 0]
  ]
end 

; turtles raise or lower each others transcription chance, degrade some proteins, missing: plot their protein concentrations, 
; turtles adjust their size in relation to transcription chance
; transcribe-protein. all in this subroutine:

to node-specific-operation
  
  ; normalize-to is the sum of all the transcription numbers from every node
  let normalize-to 0
  ; this adjusts chance of transcription
  ask turtles 
  [ 
      let baseline Transcription-Basis
      let j baseline
   
      ask in-positive-edge-neighbors [ set j ( j + (protein-amt  * Regulation-Factor)) ] 
      ask in-negative-edge-neighbors [ set j (j - (protein-amt * Regulation-Factor)) ] 
      if j < 1 [set j 1]
      
      set transcription-number j; not normalized transcription chance not 1 in 100
      set normalize-to (normalize-to + j)
  ]
  
  let l 0
  ; newprot is the number of new proteins that will be created this turn.
  ; for each new protein one node is chosen (based off of transcription chance)
  repeat newprot
  [
    let i 0
    ; choose a random number between 0 and normalize-to. 
    ; then see which node won a  brand new protein 
    let k (random normalize-to)
    while [k > 0]
    [
      set k ( k - ([transcription-number] of turtle i) )
      if k <= 0 [ask turtle i [set protein-amt ( protein-amt + 1 )] ]
      set i (i + 1)
      
    ]
  ]
  set newprot 0
  
  ; this adjusts the size of each node to be proportional to it's chance of transcription
  ask turtles 
  [
     set size 0.1 + num-nodes * 5 * (transcription-number / normalize-to)
  ]
end 

to run-metabolism
  let K ( Max-Conv-Chance / 100 ) ;this is production rate at saturation it is set to 90%
  let kp ( 1 / Conv-Sensitivity ) ; this is (1/amt of food) required to have 50% of max conversion. right now it's set to 10
  
  if (fooda < 0 or foodb < 0 or foodc < 0)
  [
    display
    user-message (word "fooda:" fooda " ca:"([protein-amt] of turtle 1) " atob:" floor (K * kp * fooda * 100 / ( 1 + (kp * fooda) )) 
                       " foodb:" foodb " btoc:" floor (K * kp * foodb * 100 / ( 1 + (kp * foodb) ))
                       " foodc:" foodc " ctop:" floor (K * kp * foodc * 100 / ( 1 + (kp * foodc) )))
    stop
  ] 
;  if [protein-amt] of turtle 1 > 0
;  [
      repeat ([protein-amt] of turtle 1)
      [
        if random 100 < floor (K * kp * fooda * 100 / ( 1 + (kp * fooda) ))
        [
           set fooda (fooda - 1)
           set foodb (foodb + 1)    
        ]  
      ]
  ;]
  repeat ([protein-amt] of turtle 2)
  [
    if random 100 < floor (K * kp * foodb * 100 / ( 1 + (kp * foodb) ))
    [
       set foodb (foodb - 1)
       set foodc (foodc + 1)  
    ]  
  ]
  
  repeat ([protein-amt] of turtle 3)
  [
    if random 100 < floor (K * kp * foodc * 100 / ( 1 + (kp * foodc) ))
    [
       set foodc (foodc - 1)
       set newprot (newprot + 1)  
    ]  
  ]
  
  set-current-plot "Metabolite-Conversion-Chance"
  set-current-plot-pen "A to B"
  plot floor (K * kp * fooda * 100 / ( 1 + (kp * fooda) )) 
  set-current-plot-pen "B to C"
  plot floor (K * kp * foodb * 100 / ( 1 + (kp * foodb) )) 
  set-current-plot-pen "C to D"
  plot floor (K * kp * foodc * 100 / ( 1 + (kp * foodc) )) 
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Plotting and Visuals ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; THIS IS TAKEN FROM DIFFUSION ON A DIRECTED NETWORK. MAYBE ADD SOMETHING LIKE THIS TO LOOK COOL.
;to update-link-appearance ; link procedure
;  ; scale color to be brighter when more value is flowing through it
;  set color scale-color gray (current-flow / (2 * mean-flow + 0.00001)) -0.4 1
;end

to make-protein-pens
  set-current-plot "Protein-Amounts"
  let i 0
  ask turtles 
  [ 
    
    create-temporary-plot-pen ( word "protein-" i )
    set protein-pens lput ( word "protein-" i ) protein-pens
    set i ( i + 1 )
    if i >= 2 and i <= 4 [set-plot-pen-color orange]
    if i >= 5 and i <= 7 [set-plot-pen-color yellow]
  ]
end 

to plot-protein-amount
  let amt-index []
  let i 0
  repeat num-nodes
  [ 
      ask turtle i
     [
         set amt-index lput ( protein-amt ) amt-index
     ]
     set i ( i + 1)
  ]  
  ;show amt-index ;to check if working properly
  
  set i 0
  repeat num-nodes
  [        
         set-current-plot "Protein-Amounts"
         set-current-plot-pen (item i protein-pens)
         plot (item i amt-index)
         ;plot-pen-reset
         set i ( i + 1)
  ]
end 

to plot-metabolites
  set-current-plot "Metabolites"
  set-current-plot-pen "A"
  plot fooda
  set-current-plot-pen "B"
  plot foodb
  set-current-plot-pen "C"
  plot foodc
  set-current-plot-pen "P"
  plot newprot
end 

;;;;;;;;;;;;;;;;;;;;;;;
;;; Edge Operations ;;;
;;;;;;;;;;;;;;;;;;;;;;;
;; pick a random missing edge and create it
;to make-edges
;    let node1 one-of turtles
;    let node2 one-of turtles
;    ifelse node1 = node2  ;or out-link-neighbor? node2
;     [ make-edges ]
;     [
;        ifelse random 100 < %positive-regulation
;        [
;          ask node1 
;          [ 
;            ifelse out-link-neighbor? node2 [make-edges]
;            [create-positive-edge-to node2 [set color green]]
;          ]
;        ]
;          [
;          ask node1
;          [ 
;            ifelse out-link-neighbor? node2 [make-edges]
;            [create-negative-edge-to node2 [set color red]]
;          ]
;        ]
;     ]  
;    find-clustering
;end
;to make-edges2
;  let i 0
;  let j 0
;  let node2 one-of turtles
;  repeat (num-nodes - 1) ; last node doesn't need to look for nodes to link to. 
;  [
;     set j 0
;     repeat (num-nodes - i - 1) ; since the node index starts at 0, num-nodes is one larger than the highest index. ie. turtle9 is last turtle for num-nodes = 10.
;     [
;        ask turtle i 
;        [
;            set node2 turtle (num-nodes - j - 1)
;            ;show (word node2 )
;            if random 100 < chance-of-edge
;            [ 
;              ifelse random 100 < %positive-regulation 
;              [create-positive-edge-to node2 [set color blue]]
;              [create-negative-edge-to node2 [set color red ]]
;            ]
;        ]
;        set j (j + 1)
;     ]
;     set i (i + 1)
;     find-clustering
;  ]
;  
;end

to make-edges3
  let i 0
  let j 0
  let node2 one-of turtles
  set-default-shape links "Myarrow"
  repeat (num-nodes - 1 ) ; last node doesn't need to look for nodes to link to. 
  [
     set j 0
     repeat (num-nodes - 1) ; since the node index starts at 0, num-nodes is one larger than the highest index. ie. turtle9 is last turtle for num-nodes = 10.
     [
        if i != j 
        [
            ask turtle i 
            [
                set node2 turtle j
                ;show (word node2 )
                if random 100 < chance-of-edge
                [ 
                  ifelse random 100 < chance-edge-positive 
                  [create-positive-edge-to node2 [set color blue set thickness .1]]
                  [create-negative-edge-to node2 [set color red set thickness .1]]
                ]
            ]
        ]
        set j (j + 1)
     ]
     set i (i + 1)
  ]
  find-clustering
  motif-check
end 
;;;;;;;;;;;;;;;;;;;;;;;;
;;; Network Analysis ;;;
;;;;;;;;;;;;;;;;;;;;;;;;

to find-clustering
  let i 0
  let clustering 0
  repeat num-nodes
  [  
     ask turtle i
     [
        ;ask out-link-neighbors [set check 1]  
        ask out-link-neighbors [set clustering count my-out-links]        
        set clustering-coef (clustering / ( num-nodes * ( num-nodes - 1 ) ) )
     ] 
     set i (i + 1)
  ]
end 

to motif-check
  check-two-node-regulation
  ; the following two are for three node motifs
  check-for-ff-loops 
  check-for-fb-loops
end 

to check-two-node-regulation
   ;all three types of two node feedback
   let i 0
   set two-node-ps-feedback 0
   set two-node-ng-feedback 0
   set two-node-dn-feedback 0
   repeat num-nodes
   [
      ask turtle i 
      [
        set check 1
        ask out-positive-edge-neighbors 
        [ 
          ask out-positive-edge-neighbors with [check = 1] [set two-node-ps-feedback (two-node-ps-feedback + 1)]; show "two-node-ps-feedback"]
          ask out-negative-edge-neighbors with [check = 1] [set two-node-ng-feedback (two-node-ng-feedback + 1)]; show "two-node-ng-feedback"]
        ]
        ask out-negative-edge-neighbors
        [ 
          ask out-positive-edge-neighbors with [check = 1] [set two-node-ng-feedback (two-node-ng-feedback + 1)]; show "two-node-ng-feedback"]
          ask out-negative-edge-neighbors with [check = 1] [set two-node-dn-feedback (two-node-dn-feedback + 1)]; show "two-node-dn-feedback"]
        ]
      ]
      set i ( i + 1 )
      ask turtles [set check 0]
   ]
   set two-node-ps-feedback (two-node-ps-feedback / 2)
   set two-node-ng-feedback (two-node-ng-feedback / 2)
   set two-node-dn-feedback (two-node-dn-feedback / 2)   
end 

to check-for-ff-loops ;three node
   ;Feed Forward
   let i 0
   let x 0
   let y 0
   set number-of-ff-loops 0
   set types-of-ff-loops []
   set who-in-ff-loops []
   repeat num-nodes
   [
      let j 0
      ask turtle i 
      [
        ask out-positive-edge-neighbors [set check 1 ]
        ask out-negative-edge-neighbors [set check 2 ]
        set x [who] of self
        ask out-positive-edge-neighbors 
        [ 
            set y [who] of self
            ask out-positive-edge-neighbors with [check = 1] 
                [
                  set j (j + 1) 
                  set who-in-ff-loops fput (word x "-" y "-" [who] of self) who-in-ff-loops
                  set types-of-ff-loops fput 1 types-of-ff-loops
                ]
            ask out-negative-edge-neighbors with [check = 1] 
                [
                  set j (j + 1) 
                  set who-in-ff-loops fput (word x "-" y "-" [who] of self) who-in-ff-loops
                  set types-of-ff-loops fput 2 types-of-ff-loops
                ]
            ask out-positive-edge-neighbors with [check = 2] 
                [
                  set j (j + 1) 
                  set who-in-ff-loops fput (word x "-" y "-" [who] of self) who-in-ff-loops
                  set types-of-ff-loops fput 3 types-of-ff-loops
                ]
            ask out-negative-edge-neighbors with [check = 2] 
                [
                  set j (j + 1) 
                  set who-in-ff-loops fput (word x "-" y "-" [who] of self) who-in-ff-loops
                  set types-of-ff-loops fput 4 types-of-ff-loops
                ]
        ]
        ask out-negative-edge-neighbors
        [
            set y [who] of self
            ask out-positive-edge-neighbors with [check = 1] 
                [
                  set j (j + 1) 
                  set who-in-ff-loops fput (word x "-" y "-" [who] of self) who-in-ff-loops
                  set types-of-ff-loops fput 5 types-of-ff-loops
                ]
            ask out-negative-edge-neighbors with [check = 1] 
                [
                  set j (j + 1) 
                  set who-in-ff-loops fput (word x "-" y "-" [who] of self) who-in-ff-loops
                  set types-of-ff-loops fput 6 types-of-ff-loops
                ]
            ask out-positive-edge-neighbors with [check = 2] 
                [
                  set j (j + 1) 
                  set who-in-ff-loops fput (word x "-" y "-" [who] of self) who-in-ff-loops
                  set types-of-ff-loops fput 7 types-of-ff-loops
                ]
            ask out-negative-edge-neighbors with [check = 2] 
                [
                  set j (j + 1) 
                  set who-in-ff-loops fput (word x "-" y "-" [who] of self) who-in-ff-loops
                  set types-of-ff-loops fput 8 types-of-ff-loops
                ]
        ]
        ;show j 
        set number-of-ff-loops (number-of-ff-loops + j)
      ]
      ;ask turtle i [if (check != 0) [set color blue]]
      set i ( i + 1 )
      ask turtles [set check 0]
   ]
end 

to check-for-fb-loops ;three node
   ;Feedback
   let i 0
   let x 0
   let y 0
   set number-of-fb-loops 0
   ;set types-of-fb-loops [b
   set who-in-fb-loops []
   repeat num-nodes
   [
      let j 0
      ask turtle i 
      [
        ask in-positive-edge-neighbors [set check 1]
        ask in-negative-edge-neighbors [set check 2]
        set x [who] of self
        ask out-positive-edge-neighbors 
        [ 
            set y [who] of self
            ask out-positive-edge-neighbors with [check = 1] [set j (j + 1) set who-in-fb-loops fput (word x "-" y "-" [who] of self) who-in-fb-loops]
            ask out-negative-edge-neighbors with [check = 1] [set j (j + 1) set who-in-fb-loops fput (word x "-" y "-" [who] of self) who-in-fb-loops]
            ask out-positive-edge-neighbors with [check = 2] [set j (j + 1) set who-in-fb-loops fput (word x "-" y "-" [who] of self) who-in-fb-loops]
            ask out-negative-edge-neighbors with [check = 2] [set j (j + 1) set who-in-fb-loops fput (word x "-" y "-" [who] of self) who-in-fb-loops]
        ]
        ask out-negative-edge-neighbors
        [
            set y [who] of self
            ask out-positive-edge-neighbors with [check = 1] [set j (j + 1) set who-in-fb-loops fput (word x "-" y "-" [who] of self) who-in-fb-loops]
            ask out-negative-edge-neighbors with [check = 1] [set j (j + 1) set who-in-fb-loops fput (word x "-" y "-" [who] of self) who-in-fb-loops]
            ask out-positive-edge-neighbors with [check = 2] [set j (j + 1) set who-in-fb-loops fput (word x "-" y "-" [who] of self) who-in-fb-loops]
            ask out-negative-edge-neighbors with [check = 2] [set j (j + 1) set who-in-fb-loops fput (word x "-" y "-" [who] of self) who-in-fb-loops]
        ]
        ;show j 
        set number-of-fb-loops (number-of-fb-loops + j)
      ]
      set i ( i + 1 )
      ask turtles [set check 0]
   ]
   set number-of-fb-loops (number-of-fb-loops / 3) ; I think they always get counted three times
   ;print who-in-fb-loops 
end 

to print-analysis
   print ( word "two-node-ps-feedback:" two-node-ps-feedback )
   print ( word "two-node-ng-feedback:" two-node-ng-feedback )
   print ( word "two-node-dn-feedback:" two-node-dn-feedback )
   
   print ( word "number-of-fb-loops:" number-of-fb-loops )
   print ( word "number-of-ff-loops:" number-of-ff-loops )
   print types-of-ff-loops
   print who-in-ff-loops
end 
;two-node-ps-feedback
;two-node-ng-feedback
;two-node-dn-feedback
;number-of-fb-loops
;number-of-ff-loops

There are 7 versions of this model.

Uploaded by When Description Download
Peter Winter over 9 years ago (Default description) Download this version
Peter Winter over 9 years ago (Default description) Download this version
Peter Winter over 9 years ago (Default description) Download this version
Peter Winter over 9 years ago (Default description) Download this version
Peter Winter over 9 years ago Initial upload Download this version
Peter Winter over 9 years ago (Default description) Download this version
Peter Winter over 9 years ago (Default description) Download this version

Attached files

No files

This model does not have any ancestors.

This model does not have any descendants.