FilesExpand file tree

 master

/

plotting_backend.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

58 lines (47 loc) · 1.76 KB

 master

/

plotting_backend.py

Copy path

Top

File metadata and controls

• Code
• Blame

58 lines (47 loc) · 1.76 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

"""An example of how to use IPython for plotting remote parallel data

The two files plotting_frontend.py and plotting_backend.py go together.

This file (plotting_backend.py) performs the actual computation. For this

example, the computation just generates a set of random numbers that

look like a distribution of particles with 2D position (x,y) and

momentum (px,py). In a real situation, this file would do some time

consuming and complicated calculation, and could possibly make calls

to MPI.

One important feature is that this script can also be run standalone without

IPython. This is nice as it allows it to be run in more traditional

settings where IPython isn't being used.

When used with IPython.parallel, this code is run on the engines. Because this

code doesn't make any plots, the engines don't have to have any plotting

packages installed.

"""

from __future__ import print_function

# Imports

import numpy as N

import time

import random

# Functions

def compute_particles(number):

x = N.random.standard_normal(number)

y = N.random.standard_normal(number)

px = N.random.standard_normal(number)

py = N.random.standard_normal(number)

return x, y, px, py

def downsample(array, k):

"""Choose k random elements of array."""

length = array.shape[0]

indices = random.sample(xrange(length), k)

return array[indices]

# Parameters of the run

number = 100000

d_number = 1000

# The actual run

time.sleep(0) # Pretend it took a while

x, y, px, py = compute_particles(number)

# Now downsample the data

downx = downsample(x, d_number)

downy = downsample(x, d_number)

downpx = downsample(px, d_number)

downpy = downsample(py, d_number)

print("downx: ", downx[:10])

print("downy: ", downy[:10])

print("downpx: ", downpx[:10])

print("downpy: ", downpy[:10])