What needs to be done for Simulation

1 separate the plot module after the simulation end at t_max or turn_max

2 use OpenMP for parallel computation with omp.h head file

3 calculate the emittance for x-x' and center of x-direction

notice the INT_MAX in your code!

no details, but be careful ! If necessary use long long int instead.

How to optimize your code in VC++

Last time I have talked about the optimization of the running code but didn't show how to do that. Here it is:

• open you project's property and change to the C++/C

make sure that "Debug Information Format" is chosen to be "Program Databas(/Zi)

• change to "Optimization" tab, 

choose Full Optimaization(/Ox) or Maximize Speed(/O2).

• change to " Code Generation" tab

choose "Default" for "Basic Runtime Checks"

A word of caution, optimization is good for running but the debug information is hard to understand if you're in the process of debugging your code. So this optimization should apply after you find no problems in building and want to run the program for test.

array vs vector

Every beginner is struggling doing something that is so simple to others.

Once you know it, you will say to yourself: I did know it should be something simple like this.

Specify the size of array at run-time,dynamically

in C++, sometimes(for me, most of the times), we don't know how long should an array should be. If that is the case, we can do the following:

float *pTable;
int n = 100;
pTable = new float[n];

The point is that one of the common use of pointer is to allocate memory in leap . Then at run-run, you can choose the size based on the need. But once you use new, don't forget to use delete to free the memory.

delete [ ] pTable;

