<?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>
