Ejemplo n.º 1
0
  const py_vector particle_momentum(ParticleState const &ps)
  {
    const unsigned vdim = ps.vdim();
    py_vector result(vdim);
    result.clear();

    for (particle_number pn = 0; pn < ps.particle_count; pn++)
      result += subrange(ps.momenta, vdim*pn, vdim*(pn+1));

    return result;
  }
Ejemplo n.º 2
0
  const py_vector particle_current(ParticleState const &ps, py_vector const &velocities,
      double length)
  {
    const unsigned vdim = ps.vdim();
    py_vector result(vdim);
    result.clear();

    for (particle_number pn = 0; pn < ps.particle_count; pn++)
      result += ps.charges[pn] * subrange(velocities, vdim*pn, vdim*(pn+1));

    return result / length;
  }
Ejemplo n.º 3
0
  const double rms_beam_emittance(ParticleState const &ps, unsigned axis, unsigned beam_axis)
  {
    if (ps.particle_count == 0)
      return 0;

    double mean_x = 0;
    double mean_xp = 0;
    double mean_x_squared = 0;
    double mean_xp_squared = 0;
    double mean_xxp = 0;

    // see doc/notes.tm
    for (particle_number pn = 0; pn < ps.particle_count; pn++)
    {
      const double x = ps.positions[pn*ps.xdim() + axis];

      mean_x += x;
      mean_x_squared += square(x);

      const double px = ps.momenta[pn*ps.vdim() + axis];
      const double pz = ps.momenta[pn*ps.vdim() + beam_axis];

      const double xprime = pz ? px/pz : 0;

      mean_xp += xprime;
      mean_xp_squared += square(xprime);

      mean_xxp += x*xprime;
    }

    mean_x /= ps.particle_count;
    mean_xp /= ps.particle_count;

    mean_x_squared /= ps.particle_count;
    mean_xp_squared /= ps.particle_count;

    mean_xxp /= ps.particle_count;

    return sqrt(
        mean_x_squared*mean_xp_squared
        - square(mean_x)*mean_xp_squared
        - mean_x_squared*square(mean_xp)
        - (
          square(mean_xxp)
          -2*mean_xxp*mean_x*mean_xp
          )
        );
  }
Ejemplo n.º 4
0
  const py_vector kinetic_energies(ParticleState const &ps, double vacuum_c)
  {
    const unsigned vdim = ps.vdim();

    py_vector result(ps.particle_count);

    const double c_squared = vacuum_c*vacuum_c;

    for (particle_number pn = 0; pn < ps.particle_count; pn++)
    {
      const unsigned vpstart = vdim*pn;
      const unsigned vpend = vdim*(pn+1);

      const double m = ps.masses[pn];
      double p = norm_2(subrange(ps.momenta, vpstart, vpend));
      double v = vacuum_c*p/sqrt(m*m*c_squared + p*p);
      result[pn] = (p/v-m)*c_squared;
    }
    return result;
  }