# Sync for Processing

**URL:** https://discourse.processing.org/t/sync-for-processing/14969
**Category:** Gallery
**Created:** [October 27, 2019, 6:11pm UTC](https://discourse.processing.org/t/sync-for-processing/14969 "2019-10-27T18:11:15Z")
**Posts on this page:** 1
**Page:** 1

<div class="post-metadata">

### Author: ![mcintyre](https://yyz2.discourse-cdn.com/flex036/user_avatar/discourse.processing.org/mcintyre/32/14561_2.png) [@mcintyre](https://discourse.processing.org/u/mcintyre)
#### Post date: [October 27, 2019, 6:11pm UTC](https://discourse.processing.org/t/sync-for-processing/14969/1 "2019-10-27T18:11:15Z")

</div>

Hey y’all,

I’ve been tinkering with a Processing implementation of the [Kuramoto model](https://en.wikipedia.org/wiki/Kuramoto_model) of coupled oscillators and think it’s working well enough to share. The library supports different coupling arrangements as described [here](https://researchspace.auckland.ac.nz/bitstream/handle/2292/2666/esc-tr-638-1.pdf). The example below simulates the synchronization of neurons in our brains.

The latest release is available on [GitHub](https://github.com/nickmcintyre/processing-synchronization/releases/tag/latest).

Cheers,  
Nick

```java
import sync.*;

PNetwork net;
Arrangement arr;

void setup() {
  size(640, 360);
  int networkSize = 8;
  float coupling = 5;
  arr = new Arrangement(networkSize, coupling);
  float[] phase = new float[networkSize];
  float[] naturalFrequency = new float[networkSize];
  for (int i = 0; i < networkSize; i++) {
    phase[i] = random(TWO_PI);
    naturalFrequency[i] = random(1);
  }
  
  net = new PNetwork(this, phase, naturalFrequency, arr.allToAll);
}

void draw() {
  background(255);
  noStroke();
  translate(width/2, height/2);
  for (int i = 0; i < net.networkSize; i++) {
    float r = i * (TWO_PI / net.networkSize);
    float a = map(net.phase[i], 0, TWO_PI, 0, 255);
    pushMatrix();
    rotate(r);
    translate(100, 0);
    fill(54, 86, 148, a);
    circle(0, 0, 50);
    popMatrix();
  }
  net.step();
}

void keyPressed() {
  switch (key) {
    case '0':
      net.coupling = arr.linearUnidirectional;
      break;
    case '1':
      net.coupling = arr.linearBidirectional;
      break;
    case '2':
      net.coupling = arr.boxUnidirectional;
      break;
    case '3':
      net.coupling = arr.boxBidirectional;
      break;
    case '4':
      net.coupling = arr.allToAll;
      break;
  }
}

class Arrangement {
  
  int networkSize;
  float coupling;
  
  float[][] linearUnidirectional;
  float[][] linearBidirectional;
  float[][] boxUnidirectional;
  float[][] boxBidirectional;
  float[][] allToAll;
  
  Arrangement(int _networkSize, float _coupling) {
    networkSize = _networkSize;
    coupling = _coupling;
    initializeMatrices();
  }
  
  void initializeMatrices() {
    initializeLU();
    initializeLB();
    initializeBU();
    initializeBB();
    initializeA2A();
  }
  
  /**
   * Linear Unidirectional
   * 
   * {{0, X, 0, 0},
   * {0, 0, X, 0},
   * {0, 0, 0, X},
   * {0, 0, 0, 0}}
   */
  void initializeLU() {
    linearUnidirectional = new float[networkSize][networkSize];
    for (int i = 0; i < networkSize; i++) {
      for (int j = 0; j < networkSize; j++) {
        if (j == i + 1) {
          linearUnidirectional[i][j] = coupling;
        } else {
          linearUnidirectional[i][j] = 0;
        }
      }
    }
  }
  
  /**
   * Linear Bidirectional
   * 
   * {{0, X, 0, 0},
   * {X, 0, X, 0},
   * {0, X, 0, X},
   * {0, 0, X, 0}}
   */
  void initializeLB() {
    linearBidirectional = new float[networkSize][networkSize];
    for (int i = 0; i < networkSize; i++) {
      for (int j = 0; j < networkSize; j++) {
        if (j == i + 1) {
          linearBidirectional[i][j] = coupling;
        } else if (i == j + 1) {
          linearBidirectional[i][j] = coupling;
        } else {
          linearBidirectional[i][j] = 0;
        }
      }
    }
  }
  
  /**
   * Box Unidirectional
   * 
   * {{0, X, 0, 0},
   * {0, 0, X, 0},
   * {0, 0, 0, X},
   * {X, 0, 0, 0}}
   */
  void initializeBU() {
    boxUnidirectional = new float[networkSize][networkSize];
    for (int i = 0; i < networkSize; i++) {
      for (int j = 0; j < networkSize; j++) {
        if (j == i + 1) {
          boxUnidirectional[i][j] = coupling;
        } else if (j == 0 && i == networkSize - 1) {
          boxUnidirectional[i][j] = coupling;
        } else {
          boxUnidirectional[i][j] = 0;
        }
      }
    }
  }
  
  /**
   * Box Bidirectional
   * 
   * {{0, X, 0, X},
   * {X, 0, X, 0},
   * {0, X, 0, X},
   * {X, 0, X, 0}}
   */
  void initializeBB() {
    boxBidirectional = new float[networkSize][networkSize];
    for (int i = 0; i < networkSize; i++) {
      for (int j = 0; j < networkSize; j++) {
        if (j == i + 1) {
          boxBidirectional[i][j] = coupling;
        } else if (i == j + 1) {
          boxBidirectional[i][j] = coupling;
        } else if (j == 0 && i == networkSize - 1) {
          boxBidirectional[i][j] = coupling;
        } else if (i == 0 && j == networkSize - 1) {
          boxBidirectional[i][j] = coupling;
        } else {
          boxBidirectional[i][j] = 0;
        }
      }
    }
  }
  
  /**
   * All-to-all
   * 
   * {{0, X, X, X},
   * {X, 0, X, X},
   * {X, X, 0, X},
   * {X, X, X, 0}}
   */
  void initializeA2A() {
    allToAll = new float[networkSize][networkSize];
    for (int i = 0; i < networkSize; i++) {
      for (int j = 0; j < networkSize; j++) {
        if (i == j) {
          allToAll[i][j] = 0;
        } else {
          allToAll[i][j] = coupling;
        }
      }
    }
  }
}

```