int
main(int argc, char *argv[])
{
float timeStep = 0.1f;
uint32_t nIntegrations = 1000;
uint32_t num_particles_x = 16;
uint32_t num_particles_y = 16;
uint32_t num_particles = num_particles_x * num_particles_y;
uint32_t num_levels = logf(num_particles) / logf(4.f);
uint32_t num_coefficients = 4;
uint32_t memory_size = 256 * 1024 * 1024;
initialize_data(memory_size, num_particles_x, num_particles_y,
num_levels, num_coefficients);
for(uint32_t loop = 0; loop < nIntegrations; loop++) {
calculate_multipoles();
reset_forces();
calculate_forces();
integrate(timeStep);
}
const char filename[] = "out.txt";
debug_write_positions_to_file(filename);
return 0;
}
void QUAN_MACRO_CAT(DATA_STRUCT,function)(){
DATA_STRUCT::particle* myParticles= 0;
try{
myParticles = new DATA_STRUCT::particle[DATA_STRUCT::num_particles];
for( DATA_STRUCT::itime simulation_time
= DATA_STRUCT::itime(0);
simulation_time < DATA_STRUCT::max_time;
simulation_time += DATA_STRUCT::timeStep){
for(int i=0; i < DATA_STRUCT::num_particles; ++i){
for(int j = i+1; j < DATA_STRUCT::num_particles; ++j){
quan::three_d::vect<DATA_STRUCT::force> f
= calculate_forces(myParticles[i], myParticles[j]);
myParticles[i].apply_force(f);
myParticles[j].apply_force(-f);
}
quan::three_d::vect<DATA_STRUCT::force> f_g
= DATA_STRUCT::single_particle_forces(myParticles[i]);
myParticles[i].apply_force(f_g);
}
for (int i = 0; i < DATA_STRUCT::num_particles; ++i){
myParticles[i].update();
// std::cout << i << " " << myParticles[i] << '\n';
}
}
delete [] myParticles;
}
catch (...){
if (myParticles) delete [] myParticles;
std::cout << "exception" <<'\n';
}
}
void init_physics(simulation_t* sim)
{
int i;
calculate_forces(sim);
for(i=0;i<sim->num_celestial_bodies;i++)sim->celestial_bodies[i].base.acceleration=vector_multiply(1/sim->celestial_bodies[i].base.mass,sim->celestial_bodies[i].base.force);
for(i=0;i<sim->num_spacecraft;i++)sim->spacecraft[i].base.acceleration=vector_multiply(1/sim->spacecraft[i].base.mass,sim->spacecraft[i].base.force);
}
void run_physics(simulation_t* sim)
{
int i,j;
double delta_t;
int iterations=1;
double max_delta_t=sim->current_spacecraft->firing?MAX_THRUSTING_DELTA_T:MAX_DELTA_T;
delta_t=DELTA_T*sim->speedup;
if(delta_t>max_delta_t)
{
delta_t=max_delta_t;
iterations=sim->speedup*(DELTA_T/max_delta_t);
}
while(iterations--)
{
//This bit might be removed
for(i=0;i<sim->num_celestial_bodies;i++)object_step_position((object_t*)(sim->celestial_bodies+i),delta_t);
calculate_forces(sim);
for(i=0;i<sim->num_celestial_bodies;i++)object_step_velocity((object_t*)(sim->celestial_bodies+i),delta_t);
for(i=0;i<sim->num_spacecraft;i++)
{
spacecraft_t* spacecraft=sim->spacecraft+i;
spacecraft_run_physics(sim,spacecraft,delta_t);
}
}
}
void fluid::step( double dt )
{
prepare_step();
/*STEP 1: calculate densities*/
calculate_densities();
glass_common_update(&fluid::calculate_glass_fluid_densities);
/*if(simulator::detailed_logging)
{
printf("densities: ");
for(int i=0;i<n;i++)
{
printf("%lf ", particles[i].density);
if(particles[i].density!=density) system("pause");
}
printf("\n");
}*/
/*STEP 2: calculate forces*/
calculate_forces();
glass_common_update(&fluid::calculate_glass_fluid_forces);
/*STEP 3: move particles*/
update_positions(dt);
set_bounding_particle_indices();
}
int main(int argc, char *argv[])
{
int npts = 1500;
int nsteps = 500;
int outevery = 1;
int simulation = SIM_RANDOM;
int status;
int output = 1;
double dt = 0.01;
double time = 0.;
double tote = 0.;
status = get_options(argc, argv, &npts, &nsteps, &output, &outevery, &simulation, &dt);
if (status) return 0;
pca_time tt,t;
NBody *mydata;
tick(&t);
mydata=allocate_nbody(npts);
printf("mydata has %d particles in a %d-dimensional space.\n",npts,NDIM);
initialize_particles(mydata, npts, simulation);
tick(&tt);
calculate_forces(mydata, npts);
calculate_energy(mydata, npts, &tote);
tock(&tt);
for (int i=0;i<nsteps;i++)
{
nbody_step(mydata,npts,dt);
calculate_energy(mydata, npts, &tote);
time += dt;
if (output) {
printf("%i\t%g\t%g\t%g\n", i, dt, time, tote);
// if (!(i % outevery)) display_particles(mydata,1.3,npts);
}
}
FILE *outfile=fopen("myparticles.txt","w");
fprintf(outfile,"positions and forces are:\n");
for (int i=0;i<npts;i++)
{
for (int j=0;j<NDIM;j++)
fprintf(outfile,"%12.6f ",mydata[i].x[j]);
fprintf(outfile," ");
for (int j=0;j<NDIM;j++)
fprintf(outfile,"%12.6f ",mydata[i].f[j]);
fprintf(outfile,"\n");
}
tock(&t);
return 0;
}
void fluid::calculate_forces()
{
size_t pairs_cache_size=pairs_cache.size();
//#pragma omp parallel for schedule(dynamic)
for(int i=0;i<pairs_cache_size;i++)
{
calculate_forces(pairs_cache[i]);
}
}
int main(int argc,char **argv) {
hupcpp::init(&argc, &argv);
#if 0
if(argc!=5) {
printf("(ERROR) USAGE: ./a.out <total bodies> <tileSize> <in data file> <out data file>\n");
hupcpp::finalize();
}
assert(atoi(argv[1]) == NUMBODIES);
assert(atoi(argv[2]) == TILESIZE);
//Init(argv[3]);
#endif
long start = get_usecs();
for(int time_steps=0;time_steps<MAX_STEPS;time_steps++) {
hupcpp::finish_spmd([=]() {
if(upcxx::global_myrank() ==0) {
calculate_forces();
}
});
}
long end = get_usecs();
double dur = ((double)(end-start))/1000000;
#ifdef VERIFY_SHORT
counter_t sum = 0;
for(int i=0; i<MAX_HCPP_WORKERS; i++) {
sum+=TOTAL_COUNTS[i];
}
counter_t total_sum;
upcxx::reduce<counter_t>(&sum, &total_sum, 1, 0, UPCXX_SUM, UPCXX_ULONG_LONG);
if(upcxx::global_myrank() == 0) {
const counter_t expected = NUMBODIES * MAX_STEPS;
const char* res = expected == total_sum ? "PASSED" : "FAILED";
printf("Test %s, Time = %0.3f\n",res,dur);
}
#endif
#if 0
// gather result from all other processes using upcxx_reduce
float accx_all[NUMBODIES], accy_all[NUMBODIES], accz_all[NUMBODIES];
upcxx::upcxx_reduce<float>(accx, accx_all, NUMBODIES, 0, UPCXX_SUM, UPCXX_FLOAT);
upcxx::upcxx_reduce<float>(accy, accy_all, NUMBODIES, 0, UPCXX_SUM, UPCXX_FLOAT);
upcxx::upcxx_reduce<float>(accz, accz_all, NUMBODIES, 0, UPCXX_SUM, UPCXX_FLOAT);
if(upcxx::global_myrank() ==0) {
printf("0: Computation done\n");
printf("Test Passed=%d\n",verify_result(argv[4],accx_all));
}
#endif
hupcpp::barrier();
hupcpp::finalize();
return 0;
}
inline void FMMMLayout :: call_POSTPROCESSING_step(Graph& G,NodeArray<NodeAttributes>& A,
EdgeArray<EdgeAttributes>& E,NodeArray
<DPoint>& F,NodeArray<DPoint>& F_attr,
NodeArray<DPoint>& F_rep,NodeArray<DPoint>
& last_node_movement)
{
int i;
for(i = 1; i<= 10; i++)
calculate_forces(G,A,E,F,F_attr,F_rep,last_node_movement,i,1);
if((resizeDrawing() == true))
{
adapt_drawing_to_ideal_average_edgelength(G,A,E);
update_boxlength_and_cornercoordinate(G,A);
}
for(i = 1; i<= fineTuningIterations(); i++)
calculate_forces(G,A,E,F,F_attr,F_rep,last_node_movement,i,2);
if((resizeDrawing() == true))
adapt_drawing_to_ideal_average_edgelength(G,A,E);
}
/* kick-drift-kick */
void nbody_step(NBody *data, int n, double dt)
{
for (int i=0;i<n;i++)
for (int j=0;j<NDIM;j++) {
data[i].x[j] += data[i].v[j]*dt;
}
calculate_forces(data, n);
for (int i=0;i<n;i++)
for (int j=0;j<NDIM;j++) {
double a = data[i].f[j] / data[i].mass;
data[i].v[j] += a*dt;
}
return;
}
// Leapfrog integrator (Drift-Kick-Drift) for non-rotating frame.
void integrate_particles(void) {
for(int i = 0; i < N; i++) {
particles[i].x += 0.5 * dt * particles[i].vx;
particles[i].y += 0.5 * dt * particles[i].vy;
particles[i].z += 0.5 * dt * particles[i].vz;
}
calculate_forces();
for(int i = 0; i < N; i++) {
particles[i].vx += dt * particles[i].ax;
particles[i].vy += dt * particles[i].ay;
particles[i].vz += dt * particles[i].az;
particles[i].x += 0.5 * dt * particles[i].vx;
particles[i].y += 0.5 * dt * particles[i].vy;
particles[i].z += 0.5 * dt * particles[i].vz;
}
}
void FMMMLayout :: call_FORCE_CALCULATION_step(Graph& G,NodeArray<NodeAttributes>&A,
EdgeArray<EdgeAttributes>& E,int act_level,
int max_level)
{
const int ITERBOUND = 10000;//needed to guarantee termination if
//stopCriterion() == scThreshold
if(G.numberOfNodes() > 1)
{
int iter = 1;
int max_mult_iter = get_max_mult_iter(act_level,max_level,G.numberOfNodes());
double actforcevectorlength = threshold() + 1;
NodeArray<DPoint> F_rep(G); //stores rep. forces
NodeArray<DPoint> F_attr(G); //stores attr. forces
NodeArray<DPoint> F (G); //stores resulting forces
NodeArray<DPoint> last_node_movement(G);//stores the force vectors F of the last
//iterations (needed to avoid oszilations)
set_average_ideal_edgelength(G,E);//needed for easy scaling of the forces
make_initialisations_for_rep_calc_classes(G);
while( ((stopCriterion() == scFixedIterations)&&(iter <= max_mult_iter)) ||
((stopCriterion() == scThreshold)&&(actforcevectorlength >= threshold())&&
(iter <= ITERBOUND)) ||
((stopCriterion() == scFixedIterationsOrThreshold)&&(iter <= max_mult_iter) &&
(actforcevectorlength >= threshold())) )
{//while
calculate_forces(G,A,E,F,F_attr,F_rep,last_node_movement,iter,0);
if(stopCriterion() != scFixedIterations)
actforcevectorlength = get_average_forcevector_length(G,F);
iter++;
}//while
if((act_level == 0))
call_POSTPROCESSING_step(G,A,E,F,F_attr,F_rep,last_node_movement);
deallocate_memory_for_rep_calc_classes();
}
}
