MPI_Scatterv рассеивает только часть пользовательского MPI_Datatype

Этот вопрос может быть связан с этим.

У меня есть следующая структура:

struct Particle {

double x;
double y;
double vx;
double vy;
double ax;
double ay;
int i;
int j;

Particle():
    x(-1.0),
    y(-1.0),
    vx(0.0),
    vy(0.0),
    ax(0.0),
    ay(0.0),
    i(-1),
    j(-1) { };

Particle& operator=(const Particle& right) {

    if(&right == this)
        throw std::domain_error("Particle self-assignment!");

    x = right.x;
    y = right.y;
    vx = right.vx;
    vy = right.vy;
    ax = right.ax;
    ay = right.ay;
    i = right.i;
    j = right.j;

    return *this;
} 
};

И я создаю MPI_Datatype для каждого процессора следующим образом:

//
// Build MPI_Datatype PARTICLE
//
MPI_Datatype PARTICLE;
Particle p;                 // needed for displacement computation
int block_len[8];           // the number of elements in each "block" will be 1 for us
MPI_Aint displacements[8];  // displacement of each element from start of new type
MPI_Datatype typelist[8];   // MPI types of the elements
MPI_Aint start_address;     // used in calculating the displacements
MPI_Aint address;

//
// Set up
//
for(int i = 0; i < 8; ++i) {
    block_len[i] = 1;
}

typelist[0] = MPI_FLOAT;
typelist[1] = MPI_FLOAT;
typelist[2] = MPI_FLOAT;
typelist[3] = MPI_FLOAT;
typelist[4] = MPI_FLOAT;
typelist[5] = MPI_FLOAT;
typelist[6] = MPI_INT;
typelist[7] = MPI_INT;

MPI_Address(&p.x, &start_address);          // getting starting address
displacements[0] = 0;                       // first element is at displacement 0

MPI_Address(&p.y, &address);
displacements[1] = address - start_address;

MPI_Address(&p.vx, &address);
displacements[2] = address - start_address;

MPI_Address(&p.vy, &address);
displacements[3] = address - start_address;

MPI_Address(&p.ax, &address);
displacements[4] = address - start_address;

MPI_Address(&p.ay, &address);
displacements[5] = address - start_address;

MPI_Address(&p.i, &address);
displacements[6] = address - start_address;

MPI_Address(&p.j, &address);
displacements[7] = address - start_address;

//
// Building new MPI type
//
MPI_Type_struct(8, block_len, displacements, typelist, &PARTICLE);
MPI_Type_commit(&PARTICLE);

И тогда хотелось бы разбросать его вот так:

MPI_Scatterv(particles.data(), partition_sizes.data(), partition_offsets.data(), PARTICLE, local_particles.data(), n_local, PARTICLE, 0, MPI_COMM_WORLD );

Аргументы MPI_Scatterv следующие:

int n_local                                    // number of particles on each processor
std::vector<Particle> particles;               // particles will be available on all processors but it will only be filled with particles on processor 0 and then scattered to all other processors.
std::vector<int> partition_sizes(n_proc);
std::vector<int> partition_offsets(n_proc);
std::vector<Particle> local_particles(n);

Интересно, что внутренние части (i, j) структуры Particle получают разбросанные правильно, поэтому у меня есть правильные значения i, j для всех локальных_частиц [k]. Однако все двойные значения (x, y, vx, vy, ax, ay) принимают значения конструктора по умолчанию.

Кто-нибудь еще испытал это? Есть идеи? Может ли кто-нибудь указать мне на подробную документацию Scatterv, где они разбросают пользовательские MPI_Datatypes?

Большое спасибо!