Computational Lab in Physics: Final Project

The Mandelbrot Set.

2

Rendering the Mandelbrot Set

Defined in the Complex plane Use the c++ complex class.

Set of points such that the mapping z -> z2 + cdoes not escape to infinity.

In code: must use a threshold. One can use e.g. |z|<4. must use a finite number of iterations. One

can use 100 or 1000 (or make the iterations depend on the scale of the plot).

3

Part 1: Render the Mandelbrot Set

Use the complex class to simplify your life, all computations are in the complex plane. complex<double> cmpx(1,1);

Do a program that will loop over the complex plane in the range: -2 < Real Part < +1 -1 < Imaginary Part < +1

For each complex number in the loop, use it as the parameter in the recurrence relation: z -> z2 + c

Initial value of z=(0,0).

4

Part 1: Continued, Render M set

Test to determine if a point is in the set or not: if |z| is always < 4 after 100 iterations, the point is

considered to be in the set. if |z| goes beyond 4, it is not in the set. The number of iterations can be used as a

“distance” measure of the point to the set. Use this to create a 2-D histogram

Each cell represents a choice of the c parameter: x-axis : Real Part of c y-axis : Imaginary Part of c

Fill each cell with a weight equal to the number of iterations done by the algorithm for that value of c.

5

Result from Part 1: Obtain a plot of the Mandelbrot Set

Save it as a gif file from root: “part1.gif”

60 points

6

Part 2: Look at the fine detail.

Now that you can render the Mandelbrot Set, have some fun with it: It is easy to look at a smaller region, all you do is change

the region you will loop over: RealPartMin < Real Part < RealPartMax ImagPartMin < Imaginary Part < ImagPartMax

Result from part 2: Choose a new range, magnification of at least 10,000 (5 points)

Save as part2a.gif Magnfication of 1,000,000 or more (5 points)

Save as part2b.gif Note:

number of iterations can be adjusted. can try a different color palette in ROOT.

7

Magnificent magnifications…

Coordinates of the center: Re(c) =

-.743,643,887,037,151, Im(c)

= .131,825,904,205,330 Horizontal diameter of the

image: .000,000,000,051,299

Magnification relative to the initial image: 59,979,000,000

Note: plot not done with ROOT. See wikipedia entry for Mandelbrot Set for reference.

8

Make an Animation: zoom into a small region

Saved directly from ROOT using TCanvas::Print(“part3.gif+10”);

40 Points

9

Final Project Summary

Part 1: you rendered it full scale, name it “LastnamePart1.gif” 60 points

Part 2: you zoomed into a small region. 5 + 5 = 10 points Name them “LastnamePart2a.gif” and “LastnamePart2b.gif”

Part 3: you can render many plots between the full Mandelbrot set and the zoomed in region. Use the one with the largest magnification factor.

Modify the program to make 20 plots for 20 choices of the complex plane range.

Save each plot into an animated gif: Use TCanvas::Print(“LastnamePart3.gif+10”);

The +n in the Print command will save the frame with a delay of n x 10 ms with respect to the previous frame.

30 points Extra credit: Continuos Animation, use Gimp or Photoshop.

10

Extra points: Continuous Animations, Zoom in & out and repeat…

Saved with ROOT using TCanvas::Print(“part3.gif+10”);

Edited with the GIMP to produce continuous In+Out animation that repeats over and over. Photoshop works too, if you have it. (GIMP is free.) 10 extra points.

11

Suggestions:

One can do the programs all in root. Suggest to split into two parts:

C++ Program to produce a text file with all the values needed to make a plot.

compile it so it’s fast ROOT independent, so it’s portable

ROOT macro read the text file fill in the histograms TH2D draw histogram in canvas save the gif file with TCanvas::Print

12

Useful code Snippets.

13

Text output into many files: ofstream

#include <fstream>

