void Simulation::integrateExplicitEuler()
{
VectorX force;
computeForces(m_mesh->m_current_positions, force);
VectorX pos_next;
pos_next.resize(m_mesh->m_system_dimension);
//two explicit euler different modes:
if (m_integration_method == INTEGRATION_EXPLICIT_EULER_DISCRETE)
{
//update rule here is xn+1 = xn + m_h*(vn-1 + f(xn-1,vn-1))
pos_next = m_mesh->m_current_positions +m_h*(m_mesh->m_previous_velocities + force*m_h);
}
else if (m_integration_method == INTEGRATION_EXPLICIT_EULER_SYMPLETIC)
{
//Sympletic Euler uses the new velocity when computing for the new position
ScalarType mh_squared = m_h*m_h;
//vn+1 = vn + h*f(xn,vn)
//xn+1 = xn + vn+1*h;
//update rule here is xn+1 = xn + m_h*(vn + f(xn,vn))
pos_next = m_mesh->m_current_positions + m_mesh->m_current_velocities*m_h + force*mh_squared;
}
updatePosAndVel(pos_next);
}
void Scene::backwardEulersUpdate (double dT) {
// initialize a changeable substitute for the vector of particles
std::vector<Particle*> standIn;
for (int i = 0; i < particles.size(); i++) standIn.push_back(particles[i]);
// compute a forward euler step to find state at t + 1
forwardEulersUpdate(dT);
// compute forces at t + 1
std::vector<Vector3d> dVel = computeForces();
std::vector<Vector3d> dPos;
for (int i = 0; i < standIn.size(); i++) dPos.push_back(standIn[i]->vel);
// compute acceleration, velocity change and position change in t + 1
for (int i = 0; i < particles.size(); i++) {
dVel[i] = dT * dVel[i] / particles[i]->mass;
dPos[i] = dT * dPos[i];
}
//update scene velocity and position step based on original position plus vel & pos at t + 1
for (int i = 0; i < particles.size(); i++) {
particles[i]->vel = particles[i]->vel + dVel[i];
particles[i]->pos = particles[i]->pos + dPos[i];
}
}
void move(particle_t* Particles){
double Fold[N_SIMULATION][DIM_SIMULATION];
for(int i=0;i<N_SIMULATION;i++){
updateX(Particles+i);
}
glutPostRedisplay();
for(int i=0;i<N_SIMULATION;i++){
for(int d=0;d<DIM_SIMULATION;d++)
Fold[i][d]=Particles[i].force[d];
}
computeForces(Particles);
for(int i=0;i<N_SIMULATION;i++){
updateV(Particles+i,Fold[i]);
// check if we are at the walls and redirect the speed!
}
}
void SolverThread::stepPhysics(float dt)
{
computeForces();
clearStiffnessAssembly();
if(bUseStiffnessWarping)
updateOrientation();
else
resetOrientation();
stiffnessAssembly();
// addPlasticityForce(dt);
dynamicsAssembly(dt);
#if SOLVEONGPU
solveGpu(m_V, m_stiffnessMatrix);
#else
solve(m_V);
#endif
updatePosition(dt);
#if ENABLE_DBG
dbglg.write("Re");
unsigned totalTetrahedra = m_mesh->numTetrahedra();
FEMTetrahedronMesh::Tetrahedron * tetrahedra = m_mesh->tetrahedra();
for(unsigned k=0;k<totalTetrahedra;k++) {
dbglg.write(k);
dbglg.write(tetrahedra[k].Re.str());
}
dbglg.writeMat33(m_stiffnessMatrix->valueBuf(),
m_stiffnessMatrix->numNonZero(),
"K ");
dbglg.write("Rhs");
unsigned totalPoints = m_mesh->numPoints();
for(unsigned k=0;k<totalPoints;k++) {
dbglg.write(k);
dbglg.write(rightHandSide()[k].str());
dbglg.newLine();
}
dbglg.write("F0");
for(unsigned k=0;k<totalPoints;k++) {
dbglg.write(k);
dbglg.write(m_F0[k].str());
dbglg.newLine();
}
#endif
}
void Simulation::integrateClassicExplicitEuler()
{
VectorX force;
computeForces(m_mesh->m_current_positions, force);
//vn+1 = vn + h*f(xn,vn)
//xn+1 = xn + vn*h;
m_mesh->m_previous_velocities = m_mesh->m_current_velocities;
m_mesh->m_current_velocities = m_mesh->m_current_velocities + m_h*force;
m_mesh->m_current_positions = m_mesh->m_current_positions + m_h* m_mesh->m_previous_velocities;
//restaura posição
}
void ParticleSimulation::particleDerivate(float* temp)
{
clearForces();
computeForces();
for (int i = 0; i < ps.length; i++)
{
*(temp++) = ps.particles[i].velo[0];
*(temp++) = ps.particles[i].velo[1];
*(temp++) = ps.particles[i].velo[2];
*(temp++) = ps.particles[i].force_acc[0] / ps.particles[i].mass;
*(temp++) = ps.particles[i].force_acc[1] / ps.particles[i].mass;
*(temp++) = ps.particles[i].force_acc[2] / ps.particles[i].mass;
}
}
void Scene::midPointUpdate (double dT) {
std::vector<Particle*> copy;
for (int i = 0; i < particles.size(); i++) copy.push_back(new Particle(*particles[i]));
// compute a
std::vector<Vector3d> a1;
for (int i = 0; i < particles.size(); i++) a1.push_back(particles[i]->vel);
std::vector<Vector3d> a2 = computeForces();
for (int i = 0; i < particles.size(); i++) {
a1[i] = a1[i]*dT;
a2[i] = a2[i]*dT/particles[i]->mass;
}
// alter copy
for (int i = 0; i < particles.size(); i++) {
copy[i]->pos = copy[i]->pos + (0.5*a1[i]);
copy[i]->vel = copy[i]->vel + (0.5*a2[i]);
}
// compute b
std::vector<Vector3d> b1;
for (int i = 0; i < particles.size(); i++) b1.push_back(copy[i]->vel);
std::vector<Vector3d> b2 = computeForces();
for (int i = 0; i < particles.size(); i++) {
b1[i] = b1[i]*dT;
b2[i] = b2[i]*dT/particles[i]->mass;
particles[i]->pos += b1[i];
particles[i]->vel += b2[i];
delete copy[i];
}
}
void Scene::forwardEulersUpdate (double dT) {
// Initialize Vectors
std::vector<Vector3d> forces = computeForces();
for (int i = 0; i < particles.size(); i++) {
// Position Update
particles[i]->pos = particles[i]->pos + dT * particles[i]->vel;
// Velocity Update
Vector3d accel = forces[i] / particles[i]->mass;
particles[i]->vel = particles[i]->vel + dT * accel;
}
}
bool ElasticBand::update(InnerModel *innermodel, WayPoints &road, const RoboCompLaser::TLaserData &laserData,
const CurrentTarget ¤tTarget, uint iter)
{
//qDebug() << __FILE__ << __FUNCTION__ << "road size"<< road.size();
if (road.isFinished() == true)
return false;
/////////////////////////////////////////////
//Tags all points in the road ar visible or blocked, depending on laser visibility. Only visible points are processed in this iteration
/////////////////////////////////////////////
//checkVisiblePoints(innermodel, road, laserData);
/////////////////////////////////////////////
//Check if there is a sudden shortcut to take
/////////////////////////////////////////////
//shortCut(innermodel, road, laserData);
/////////////////////////////////////////////
//Add points to achieve an homogenoeus chain
/////////////////////////////////////////////
addPoints(road, currentTarget);
/////////////////////////////////////////////
//Remove point too close to each other
/////////////////////////////////////////////
cleanPoints(road);
/////////////////////////////////////////////
//Compute the scalar magnitudes
/////////////////////////////////////////////
computeForces(innermodel, road, laserData);
/////////////////////////////////////////////
//Delete half the tail behind, if greater than 6, to release resources
/////////////////////////////////////////////
if (road.getIndexOfClosestPointToRobot() > 6)
{
for (auto it = road.begin(); it != road.begin() + (road.getIndexOfCurrentPoint() / 2); ++it)
road.backList.append(it->pos);
road.erase(road.begin(), road.begin() + (road.getIndexOfCurrentPoint() / 2));
}
return true;
}
void Simulation::integrateExplicitEuler()
{
// q_{n+1} - 2q_n + q_{n-1} = h^2 * M^{-1} * force(q_{n-1})
// inertia term 2q_n - q_{n-1} is calculated in calculateInertiaY function
// calculate force(q_{n-1})
// VectorX position_previous = m_mesh->m_current_positions - m_mesh->m_current_velocities*m_h;
VectorX position_previous = m_mesh->m_current_positions - m_mesh->m_current_velocities*m_h;
VectorX force_previous;
computeForces(position_previous, force_previous);
//cout<<force_previous<<endl;
// update q_{n+1}
ScalarType h_square = m_h*m_h;
VectorX pos_next = m_inertia_y + h_square*m_mesh->m_inv_mass_matrix*force_previous;
//cout<<"pos_next"<<pos_next.block_vector(0)<<endl;
//cout<<"m_current"<<m_mesh->m_current_positions.block_vector(0)<<endl;
updatePosAndVel(pos_next);
}
int main(int argc, char **argv) {
const int NUM_OF_BODIES_DEFAULT = 1000;
const int NUM_OF_TIME_STEPS_DEFAULT = 10;
const int num_of_bodies = (argc > 1) ? atoi(argv[1]) : NUM_OF_BODIES_DEFAULT;
const int num_of_time_steps = (argc > 2) ? atoi(argv[2]) : NUM_OF_TIME_STEPS_DEFAULT;
const double delta_t = 0.01;
const double theta = 1.0;
printf("Bodies: %d, time steps: %d\n", num_of_bodies, num_of_time_steps);
Body *bodies = new Body[num_of_bodies];
clock_t c_beg = clock();
Domain2D domain(-10.0, 10.0, -10.0, 10.0);
initBodies(bodies, num_of_bodies, domain);
for (int t = 0; t < num_of_time_steps; t++) {
QuadTree tree(bodies, num_of_bodies, domain);
computeForces(bodies, num_of_bodies, tree, theta);
updateBodies(bodies, num_of_bodies, delta_t);
//printf("%d %d\n", tree.getHeight(), tree.getSize());
}
clock_t c_end = clock();
printf("Time to compute: %.5f seconds\n", float(c_end - c_beg)/CLOCKS_PER_SEC);
delete[] bodies;
return 0;
}
void Scene::rK4Update (double dT) {
// initialize a changeable substitute for the vector of particles
std::vector<Particle*> standIn;
for (int i = 0; i < particles.size(); i++) standIn.push_back(new Particle(*particles[i]));
// initialize acceleration, velocity vectors for A
std::vector<Vector3d> a1;
for (int i = 0; i < particles.size(); i++) a1.push_back(standIn[i]->vel);
std::vector<Vector3d> a2 = computeForces();
// find A and update standIn
for (int i = 0; i < standIn.size(); i++) {
a1[i] = a1[i] * dT;
a2[i] = dT * a2[i] / standIn[i]->mass;
// find RK4 positions and velocities for B
standIn[i]->pos = .5 * a1[i] + particles[i]->pos;
standIn[i]->vel = .5 * a2[i] + particles[i]->vel;
}
// initialize acceleration, velocity, and position vectors for B
std::vector<Vector3d> b1;
for (int i = 0; i < particles.size(); i++) b1.push_back(standIn[i]->vel);
std::vector<Vector3d> b2 = computeForces();
// find B and update standIn
for (int i = 0; i < standIn.size(); i++) {
b1[i] = b1[i] * dT;
b2[i] = dT * b2[i] / standIn[i]->mass;
// find RK4 positions and velocities for C
standIn[i]->pos = .5 * b1[i] + particles[i]->pos;
standIn[i]->vel = .5 * b2[i] + particles[i]->vel;
}
// initialize acceleration, velocity, vectors for C
std::vector<Vector3d> c1;
for (int i = 0; i < particles.size(); i++) c1.push_back(standIn[i]->vel);
std::vector<Vector3d> c2 = computeForces();
// find C and update standIn
for (int i = 0; i < standIn.size(); i++) {
c1[i] = c1[i] * dT;
c2[i] = dT * c2[i] / standIn[i]->mass;
// find RK4 positions and velocities for D
standIn[i]->pos = c1[i] + particles[i]->pos;
standIn[i]->vel = c2[i] + particles[i]->vel;
}
// initialize acceleration, velocity, and position vectors for D
std::vector<Vector3d> d1;
for (int i = 0; i < particles.size(); i++) d1.push_back(standIn[i]->vel);
std::vector<Vector3d> d2 = computeForces();
// find D
for (int i = 0; i < standIn.size(); i++) {
d1[i] = d1[i] * dT;
d2[i] = dT * d2[i] / standIn[i]->mass;
}
// update poitions and velocities in particle based on Runge-Kutta 4 formula
for (int i = 0; i < particles.size(); i++) {
particles[i]->pos = particles[i]->pos + (1/6) * (2 * (b1[i] + c1[i]) +
a1[i] + d1[i]);
particles[i]->vel = particles[i]->vel + (1/6) * (2 * (b2[i] + c2[i]) +
a2[i] + d2[i]);
delete standIn[i];
}
}
void initData(particle_t* Particles, int DIM, int N){
DIM_SIMULATION = DIM;
N_SIMULATION = N;
srand48(time(NULL));
// initialize 'DARK MATTER PARTICLE' - black hole!!!
Particles[0].p =(double*)malloc(DIM_SIMULATION*sizeof(double));
Particles[0].v =(double*)malloc(DIM_SIMULATION*sizeof(double));
Particles[0].force =(double*)malloc(DIM_SIMULATION*sizeof(double));
for(int d=0;d<DIM_SIMULATION;d++){
Particles[0].p[d] = 0;//(drand48()-0.5)*size;
Particles[0].v[d] = 0;
Particles[0].force[d] = 0;
}
Particles[0].radius = radius_all/10 ; // (drand48()+0.5)/10; // radius between 0.05 and 0.15
Particles[0].r = 1;
Particles[0].g = 1;
Particles[0].b = 1;
Particles[0].m = 1; // make the mass proportional to the volume
double rand;
for(int i=1;i<N_SIMULATION;i++){
// allocate storage for the position velocity and force vectors, respectively.
Particles[i].p =(double*)malloc(DIM_SIMULATION*sizeof(double));
Particles[i].v =(double*)malloc(DIM_SIMULATION*sizeof(double));
Particles[i].force =(double*)malloc(DIM_SIMULATION*sizeof(double));
for(int d=0;d<DIM_SIMULATION;d++){
rand = (drand48()-0.5)*size;
Particles[i].p[d] = rand >= 0 ? rand+1 : rand-1;
Particles[i].v[d] =(drand48()-0.5);
Particles[i].force[d] = 0;
}
Particles[i].radius = radius_all ; // (drand48()+0.5)/10; // radius between 0.05 and 0.15
Particles[i].r =drand48();
Particles[i].g = drand48();
Particles[i].b = drand48();
Particles[i].m = 3e-6; // make the mass proportional to the volume
}
computeForces(Particles);
//DIM_SIMULATION = DIM;
//N_SIMULATION = N;
///*SUN*/
//Particles[0].p = new double[DIM_SIMULATION];// (double*) malloc(DIM*sizeof(double));
//Particles[0].v = new double[DIM_SIMULATION];//(double*) malloc(DIM*sizeof(double));
//Particles[0].force = new double[DIM_SIMULATION];//(double*) malloc(DIM*sizeof(double));
//Particles[0].p[0] = 0.;
//Particles[0].p[1] = 0.;
//Particles[0].p[2] = 0.;
//Particles[0].v[0] = 0.;
//Particles[0].v[1] = 0.;
//Particles[0].v[2] = 0.;
//Particles[0].m = 1;
//Particles[0].r = 0.5f;
//Particles[0].g = .0f;
//Particles[0].b = 0.0f;
//Particles[0].radius = (float)radius_all;
///*EARTH*/
//Particles[1].p = new double[DIM_SIMULATION];//(double*) malloc(DIM*sizeof(double));
//Particles[1].v = new double[DIM_SIMULATION];//(double*) malloc(DIM*sizeof(double));
//Particles[1].force = new double[DIM_SIMULATION];//(double*) malloc(DIM*sizeof(double));
//Particles[1].p[0] = 0.;
//Particles[1].p[1] = 1.;
//Particles[1].p[2] = 0.;
//Particles[1].v[0] = -1.;
//Particles[1].v[1] = 0.;
//Particles[1].v[2] = 0.;
//Particles[1].m = 3.0e-6;
//Particles[1].r = 0.0f;
//Particles[1].g = 0.0f;
//Particles[1].b = 1.0f;
//Particles[1].radius = (float)radius_all/3;
///*JUPITER*/
//Particles[2].p = new double[DIM_SIMULATION];//(double*) malloc(DIM*sizeof(double));
//Particles[2].v = new double[DIM_SIMULATION];//(double*) malloc(DIM*sizeof(double));
//Particles[2].force = new double[DIM_SIMULATION];//(double*) malloc(DIM*sizeof(double));
//Particles[2].p[0] = 0.;
//Particles[2].p[1] = 5.36;
//Particles[2].p[2] = 0.;
//Particles[2].v[0] = -0.425;
//Particles[2].v[1] = 0.;
//Particles[2].v[2] = 0.;
//Particles[2].m = 9.55e-4;
//Particles[2].r = 0.4f;
//Particles[2].g = .0f;
//Particles[2].b = 1.0f;
//Particles[2].radius = (float)radius_all/2;
///*Halley Commet*/
//Particles[3].p = new double[DIM_SIMULATION];//(double*) malloc(DIM*sizeof(double));
//Particles[3].v = new double[DIM_SIMULATION];//(double*) malloc(DIM*sizeof(double));
//Particles[3].force = new double[DIM_SIMULATION];//(double*) malloc(DIM*sizeof(double));
//Particles[3].p[0] = 34.75;
//Particles[3].p[1] = 0.;
//Particles[3].p[2] = 0.;
//Particles[3].v[0] = 0.;
//Particles[3].v[1] = 0.0296;
//Particles[3].v[2] = 0.;
//Particles[3].m = 1.e-14;
//Particles[3].r = 1.0f;
//Particles[3].g = 0.0f;
//Particles[3].b = 0.0f;
//Particles[3].radius = (float)radius_all/2;
//computeForces(Particles);
}
int main(int argc, char* argv[]){
// domain variables
int iter = 0;
int i;
int file_index;
int max_iter;
double max_time = 1.0;
double dt = .0000001;
double domain_box[4] = {0.0, 0.0, 1.0, 2.0};
double domain_m_box[4] = {.10, 0.2, 0.90, 2.00};
int domain_num_cells[2] = {10, 20};
int pp_cell[2] = {2,2};
double ipart_dim[2];
int domain_num_particles[2];
double test_px, test_py;
char p_filename[40];
char p_filename2[40];
char g_filename[40];
//timing variables
double start_time;
double end_time;
// patch variables
int rank = 0;
int size;
int num_proc[2];
double box[4];
double m_box[4];
int num_cells[2];
int halo_cells[4] = {1,1,1,1};
int num_particles[2];
int sfactor = 2;
GridData grid_data;
Node** grid;
InitialParticleData ipart_data;
Particle* particles;
Particle* post_particles;
Particle* particle_list;
Particle* rhalo_parts[8];
Particle* shalo_parts[8];
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Request halo_req[8][2];
MPI_Status halo_stat[8][2];
max_iter = (int)(max_time/dt);
if(rank == 0){
if(argc == 3){
num_proc[0] = atoi(argv[1]);
num_proc[1] = atoi(argv[2]);
}else if(argc == 6){
num_proc[0] = atoi(argv[1]);
num_proc[1] = atoi(argv[2]);
domain_num_cells[0] = atoi(argv[3]);
domain_num_cells[1] = atoi(argv[4]);
max_iter = atoi(argv[5]);
}
}
MPI_Bcast(num_proc, 2, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(domain_num_cells, 2, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&max_iter, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
grid_data.gravity[0] = 0;
grid_data.gravity[1] = -900.8;
grid_data.cell_dim[0] = (domain_box[2] - domain_box[0])/domain_num_cells[0];
grid_data.cell_dim[1] = (domain_box[3] - domain_box[1])/domain_num_cells[1];
test_px = grid_data.cell_dim[0]/pp_cell[0];
test_py = grid_data.cell_dim[1]/pp_cell[1];
domain_num_particles[0] = (int)((domain_m_box[2] - domain_m_box[0])/test_px);
domain_num_particles[1] = (int)((domain_m_box[3] - domain_m_box[1])/test_py);
ipart_dim[0] = (domain_m_box[2] - domain_m_box[0])/domain_num_particles[0];
ipart_dim[1] = (domain_m_box[3] - domain_m_box[1])/domain_num_particles[1];
decomposeGrid(rank, num_proc, domain_num_cells, num_cells, domain_box, box, halo_cells, &grid_data);
decomposeMaterial(box, domain_m_box, m_box, ipart_dim, num_particles);
ipart_data.density = 1000;
ipart_data.bulk = 3;
ipart_data.shear = 4;
ipart_data.E = 90000;
ipart_data.poisson = .30;
ipart_data.idim[0] = ipart_dim[0];
ipart_data.idim[1] = ipart_dim[1];
ipart_data.velocity[0] = 0;
ipart_data.velocity[1] = 0;
ipart_data.box[0] = m_box[0];
ipart_data.box[1] = m_box[1];
ipart_data.box[2] = m_box[2];
ipart_data.box[3] = m_box[3];
ipart_data.num_particles[0] = num_particles[0];
ipart_data.num_particles[1] = num_particles[1];
ipart_data.domain_num_particles[0] = domain_num_particles[0];
ipart_data.domain_num_particles[1] = domain_num_particles[1];
grid = createGrid(&grid_data, box, num_cells);
particles = createMaterial(&grid_data, &ipart_data);
post_particles = createMaterial(&grid_data, &ipart_data);
initializeGrid(&grid_data, grid);
initializeMaterial(&grid_data, &ipart_data, particles);
//allocate halo particles
allocateHaloParticles(&grid_data, sfactor, pp_cell, rhalo_parts, shalo_parts);
file_index = 0;
start_time = MPI_Wtime();
for(iter = 0; iter <= max_iter; iter++){
gatherHaloParticles(&grid_data, particles, rhalo_parts, shalo_parts);
sendRecvParticles(&grid_data, rhalo_parts, shalo_parts);
clearGridValues(&grid_data, grid);
mapToGrid(&grid_data, grid, particles);
for(i = 0; i < 8; i++){
if(grid_data.rank[i] >= 0 && rhalo_parts[i][0].particle_count > 0){
mapToGrid(&grid_data, grid, rhalo_parts[i]);
}
}
momentumToVelocityOnGrid(&grid_data, grid);
computeForces(&grid_data, grid, particles);
for(i = 0; i < 8; i++){
if(grid_data.rank[i] >= 0 && rhalo_parts[i][0].particle_count > 0){
computeForces(&grid_data, grid, rhalo_parts[i]);
}
}
computeAcceleration(&grid_data, grid);
/**
particle_list = gatherParticles(rank, size, domain_num_particles[0] * domain_num_particles[1],
particles, post_particles);
if(rank == 0){
//if(iter%100 == 0){
sprintf(p_filename, "ppart%06d.vtk", file_index);
//sprintf(p_filename2, "center%06d.vtk", file_index);
//sprintf(g_filename, "grid_output%06d.vtk", file_index);
//writeParticlesVtkFile(&grid_data, grid, rhalo_parts[0], p_filename);
writeParticlesVtkFile(&grid_data, grid, particle_list, p_filename);
//writeParticlesVtkFile(&grid_data, grid, particle_list, p_filename);
//writeParticlesVtkFile(&grid_data, grid, particles, p_filename);
//writeGridVtkFile(&grid_data, grid, g_filename);
//writeGridVtkFile(&grid_data, grid, g_filename);
//free(particle_list);
file_index++;
//}
}
**/
updateNodalValues(&grid_data, grid, dt);
updateStressAndStrain(&grid_data, grid, particles, dt);
pUpdateParticlePosition(&grid_data, grid, particles, post_particles, shalo_parts, dt);
sendRecvParticles(&grid_data, rhalo_parts, shalo_parts);
updateParticleList(&grid_data, particles, rhalo_parts);
/**
particle_list = gatherParticles(rank, size, domain_num_particles[0] * domain_num_particles[1],
particles, post_particles);
if(rank == 0){
sprintf(p_filename, "particle_output%06d.vtk", file_index);
file_index++;
//sprintf(g_filename, "grid_output%06d.vtk", file_index);
writeParticlesVtkFile(&grid_data, grid, particles, p_filename);
//writeParticlesVtkFile(&grid_data, grid, particle_list, p_filename);
//writeParticlesVtkFile(&grid_data, grid, particles, p_filename);
//writeGridVtkFile(&grid_data, grid, g_filename);
free(particle_list);
}
**/
MPI_Barrier(MPI_COMM_WORLD);
}
end_time = MPI_Wtime();
MPI_Barrier(MPI_COMM_WORLD);
//particle_list = gatherParticles(rank, size, domain_num_particles[0] * domain_num_particles[1],
// particles, post_particles);
if(rank == 0){
printf("Parallel, np: %d, iterations: %d, time: %f\n", size, max_iter, end_time-start_time);
//writeParticlesVtkFile(&grid_data, grid, particle_list, "pparts.vtk");
//free(particle_list);
}
freeGrid(grid, &grid_data);
freeMaterial(particles);
freeMaterial(post_particles);
freeHaloParticles(&grid_data, rhalo_parts, shalo_parts);
//MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
return 0;
}
void OpenCloth::step( float deltaTime ) {
computeForces(deltaTime);
integrateVerlet(deltaTime);
provotDynamicInverse();
}