And notice that we also have a STL container called std::array, (include it with #include<array>), it adds useful member functions and iterators to it. So it convenient to use. But still, you need to use pointer to get a run-time specified size of it.
OK, now we see that the built-in array have some drawbacks and even for the std::array we have to specify the size of it with a constant. Why don't we just use vector, which does all the tedious work for us? "I thought for a computation intense program, array is faster than vector," you will think like this as I did. However, this is not true!
Read this link for this answer then you will not waste you time in figuring out those tedious things related to array, just go with vector and finish your work.

Then here is the conclusion: just go with vector

1. Nearly all of the time, you should choose vector instead of array( built-in or std::array). Spend those saved time in programming.
2. the vector performs less efficient only when you need change its size frequently(which makes it reallocate the memory). If that's not the case, their performance almost the same.
3. the compile spends a lot of extra work in range-checking or similar thing in debugging. Once you got your program right, you can use a optimized build and right settings (removing the STL debugging).

c++ read in file for initialization

two things you should know:

1. getline read in a single line with "\n" delimiter by default, you can specify the delimiter
2. >> will automatically skip white space and choose the right type for you

A stardard example

// ini.txt
numberofTest: 100000
kickPerTurn: 20

// code segment
ifstream ini_para("ini_parameters.txt");
if( ini_para.fail() )
cerr <<" failed to open ini_parameters.txt" ;
string dummy_string;
getline(ini_para,dummy_string,':');

         // it's import that you use ':' instead of ":" 

ini_para >> numberofTest;
cout << "numberofTest read as: " << numberofTest <<endl;
getline(ini_para,dummy_string,':');
ini_para >> kickPerTurn;
cout << "kickPerTurn read as: " << kickPerTurn <<endl;
     
        ini_para.close();

A similar discussion could be found example on cplusplus.com.

Two things today

1. Test the micro-bunching structure with momentum modulation
2. Finish the code implementing the FFT Longitudinal space-charge force

How to call Gnuplot from C++

When I have do the simulation to our physics problem, I have many data files that I want to visualize. It's not an easy work, if you are a new C++ user like me. After searching around the internet, finally I got the solution pretty nice. Here is how.

1 download and intall

go to  gnuplot.info to download the windows installer and install it (The newest edition is 4.6 till this document). Make sure that you choose "add PATH to my system" in the process of installation, or you have to add by your own. (Thanks the gnuplot team adding this for us).

2 create a general purpose head file

create a new .h file with this following content(or you can download it here):

#ifndef GNUPLOT_H_
#define GNUPLOT_H_
#include <string>
#include <iostream>
using namespace std;
class Gnuplot {
public:
Gnuplot() ;
~Gnuplot();
void operator ()(const string & command);
// send any command to gnuplot
protected:
FILE *gnuplotpipe;
};
Gnuplot::Gnuplot() {
// with -persist option you will see the windows as your program ends
//gnuplotpipe=_popen("gnuplot -persist","w");
//without that option you will not see the window

 // because I choose the terminal to output files so I don't want to see the window

 gnuplotpipe=_popen("gnuplot","w");

if (!gnuplotpipe) {
cerr<< ("Gnuplot not found !"); }
}
Gnuplot::~Gnuplot() {
fprintf(gnuplotpipe,"exit\n");
_pclose(gnuplotpipe);
}
void Gnuplot::operator()(const string & command) {
fprintf(gnuplotpipe,"%s\n",command.c_str());
fflush(gnuplotpipe);
// flush is necessary, nothing gets plotted else
};
#endif

3 use the head file and plot

 now you have a class of gnuplot, so you can initialize it with object and send the command directly to gnuplot. If you don't know what I mean, check the example I use to test under Windows(example.cpp)

#include <iostream>
#include "gnuplot.h"
using namespace std;
int main(){
Gnuplot plot;
plot("plot sin(x)") ;
system("pause");
plot("plot cos(x)") ;
system("pause");
return 0;
}

Others:

The good side is that you can customize what you want to plot and make it automatically done for you.
The bad side is that it is the same usage as gnuplot itself. I mean, if you have to plot the simulation results, you have to output them then read in and plot the graph out. If you concerns only on the graph instead of the output data files, you will find that the most time-consuming thing for C++ is output files. If you have better solution for this( directly plot with a data structure), please let me know. I know there's some pipe written for this but they just don't work for me. Maybe you have better suggestion. Thanks.

Use FFTW in C++

Linux/Unix

in Ubuntu it's very easy, just compile the source, then link the library to the project in project property. I use ellipse to write the program, no problem with that.

Windows

I never succeed in linking the fftw library in Microsoft Visual C++ Express 2010, though my friend told me there's no problem with that. I use 64-bit Windows 7.

there're basically three things you need to do if you have the same environment as me:
all you need is the following: fftw3.h, three .dll files(libfftw3-3.dll,libfftw3l-3.dll,libfftw3f-3.dll), three .def files(libfftw3-3.def,libfftw3l-3.def,libfftw3f-3.def).

1 generate the .lib files

In fact, .lib files is necessary but not included in the .zip files we download from fftw.org. That's because it's better to compile for yourself what you need (-- at least let's think in this way, I know some of you don't agree with me on this point).
open cmd.exe, then direct to the folder where your lib.exe is, for example, here is mine with a default installation of VC++ Express:

 C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\bin

(oh, wait a moment, you should copy the following files from another folder to the \bin folder before you can proceed, I guess--at least for me it's like this:

C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE

msobj100.dll
mspdb100.dll
mspdbcore.dll
mspdbsrv.exe

if you are using 2011, I think it's something like msobj110.dll )
 now copy those three .def files into the \bin folder.
then use lib.exe setup under cmd environment to generate the three .lib files in compatible to your system(change your machinetype, 64-bit windows is x64, 32-bit is x86)

lib /machine:x64 /def:libfftw3-3.def
lib /machine:x64 /def:libfftw3f-3.def
lib /machine:x64 /def:libfftw3l-3.def

OK, we're finished with three .lib files. (I recommend you generate another 32-bit like me in case you may use them later) Move the three .lib files out to the original folder where it should be, for example, here I just copy them back to the same folder as  fftw3.h (in fact, you just find a place you find convenient).

2 link the library before you can use #include<fftw3.h> in your code:

copy the three .dll files into the default folder of your project ( the same as .vcxproj and .vcxproj.filters, default for your code). (In fact, I just copy one, because I only use this one: libfftw3-3.dll. And I also have a folder like "\fftw-3.3.1-dll64" here to contain my .h file and .lib files)
open the properties of you project, under the "C/C++" option, chose "general", then add the path of you fftw3.h files(should be in a folder) into "Additional Include Directories"
change to the "Linker" option and choose "general", add the .lib files path(could be the same folder) to the "Additional Library Directories"
under the  "Linker" option and choose "input", add the following items to the "Additional Dependencies":

libfftw3-3.lib
libfftw3l-3.lib
libfftw3f-3.lib

3 (if you're using 64-bit windows as me) change your project to be compiled as 64-bit as you use 64-bit compiled .lib files to the .dll files.
(I get this help from stackflow:

http://stackoverflow.com/questions/1865069/how-to-compile-a-64-bit-application-using-visual-c-2010-express Remind you that you should install Windows7.1SDK if you want to debug as 64-bit with Express 2010, with other Visual Studio I think you have x64 debugger with you )

However, I didn't succeed with that as I mentioned at the beginning. I tried 32-bit .lib files and it didn't work either. As frustrated as me, I installed the trial version of Visual Studio 2011, where I got the x64 debug on its installation and it's easy to get it done like this( almost same as the above link):

Go to Properties of your project. On the top of the dialog box there will be a "Configuration" drop-down menu. Make sure that selects "All Configurations." There will also be a "Platform" drop-down that will read "Win32." Finally on the right there is a "Configuration Manager" button - press it. In the dialog that comes up, find your project, hit the Platform drop-down, select New, then select x64. When you return to the Properties dialog box, the "Platform" drop-down should now read "x64."

(

By the way, if you have problem in debugging. Follow this:

 How to rightly set-up debug:
1) Goto your Project Properties
2) On the left expand "Configuration Properties"
3) Expand "C/C++"
4) On the left, Select "General"
5) On the right, change "Debug Information Format" to "Program Database For Edit And Continue (/ZI)"
5) On the left, Select "Optimization"
6) On the right, change "Optimization" to "Disabled (/Od)"
7) On the left, expand "Linker"
8) On the left, select "Debugging"
9) On the right, change "Generate Debug Info" to "Yes"
10) Click ok
11) Set your breakpoints
12) Rebuild your application