char filename[255]; sprintf(filename,"MandelbrotRunDataAdapIter%i.txt",i); cout << filename << endl; ofstream mandelOutput(filename); for (double c_real=RealPartMin[i];

c_real<RealPartMax[i];c_real+=stepSizeRe) { for (double c_imag=ImagPartMin[i]; c_imag<ImagPartMax[i];

c_imag+=stepSizeIm) {

// iterate until iter>100 or |z|>4

mandelOutput << c_real << '\t' << c_imag << '\t' << iter << endl;

14

Using the complex class

Operators defined for complex numbers +, -, *, /, -=, +=, /=, *=, =, ==, !=

Overloading of operators: complex_ob + scalar scalar + complex_ob complex_ob + complex_ob

Functions: Returning a scalar:

T abs(const complex<T> &ob) : absolute value T arg(const complex<t> &ob) : phase angle T conj(…) : complex conjugate cos, cosh, exp, imag, log, log10, pow, real, sin, sinh sqrt, tan, tanh, do the

obvious T norm(const complex<T> &ob) : magnitude squared complex<T> polar(const T& v, const T& theta=0) : magnitude specified by

v and phase angle specified by theta

15

Demonstrating complex class#include <iostream>#include <complex>using namespace std;int main() {complex<double> cmpx1(1,0);complex<double> cmpx2(1,1);

cout << cmpx1 << “ “ << cmpx2 << endl;

complex<double> cmpx3 = cmpx1*sqrt(cmpx2);

cout << cmpx3 << endl;

cmpx3+=10;cout << cmpx3 << endl;

return 0;}

16

Avoiding some problems with TH2D

Make sure to match your number of bins with the step size and number of calculations.

Example: nBinsx=1000; // bins along Real (x-axis) nBinsy=1000; // bins along Imag (y-axis) xRangeMin= -2; xRangeMax= 1; yRangeMin = -1;yRangeMax= 1 stepSizeX = (xRangeMax – xRangeMin )/nBinsX

Book the histogram using above values. Even better book histogram with range:

xRangeMin-stepSizeX/2 to xRangeMax-stepSizeX/2

17

Reading data from text files//loop to read many files that have a similar name// and one number to index them.for (int i=0; i<nPlots; ++i) {char filename[255];sprintf(filename,"MandelbrotRunData%i.txt",i);ifstream inputFile(filename);

//read the data// example, read 1 line:char buffer[255]l;inputFile.getline(buffer,255);//example, read 3 numbers from a linedouble number1, number2, number3;inputFile >> number1 >> number2 >> number3;// note that one must take care of end-of-lines.// another useful loop: while(!inputFile.eof()) { // keep reading next line }// do something with data.

}

18

Playing with Palettes gStyle:

SetPalette(1,0); RGB colors in the

range 51 to 99 SetPalette(51,0);

Deep blue to light blue Look in TColor class:

SetPalette CreateGradientColorTa

ble

19

Example (modified from R. Brun’s in ROOTTALK)

void colorPalette() {//example of new colors and definition of a new palette const Int_t colNum = 200; Int_t palette[colNum/2]; for (Int_t i=0;i<colNum/2;i++) { TColor *color = new

TColor(501+i,0,Float_t(i)/(colNum/2.),Float_t(i)/(colNum),""); palette[i] = 501+i; } gStyle->SetPalette(colNum/2,palette); TF2 *f2 = new TF2("f2","exp(-(x^2) - (y^2))",-1.5,1.5,-1.5,1.5); //f2->SetContour(colNum); f2->Draw("colz"); return;}

Plot using the abovepalette

20

More control over colors:

void colorPalette() {//example of new colors (greys) and definition of a new palette const Int_t NRGBs = 5; const Int_t NCont = 256;

Double_t stops[NRGBs] = { 0.00, 0.30, 0.61, 0.84, 1.00 }; Double_t red[NRGBs] = { 0.00, 0.00, 0.57, 0.90, 0.51 }; Double_t green[NRGBs] = { 0.00, 0.65, 0.95, 0.20, 0.00 }; Double_t blue[NRGBs] = { 0.51, 0.55, 0.15, 0.00, 0.10 }; gStyle->CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont); gStyle->SetNumberContours(NCont); TF2 *f2 = new TF2("f2","exp(-(x^2) - (y^2))",-1.5,1.5,-1.5,1.5); //f2->SetContour(colNum); f2->SetNpx(300); f2->SetNpy(300); f2->Draw("colz"); return;}