Home
Introduction
Examples
Downloads
Documentation
Script Repository
FAQ
Links
TODO
News
Project Page
Contacts
Home
Introduction
Examples
Downloads
Documentation
Script Repository
FAQ
Links
TODO
News
Project Page
Contacts
|
raman_wigner_diff.xmdsScript source: raman_wigner_diff.xmds.gz
<?xml version="1.0"?>
<!--Fibre soliton (sagnac configuation) squeezing calculation in -->
<!--Wigner representation -->
<!--Raman noise modelled by including a heap (10) of cross-propagating -->
<!--phonon modes. This is a really cumbersome thing to do at the -->
<!--moment in xmds. It would be a lot easier if one could simulate -->
<!--integro-differential equations in xmds (with nonlocal terms), or -->
<!--if arrays of fields could be defined.-->
<!--Also there is something funny going on with the initialization of -->
<!--the cross-propagating modes - it changes with the longitudinal -->
<!--(forward-propagating) coordinate, if the cross-propagating mode -->
<!--has some initial dynamics-->
<!DOCTYPE simulation [
<!ENTITY Nt "256">
<!ENTITY tmax "25.0">
]>
<simulation>
<name>raman_wigner_diff</name>
<author>Joel Corney</author>
<description>
Fibre soliton (sagnac configuation) squeezing calculation in
Wigner representation.
Raman noise modelled by including a heap (10) of cross-propagating
phonon modes. This is a really cumbersome thing to do at the
moment in xmds. It would be a lot easier if one could simulate
integro-differential equations in xmds (with nonlocal terms), or
if arrays of fields could be defined. Also there is something
funny going on with the initialization of
the cross-propagating modes - it changes with the longitudinal
(forward-propagating) coordinate, if the cross-propagating mode
has some initial dynamics.
</description>
<prop_dim>x</prop_dim>
<error_check>yes</error_check>
<stochastic>yes</stochastic>
<use_mpi>yes</use_mpi>
<paths>10000</paths>
<seed>10 20</seed>
<noises>40</noises>
/***********/
<globals>
/***********/
<![CDATA[
const double Pi = 2.0*asin(1.0);
/*Initial Pulse Shape parameters*/
const double vel = 0.0;
const double hwhm = 1.0;
const double gain = 0;
const double loss = 0;
const double alpha = 0.9; /* Pulse splitting ratio alpha/(1-alpha)*/
/*Photon number and related scalings*/
const double f = 0.2; /*Raman fraction of nonlinearity*/
const double n = (1-f)*6.8E8 ; /*Photon number scaling*/
const double eps = 1.0/(2.0*n); /*Zero-point correction*/
const double z = sqrt((gain+loss)*eps); /*Gain/loss noise scaling*/
/* Raman Data */
const double T = 300.0; /* Temperature in Kelvin */
const double t0 = 0.0715; /*Time scale in picoseconds*/
const double Fj[11] = {0.16,-0.3545,1.2874,-1.4763,1.0422,-0.4520,0.1623,1.3446,-0.8401,-0.5613,0.0906};
const double Omegaj[11] = {0.005,0.3341,26.1129,32.7138,40.4917,45.4704,93.0111,99.1746,100.274,114.625,151.4672};
const double Deltaj[11] = {0.005,8.0078,46.6540,33.0592,30.2293,23.6997,2.1382,26.7883,13.8984,33.9373,8.3649};
/* Phonon Constants*/
const double g = 2; /*Virtual gain for dynamic noise initialisation */
const int Nb = 10; /*Number of phonon variables*/
const double omega_max = 160*t0; /*Maximum phonon frequency*/
const double delta_omega = omega_max/Nb; /*phonon frequency step*/
double r[Nb]; /*Raman coupling*/
double omega[Nb]; /*Phonon Frequency*/
double b_init[Nb]; /*Initial phonon noise scaling*/
complex b[Nb]; /*Container for phonon variables*/
complex db[Nb]; /*Container for phonon variables*/
complex b_lo[Nb]; /*Container for l.o. phonon variables*/
complex db_lo[Nb]; /*Container for l.o. phonon variables*/
complex expikt[Nb]; /*Container for phonon free evolution operator*/
]]>
</globals>
/*************/
<field>
/*************/
<name>main</name>
<dimensions> t </dimensions>
<lattice> &Nt; </lattice>
<domains> (-&tmax;,&tmax;) </domains>
<samples>1 1 1 1</samples>
/***MAIN***/
<vector>
<name>main</name>
<type>complex</type>
<components>phi dphi psi dpsi</components>
<fourier_space>no</fourier_space>
<![CDATA[
const double split = (1.0-alpha)/alpha; /* Pulse splitting ratio*/
const double w0 = 1.0 ; /*hwhm*sqrt(2/log(2.0))*/
const double amp1 = 1.0;
const double amp2 = sqrt(split);
phi = pcomplex(amp1*2/(exp(w0*t)+exp(-w0*t)),vel*t); /*sech soliton*/
dphi = rcomplex(n_1,n_2)/(2*sqrt(n)); /* soliton noise */
psi = pcomplex(amp2*2/(exp(w0*t)+exp(-w0*t)),vel*t); /*local oscillator*/
dpsi = rcomplex(n_3,n_4)/(2*sqrt(n)); /*l.o. noise */
/*While we're here initialising fields,
we will also initialise some global parameters for the phonon fields */
double nth; /*B-E distribution for initial thermal state of phonons*/
double h; /*Imaginary part of the Fourier Raman nonlinear response function*/
if (t <= -]]>&tmax;<![CDATA[) {
for (int k=0; k<Nb; k++) { /*Frequency-depedent Raman initialisations*/
omega[k] = (k+1)*delta_omega;
nth = 1.0/(exp(7.6382*omega[k]/(T*t0))-1.0);
h = 0.0;
for (int j=1; j<11; j++) {
h += Fj[j]*Deltaj[j]*Deltaj[j]*t0*t0*Omegaj[j]*t0*omega[k]/
((Deltaj[j]*Deltaj[j]*t0*t0 + Omegaj[j]*Omegaj[j]*t0*t0 - omega[k]*omega[k])*
(Deltaj[j]*Deltaj[j]*t0*t0 + Omegaj[j]*Omegaj[j]*t0*t0 - omega[k]*omega[k])
+ 4*Deltaj[j]*Deltaj[j]*t0*t0*omega[k]*omega[k]);
}
r[k] = sqrt(2.0/Pi)*sqrt(fabs(h)); /*Raman gain function*/
b_init[k] = r[k]*sqrt((nth+0.5)/(delta_omega*n)); /*For initialisation of phonons*/
//printf("%g %g %g\n", 1.0*k, omega[k],r[k]);
}
}
]]>
</vector>
/***CROSS***/
<vector> /*Initialise the phonon variables */
<name>cross</name>
<type>complex</type>
<components>b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 db0 db1 db2 db3 db4 db5 db6 db7 db8 db9 b_lo0 b_lo1 b_lo2 b_lo3 b_lo4 b_lo5 b_lo6 b_lo7 b_lo8 b_lo9 db_lo0 db_lo1 db_lo2 db_lo3 db_lo4 db_lo5 db_lo6 db_lo7 db_lo8 db_lo9</components>
<![CDATA[
/*XMDS cannot do stochastic initialisation for cross-propagation variables - must do this dynamically in integrate routine*/
db0 = 0.0; /* b_init[0]*rcomplex(n_1,n_2); */
db1 = 0.0; /* b_init[1]*rcomplex(n_3,n_4); */
db2 = 0.0; /* b_init[0]*rcomplex(n_1,n_2); */
db3 = 0.0; /* b_init[1]*rcomplex(n_3,n_4); */
db4 = 0.0; /* b_init[0]*rcomplex(n_1,n_2); */
db5 = 0.0; /* b_init[1]*rcomplex(n_3,n_4); */
db6 = 0.0; /* b_init[0]*rcomplex(n_1,n_2); */
db7 = 0.0; /* b_init[1]*rcomplex(n_3,n_4); */
db8 = 0.0; /* b_init[0]*rcomplex(n_1,n_2); */
db9 = 0.0; /* b_init[1]*rcomplex(n_3,n_4); */
b0 = 0.0;
b1 = 0.0;
b2 = 0.0;
b3 = 0.0;
b4 = 0.0;
b5 = 0.0;
b6 = 0.0;
b7 = 0.0;
b8 = 0.0;
b9 = 0.0;
db_lo0 = 0.0;
db_lo1 = 0.0;
db_lo2 = 0.0;
db_lo3 = 0.0;
db_lo4 = 0.0;
db_lo5 = 0.0;
db_lo6 = 0.0;
db_lo7 = 0.0;
db_lo8 = 0.0;
db_lo9 = 0.0;
b_lo0 = 0.0;
b_lo1 = 0.0;
b_lo2 = 0.0;
b_lo3 = 0.0;
b_lo4 = 0.0;
b_lo5 = 0.0;
b_lo6 = 0.0;
b_lo7 = 0.0;
b_lo8 = 0.0;
b_lo9 = 0.0;
]]>
</vector>
/***HEAVISIDE***/
<vector> /*Step function*/
<name>Heaviside</name>
<type>double</type>
<components>step_function</components>
<![CDATA[
if (t<-4.0*]]>&tmax;<![CDATA[/5.0)
step_function = 1.0;
else
step_function = 0.0;
]]>
</vector>
/***PHONONS***/
<vector>
<name>Phonons</name> /*Constant operator for phonon free evolution*/
<type>complex</type>
<components>expikt0 expikt1 expikt2 expikt3 expikt4 expikt5 expikt6 expikt7 expikt8 expikt9</components>
<![CDATA[
for (int k=0; k<Nb; k++) {
expikt[k] = c_exp(i*omega[k]*t);
}
expikt0 = expikt[0];
expikt1 = expikt[1];
expikt2 = expikt[2];
expikt3 = expikt[3];
expikt4 = expikt[4];
expikt5 = expikt[5];
expikt6 = expikt[6];
expikt7 = expikt[7];
expikt8 = expikt[8];
expikt9 = expikt[9];
]]>
</vector>
</field>
/******************/
<sequence>
/******************/
<integrate>
<algorithm>SIIP</algorithm>
<interval>12.57</interval>
<lattice>500</lattice>
<samples>25 100 25 100</samples>
<k_operators>
<constant>yes</constant>
<operator_names>L</operator_names>
<![CDATA[
L = rcomplex(gain-loss,-kt*kt/2);
]]>
</k_operators>
<iterations>4</iterations>
<vectors>main cross Heaviside Phonons</vectors>
<![CDATA[
/* Note: must avoid square brackets in this section,
because xmds will rip them out!! Hence all the pointers. */
double I = 0.0; /*Integral(sum) over phonon variables*/
double dI = 0.0; /*Integral(sum) over phonon variables*/
complex* b_pointer = b; /* pointer to zeroth element of b */
complex* db_pointer = db; /* pointer to zeroth element of db */
double I_lo = 0.0; /*Integral(sum) over l.o. phonon variables*/
double dI_lo = 0.0; /*Integral(sum) over l.o. phonon variables*/
complex* b_lo_pointer = b_lo; /* pointer to zeroth element of b_lo */
complex* db_lo_pointer = db_lo; /* pointer to zeroth element of db_lo */
complex* expikt_pointer = expikt; /* pointer to zeroth element of expikt */
*b_pointer = b0; /*Assign b0 to what b_pointer points to (ie zeroth element of b)*/
*(b_pointer+1) = b1;
*(b_pointer+2) = b2;
*(b_pointer+3) = b3;
*(b_pointer+4) = b4;
*(b_pointer+5) = b5;
*(b_pointer+6) = b6;
*(b_pointer+7) = b7;
*(b_pointer+8) = b8;
*(b_pointer+9) = b9;
*db_pointer = db0;
*(db_pointer+1) = db1;
*(db_pointer+2) = db2;
*(db_pointer+3) = db3;
*(db_pointer+4) = db4;
*(db_pointer+5) = db5;
*(db_pointer+6) = db6;
*(db_pointer+7) = db7;
*(db_pointer+8) = db8;
*(db_pointer+9) = db9;
*b_lo_pointer = b_lo0; /*Assign b_lo0 to what b_lo_pointer points to (ie zeroth element of b_lo)*/
*(b_lo_pointer+1) = b_lo1;
*(b_lo_pointer+2) = b_lo2;
*(b_lo_pointer+3) = b_lo3;
*(b_lo_pointer+4) = b_lo4;
*(b_lo_pointer+5) = b_lo5;
*(b_lo_pointer+6) = b_lo6;
*(b_lo_pointer+7) = b_lo7;
*(b_lo_pointer+8) = b_lo8;
*(b_lo_pointer+9) = b_lo9;
*db_lo_pointer = db_lo0;
*(db_lo_pointer+1) = db_lo1;
*(db_lo_pointer+2) = db_lo2;
*(db_lo_pointer+3) = db_lo3;
*(db_lo_pointer+4) = db_lo4;
*(db_lo_pointer+5) = db_lo5;
*(db_lo_pointer+6) = db_lo6;
*(db_lo_pointer+7) = db_lo7;
*(db_lo_pointer+8) = db_lo8;
*(db_lo_pointer+9) = db_lo9;
*expikt_pointer = expikt0;
*(expikt_pointer+1) = expikt1;
*(expikt_pointer+2) = expikt2;
*(expikt_pointer+3) = expikt3;
*(expikt_pointer+4) = expikt4;
*(expikt_pointer+5) = expikt5;
*(expikt_pointer+6) = expikt6;
*(expikt_pointer+7) = expikt7;
*(expikt_pointer+8) = expikt8;
*(expikt_pointer+9) = expikt9;
/* First sum the phonon variables*/
for (int k = 0; k<Nb;k++) {
I += 2*real(*(b_pointer+k)/(*(expikt_pointer+k)))*delta_omega;
dI += 2*real(*(db_pointer+k)/(*(expikt_pointer+k)))*delta_omega;
I_lo += 2*real(*(b_lo_pointer+k)/(*(expikt_pointer+k)))*delta_omega;
dI_lo += 2*real(*(db_lo_pointer+k)/(*(expikt_pointer+k)))*delta_omega;
}
/*Now do integration of photon variables*/
ddphi_dx = L[dphi] + (1.0-f)*i*((~dphi+~phi)*(2.*dphi*phi+dphi*dphi)+~dphi*phi*phi)
+ rcomplex(n_1,n_2)*z - i*(I*dphi+dI*phi+dI*dphi) ;/*-i*r0*phi*n_5 *//* includes Raman noise*/
dphi_dx = L[phi] +(1.0-f)*i*~phi*phi*phi - i*I*phi; /* includes Raman NL*/
ddpsi_dx = L[dpsi] + (1.0-f)*i*((~dpsi+~psi)*(2.*dpsi*psi+dpsi*dpsi)+~dpsi*psi*psi)
+ rcomplex(n_3,n_4)*z - i*(I_lo*dpsi+dI_lo*psi+dI_lo*dpsi); /* includes Raman noise*/
dpsi_dx = L[psi]+ (1.0-f)*i*~psi*psi*psi - i*I_lo*psi; /* includes Raman NL*/
]]>
/*****************/
<cross_propagation> /*Integrate phonon variables*/
/*****************/
<vectors>cross</vectors>
<prop_dim>t</prop_dim>
<![CDATA[
complex increment[Nb];
complex dincrement[Nb];
complex complex_noise[Nb];
complex increment_lo[Nb];
complex dincrement_lo[Nb];
complex complex_noise_lo[Nb];
b[0] = b0;
b[1] = b1;
b[2] = b2;
b[3] = b3;
b[4] = b4;
b[5] = b5;
b[6] = b6;
b[7] = b7;
b[8] = b8;
b[9] = b9;
db[0] = db0;
db[1] = db1;
db[2] = db2;
db[3] = db3;
db[4] = db4;
db[5] = db5;
db[6] = db6;
db[7] = db7;
db[8] = db8;
db[9] = db9;
b_lo[0] = b_lo0;
b_lo[1] = b_lo1;
b_lo[2] = b_lo2;
b_lo[3] = b_lo3;
b_lo[4] = b_lo4;
b_lo[5] = b_lo5;
b_lo[6] = b_lo6;
b_lo[7] = b_lo7;
b_lo[8] = b_lo8;
b_lo[9] = b_lo9;
db_lo[0] = db_lo0;
db_lo[1] = db_lo1;
db_lo[2] = db_lo2;
db_lo[3] = db_lo3;
db_lo[4] = db_lo4;
db_lo[5] = db_lo5;
db_lo[6] = db_lo6;
db_lo[7] = db_lo7;
db_lo[8] = db_lo8;
db_lo[9] = db_lo9;
expikt[0] = expikt0;
expikt[1] = expikt1;
expikt[2] = expikt2;
expikt[3] = expikt3;
expikt[4] = expikt4;
expikt[5] = expikt5;
expikt[6] = expikt6;
expikt[7] = expikt7;
expikt[8] = expikt8;
expikt[9] = expikt9;
complex_noise[0] = rcomplex(n_1,n_2)/sqrt(2.0); /*Initial phonon noise*/
complex_noise[1] = rcomplex(n_3,n_4)/sqrt(2.0); /*Initial phonon noise*/
complex_noise[2] = rcomplex(n_5,n_6)/sqrt(2.0); /*Initial phonon noise*/
complex_noise[3] = rcomplex(n_7,n_8)/sqrt(2.0); /*Initial phonon noise*/
complex_noise[4] = rcomplex(n_9,n_10)/sqrt(2.0); /*Initial phonon noise*/
complex_noise[5] = rcomplex(n_11,n_12)/sqrt(2.0); /*Initial phonon noise*/
complex_noise[6] = rcomplex(n_13,n_14)/sqrt(2.0); /*Initial phonon noise*/
complex_noise[7] = rcomplex(n_15,n_16)/sqrt(2.0); /*Initial phonon noise*/
complex_noise[8] = rcomplex(n_17,n_18)/sqrt(2.0); /*Initial phonon noise*/
complex_noise[9] = rcomplex(n_19,n_20)/sqrt(2.0); /*Initial phonon noise*/
complex_noise_lo[0] = rcomplex(n_21,n_22)/sqrt(2.0); /*Initial l.o. phonon noise*/
complex_noise_lo[1] = rcomplex(n_23,n_24)/sqrt(2.0); /*Initial l.o. phonon noise*/
complex_noise_lo[2] = rcomplex(n_25,n_26)/sqrt(2.0); /*Initial l.o. phonon noise*/
complex_noise_lo[3] = rcomplex(n_27,n_28)/sqrt(2.0); /*Initial l.o. phonon noise*/
complex_noise_lo[4] = rcomplex(n_29,n_30)/sqrt(2.0); /*Initial l.o. phonon noise*/
complex_noise_lo[5] = rcomplex(n_31,n_32)/sqrt(2.0); /*Initial l.o. phonon noise*/
complex_noise_lo[6] = rcomplex(n_33,n_34)/sqrt(2.0); /*Initial l.o. phonon noise*/
complex_noise_lo[7] = rcomplex(n_35,n_36)/sqrt(2.0); /*Initial l.o. phonon noise*/
complex_noise_lo[8] = rcomplex(n_37,n_38)/sqrt(2.0); /*Initial l.o. phonon noise*/
complex_noise_lo[9] = rcomplex(n_39,n_40)/sqrt(2.0); /*Initial l.o. phonon noise*/
for (int k=0; k<Nb; k++) {
/* Note: we integrate phonon fields in an interaction picture, for efficiency */
increment[k] = (1.0-step_function)*(-i*r[k]*r[k]*phi*~phi*expikt[k]);
dincrement[k] = (1.0-step_function)*(-i*r[k]*r[k]*(phi*~dphi + dphi*~phi + dphi*~dphi)*expikt[k]);
increment_lo[k] = (1.0-step_function)*(-i*r[k]*r[k]*psi*~psi*expikt[k]);
dincrement_lo[k] = (1.0-step_function)*(-i*r[k]*r[k]*(psi*~dpsi + dpsi*~psi + dpsi*~dpsi)*expikt[k]);
/* Include also dynamical normalisation */
dincrement[k] += step_function*(sqrt(2.0*g)*b_init[k]*complex_noise[k]-g*db[k]);
dincrement_lo[k] += step_function*(sqrt(2.0*g)*b_init[k]*complex_noise_lo[k]-g*db_lo[k]);
}
db0_dt = increment[0];
db1_dt = increment[1];
db2_dt = increment[2];
db3_dt = increment[3];
db4_dt = increment[4];
db5_dt = increment[5];
db6_dt = increment[6];
db7_dt = increment[7];
db8_dt = increment[8];
db9_dt = increment[9];
ddb0_dt = dincrement[0];
ddb1_dt = dincrement[1];
ddb2_dt = dincrement[2];
ddb3_dt = dincrement[3];
ddb4_dt = dincrement[4];
ddb5_dt = dincrement[5];
ddb6_dt = dincrement[6];
ddb7_dt = dincrement[7];
ddb8_dt = dincrement[8];
ddb9_dt = dincrement[9];
db_lo0_dt = increment_lo[0];
db_lo1_dt = increment_lo[1];
db_lo2_dt = increment_lo[2];
db_lo3_dt = increment_lo[3];
db_lo4_dt = increment_lo[4];
db_lo5_dt = increment_lo[5];
db_lo6_dt = increment_lo[6];
db_lo7_dt = increment_lo[7];
db_lo8_dt = increment_lo[8];
db_lo9_dt = increment_lo[9];
ddb_lo0_dt = dincrement_lo[0];
ddb_lo1_dt = dincrement_lo[1];
ddb_lo2_dt = dincrement_lo[2];
ddb_lo3_dt = dincrement_lo[3];
ddb_lo4_dt = dincrement_lo[4];
ddb_lo5_dt = dincrement_lo[5];
ddb_lo6_dt = dincrement_lo[6];
ddb_lo7_dt = dincrement_lo[7];
ddb_lo8_dt = dincrement_lo[8];
ddb_lo9_dt = dincrement_lo[9];
]]>
</cross_propagation>
</integrate>
</sequence>
/**************/
<output>
/**************/
<filename>raman_wigner_diff.xsil</filename>
<group>
<sampling>
<fourier_space> no </fourier_space>
<lattice> 32 </lattice>
<vectors>main cross</vectors>
<moments>I I_phi I_psi bm0 bm1 bd0 bd1 b_lom0 b_lom1 b_lod0 b_lod1</moments>
<![CDATA[
complex p = sqrt(alpha)*phi-sqrt(1.0-alpha)*psi; /* Assymetric Beam splitter */
I = ~p*p; /*Mean*/
I_phi = ~phi*phi;/*Mean signal intensity*/
I_psi = ~psi*psi; /*Mean lo intensity*/
bm0 = b0; /*phonon variables*/
bm1 = b1;
bd0 = db0;
bd1 = db1;
b_lom0 = b_lo0; /*l.o. phonon variables*/
b_lom1 = b_lo1;
b_lod0 = db_lo0;
b_lod1 = db_lo1;
]]>
</sampling>
</group>
<group>
<sampling>
<fourier_space> no </fourier_space>
<lattice> 0 </lattice>
<moments>N_sym,dN_sym</moments>
complex p = sqrt(alpha)*phi-sqrt(1.0-alpha)*psi; /* Beam splitter*/
complex dp = sqrt(alpha)*dphi-sqrt(1.0-alpha)*dpsi; /* Beam splitter*/
N_sym = ~p*p; /*Symmetrically ordered*/
dN_sym = ~dp*dp+2*real(~p*dp); /*Symmetrically ordered*/
</sampling>
<post_propagation>
<fourier_space> no </fourier_space>
<moments>N NN N0</moments>
double N_s = N_sym;
double dN_s = dN_sym;
double c1 = &Nt;/n; /*&Nt;Int[delta(0)/n dxi], from same-point commutator */
double c2 = 1/n; /*Int[delta(xi)/n dxi], from different-point commutator*/
N0 = N_s; /*mean number in output port*/
N= dN_s- c1/2; /*Normally ordered fluctuations*/
NN = dN_s*dN_s - c1*dN_s + (c1*c1-c2*c1)/4; /*Normally ordered fluctuations squared*/
</post_propagation>
</group>
<group>
<sampling>
<fourier_space> yes </fourier_space>
<lattice> 256 </lattice>
<vectors>main cross Phonons</vectors>
<moments>I_phik I_psik db1k db9k b1k b9k exp1 exp9</moments>
<![CDATA[
I_phik = ~phi*phi;/*Mean signal intensity*/
I_psik = ~psi*psi; /*Mean lo intensity*/
db1k = mod(db1); /*phonon variables*/
db9k = mod(db9); /*phonon variables*/
b1k = mod(b1); /*phonon variables*/
b9k = mod(b9); /*phonon variables*/
exp1 = mod(expikt1);
exp9 = mod(expikt9);
]]>
</sampling>
</group>
<group>
<sampling>
<fourier_space> yes </fourier_space>
<lattice> 0 </lattice>
<vectors>main cross</vectors>
<moments>norm_phi norm_psi omega_phi omega_psi</moments>
<![CDATA[
omega_phi = kt*~phi*phi; /*centre frequency*/
norm_phi = ~phi*phi; /*normalisation*/
omega_psi = kt*~psi*psi; /*centre frequency*/
norm_psi = ~psi*psi; /*normalisation*/
]]>
</sampling>
</group>
</output>
</simulation>
Generated by GNU enscript 1.6.3.
|