Also when running your application use Ctrl+F5 to build and run it, this keeps the console window open long enough for you to see your output.
)

OK, well done, now you can #include<fftw3.h> and test an example. The best one is on the fftw manual, check it instead of the Internet.

The Mathematica Documents

Beam Lattice

• ring Lattice: finished and justified(two methods)
• LEBT lattice: almost finished

(both of them could be compared with Madx's output)

Experimental Data Analyzing

• Bdc results: finished. with FFT to get the period and a manipulate to get a dynamic view turn by turn
• Bac results: no

Others:

• FFT method for LSC(part II)--needed to be improved
• part I needed to be write

Period for 200kV Helium 1 plus in DA

 The difference between calculated one and experimental one

calculation

For this calculation, at first glance, it is as simple as C0/v. Yes, you can say that only if:

• correct circumference of the ring
• correct rest mass of Helium
• properly choose the right constant for light speed, proton mass, neutron mass, electron charge
• the kinetic energy for the beam is precisely as 200 kv

After I choose the  following parameters(as used in harada's table calculation)

• C0 = 37.71 m
• const double lightSpeed = 2.99792458e8 m/s
• const double electronCharge = 1.60217646e-19 C
• const double protonMass = 1.672621e-27 kg
• const double NeutronMass = 1.674927e-27 kg

for 200kv Helium 1+, circumference of the ring taken as 37.71m, 

lightSpeed = 2.99792458*10^8;

electronCharge=1.60217646*10^-19;

protonMass=1.672621*10^-27;

NeutronMass=1.674927*10^-27;

HeliumRest = 2*(NeutronMass+protonMass)*lightSpeed^2/electronCharge

ringLength=37.71;

extV=2*10^5;

gamma=extV/HeliumRest+1

beta=Sqrt[1-1/gamma^2]

T=ringLength/(beta*lightSpeed)

Output:

 beta = 0.0103197
T=12.189 us

if calculated with (as in Harada's "TsGEN3_20111025"):

•  m0 = A * 1.6726231e-27 
• A = 4
• gamma = 1.0 + kinetic_energy * e / ( m0 * c * c )
• beta = sqrt( 1 - 1/(gamma*gamma) )

the output is the same.

energy error

if we assume some energy differece at the injection, for example, 201kV, then the result is
T=12.1586 us

method error and ring length error

if we use atomic weight of helium as 4.002602 and atomic mass unit corresponding to energy in eV as 931.494061×10^6, the result is
T=12.1446 us
further more, if the change the ring length to be 37.75(4 cm longer)
T=12.1575 us

experiment

However, after doing FFT analysis to the bunch signal from the experimental data, the period is(2011116,1206,1222),:

T_experiment=12.1579 us

the difference is about: ( T - T_experiment )/T_experiment = 0.26%. This is a difference of 31 ns. Provided that the rise time of our Vbb is around ~80, or ~100 ns, in the experiment with Vbb this might be a problem.(in fact it may be good for commissioning, because the bunch tends to  "arrive later" when the B field is rising without acceleration to the beam.

others

I notice that for the 20111116 data, we did the experiment for different bunch length and different beam current. But the FFT analysis suggests that the period is changing as time goes by. This may suggested that the voltage is not so consistent with the B-field.

A better way is to do FFT to the part of the data ( for example, every 5 turns) until the time end(for example, 4ms as we usually use), then we can get a T changing along the time.

Strictly speaking, we cannot keep the extraction energy precisely every time we do the beam commissioning. However, as we can see by different date, the period given by the experiment is somehow repeat itself. With this we can safely say they're unnoticeable difference on the injection energy.

Note that if the injection energy is different from the what it needs to be with the B field, the period will change as time goes on.

conclusion at this momentum

as discussed above, use the atomic weight and a length of 37.75m is closer to the experiment result, if the result is reliable.

Barrier voltages could be detrimental to beam commissioning

The formal scheme is that we trigger the Vac and Vbb voltage with a relative delay to the referential signal.

However, as the by the default idea of pulse density control (with or without threshold for accumulated required voltage), in the phase space of  (t, dp_p), the bunch would travel to the negative part of dp_p, then go to the right-hand-side, where the beam tail would meet the Vbb there. Thus we can observe that the bunch is kicked back from there.

In a better situation(or ideal case), the Vbb should do its own job by just restrain the bunch from becoming longer due to momentum deviation and longitudinal space charge.

Thus, when we set the Vac and Vbb, we should use a different referential signal( or with modified delays), to ensure that Vbbs are located at the equal distance from the center every turn.

Let Vbb does its job. The same thing should be applied to Vac.

Einzel lens and Momentum Modulation

What happened in DA's beam commissioning

1. Einzel lens is adopted to chop the beam (several us out of 5ms): using Marx generator with a pulse profile.
2. This technique has a byproduct that momentum modulation would occur to the rise and fall region of that pulse for Einzel lens.
3. The momentum modulation in the beam head and tail has two effect: 
1. good one: compensate somehow to the longitudinal space charge effect
2. bad one: resulting micro-bunching inside the beam

remained issues:

1. explain why the pulse used for Einzel lens results in momentum modulation in rise and fall region(beam head and tail)
2. could you give a mathematical description of that process, along with related parameters, e.g. rise&fall time, dimension of einzel lens, operation voltage(for 14 kv, 17 kv ->11 kv, for 10kv, 13->8kv)
3. what do you mean by "compensate", could you give some example?
4. could you give a mathematical description on the effect of momentum modulation within the beam? Especially, what's the difference between motions with and without space charge? Is there still micro-bunching structure inside the beam without space charge?

Problems for the LSC with FFT

Today's task(1 simulation):

1. compare the phase space evolution between different momentum spread without LSC
2. find the relationship between number of bins & number of test particles versus the density profile
3. find a better way to retrieving the density profile

(2 Master Thesis)

1. Finishing learning LaTeX
2. study the Material of Bac-Bdc

(3 20111116 data summary)