::std::basic_ostream<CharT,CharTraitsT>& operator<<(::std::basic_ostream<CharT,CharTraitsT>& os, darx_siso_model<VectorT,RealT,UIntT> const& model)
{
::std::pair<UIntT,UIntT> ord = order(model);
os << "<SISO ARX model y(k)+a_1*y(k-t_s)+...+a_{n_a}*y(k-n_a*t_s)=b_0*u(k-d)+...+b_{n_b}*u(k-d-n_b*t_s):"
<< " t_s=" << sampling_time(model)
<< ", n_a=" << ord.first
<< ", n_b=" << ord.second
<< ", d=" << delay(model)
<< ", a=" << output_parameters(model)
<< ", b=" << input_parameters(model)
<< ">";
return os;
}
int main ( int argc, char *argv[])
{
float sigma, rcut, dt, eqtemp, dens, boxlx, boxly, boxlz, sfx, sfy, sfz, sr6, vrcut, dvrcut, dvrc12, freex;
int nstep, nequil, iscale, nc, mx, my, mz, iprint;
float *rx, *ry, *rz, *vx, *vy, *vz, *fx, *fy, *fz, *potentialPointer, *virialPointer, *virialArray, *potentialArray, *virialArrayTemp, *potentialArrayTemp;
float ace, acv, ack, acp, acesq, acvsq, acksq, acpsq, vg, kg, wg;
int *head, *list;
int natoms=0;
int ierror;
int jstart, step, itemp;
float potential, virial, kinetic;
float tmpx;
int i, icell;
cl_int err;
cl_device_id device;
cl_context context;
cl_command_queue queue;
cl_program program;
cl_kernel force_kernel;
cl_kernel add_kernel;
cl_mem d_rx, d_ry, d_rz, d_fx, d_fy, d_fz, d_head, d_list, d_potential, d_virial, d_virialArray, d_potentialArray;
ierror = input_parameters (&sigma, &rcut, &dt, &eqtemp, &dens, &boxlx, &boxly, &boxlz, &sfx, &sfy, &sfz, &sr6, &vrcut, &dvrcut, &dvrc12, &freex, &nstep, &nequil, &iscale, &nc, &natoms, &mx, &my, &mz, &iprint);
//printf ("\nReturned from input_parameters, natoms = %d\n", natoms);
device = create_device();
context = clCreateContext(NULL, 1, &device, NULL, NULL, &err);
if(err < 0) {
perror("Couldn't create a context");
exit(1);
}
/* Build the program */
program = build_program(context, device, PROGRAM_FILE);
force_kernel = clCreateKernel(program, FORCE_KERNEL, &err);
if(err < 0) {
perror("Couldn't create a kernel");
exit(1);
}
//printf("\nmx = %d, my = %d, mz = %d\n",mx,my,mz);
rx = (float *)malloc(2*natoms*sizeof(float));
ry = (float *)malloc(2*natoms*sizeof(float));
rz = (float *)malloc(2*natoms*sizeof(float));
vx = (float *)malloc(natoms*sizeof(float));
vy = (float *)malloc(natoms*sizeof(float));
vz = (float *)malloc(natoms*sizeof(float));
fx = (float *)malloc(natoms*sizeof(float));
fy = (float *)malloc(natoms*sizeof(float));
fz = (float *)malloc(natoms*sizeof(float));
list = (int *)malloc(2*natoms*sizeof(int));
head= (int *)malloc((mx+2)*(my+2)*(mz+2)*sizeof(int));
virialPointer = (float *)malloc(sizeof(float));
potentialPointer = (float *)malloc(sizeof(float));
int index = 0;
int numBlocks = ceil(natoms/(float)BLOCK_WIDTH);
virialArray = (float *)malloc( (numBlocks)* sizeof(float));
potentialArray = (float *)malloc((numBlocks) * sizeof(float));
virialArrayTemp = (float *)malloc(numBlocks * sizeof(float));
potentialArrayTemp = (float *)malloc(numBlocks * sizeof(float));
for (index = 0; index < numBlocks; index++)
{
virialArray[index] = (float)0;
potentialArray[index] = (float)0;
}
// printf ("\nFinished allocating memory\n");
initialise_particles (rx, ry, rz, vx, vy, vz, nc);
// printf ("\nReturned from initialise_particles\n");
loop_initialise(&ace, &acv, &ack, &acp, &acesq, &acvsq, &acksq, &acpsq, sigma, rcut, dt);
// printf ("\nReturned from loop_initialise\n");
// output_particles(rx,ry,rz,vx,vy,vz,fx,fy,fz,0);
movout (rx, ry, rz, vx, vy, vz, sfx, sfy, sfz, head, list, mx, my, mz, natoms);
// printf ("\nReturned from movout\n");
// check_cells(rx, ry, rz, head, list, mx, my, mz, natoms,0,0);
*potentialPointer = (float)0;
*virialPointer = (float)0;
d_rx = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * natoms * 2, rx, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_ry = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * natoms * 2, ry, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_rz = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * natoms * 2, rz, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_fx = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * natoms, fx, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_fy = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * natoms, fy, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_fz = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * natoms, fz, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_head = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, (mx+2)*(my+2)*(mz+2)*sizeof(int), head, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_list = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, 2*natoms*sizeof(int), list, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_virialArray = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * (numBlocks), virialArray, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_potentialArray = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * (numBlocks), potentialArray, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
err = clSetKernelArg(force_kernel, 0, sizeof(cl_mem), &d_virialArray);
err |= clSetKernelArg(force_kernel, 1, sizeof(cl_mem), &d_potentialArray);
err |= clSetKernelArg(force_kernel, 2, sizeof(cl_mem), &d_rx);
err |= clSetKernelArg(force_kernel, 3, sizeof(cl_mem), &d_ry);
err |= clSetKernelArg(force_kernel, 4, sizeof(cl_mem), &d_rz);
err |= clSetKernelArg(force_kernel, 5, sizeof(cl_mem), &d_fx);
err |= clSetKernelArg(force_kernel, 6, sizeof(cl_mem), &d_fy);
err |= clSetKernelArg(force_kernel, 7, sizeof(cl_mem), &d_fz);
err |= clSetKernelArg(force_kernel, 8, sizeof(sigma), &sigma);
err |= clSetKernelArg(force_kernel, 9, sizeof(rcut), &rcut);
err |= clSetKernelArg(force_kernel, 10, sizeof(vrcut), &vrcut);
err |= clSetKernelArg(force_kernel, 11, sizeof(dvrc12), &dvrc12);
err |= clSetKernelArg(force_kernel, 12, sizeof(dvrcut), &dvrcut);
err |= clSetKernelArg(force_kernel, 13, sizeof(cl_mem), &d_head);
err |= clSetKernelArg(force_kernel, 14, sizeof(cl_mem), &d_list);
err |= clSetKernelArg(force_kernel, 15, sizeof(mx), &mx);
err |= clSetKernelArg(force_kernel, 16, sizeof(my), &my);
err |= clSetKernelArg(force_kernel, 17, sizeof(mz), &mz);
err |= clSetKernelArg(force_kernel, 18, sizeof(natoms), &natoms);
err |= clSetKernelArg(force_kernel, 19, sizeof(sfx), &sfx);
err |= clSetKernelArg(force_kernel, 20, sizeof(sfy), &sfy);
err |= clSetKernelArg(force_kernel, 21, sizeof(sfz), &sfz);
if(err < 0) {
printf("Couldn't set an argument for the transpose kernel");
exit(1);
}
//size_t max_size;
//clGetKernelWorkGroupInfo(add_kernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(max_size), &max_size, NULL);
//printf("\nMAX SIZE: %d\n", max_size);
queue = clCreateCommandQueue(context, device, 0, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
size_t global_size[1];
size_t local_size[1];
global_size[0] = BLOCK_WIDTH * ceil(natoms / (float) BLOCK_WIDTH);
local_size[0] = BLOCK_WIDTH;
long double elapsedTime = (float)0.0;
long unsigned int startTime;
long unsigned int endTime;
startTime = get_tick();
err = clEnqueueNDRangeKernel(queue, force_kernel, 1, NULL, global_size, local_size, 0, NULL, NULL);
clFinish(queue);
endTime = get_tick();
if(err < 0) {
printf("Couldn't enqueue force kernel\n");
printf("%d\n", err);
printf("CL_INVALID_PROGRAM_EXECUTABLE: %d\n", CL_INVALID_PROGRAM_EXECUTABLE);
printf("CL_INVALID_COMMAND_QUEUE: %d\n",CL_INVALID_COMMAND_QUEUE );
printf("CL_INVALID_KERNEL: %d\n", CL_INVALID_KERNEL);
printf("CL_INVALID_CONTEXT: %d\n", CL_INVALID_CONTEXT);
printf("CL_INVALID_KERNEL_ARGS: %d\n", CL_INVALID_KERNEL_ARGS);
printf("CL_INVALID_WORK_DIMENSION: %d\n", CL_INVALID_WORK_DIMENSION);
printf("CL_INVALID_GLOBAL_WORK_SIZE: %d\n", CL_INVALID_GLOBAL_WORK_SIZE);
printf("CL_INVALID_GLOBAL_OFFSET: %d\n", CL_INVALID_GLOBAL_OFFSET);
printf("CL_INVALID_WORK_GROUP_SIZE: %d\n", CL_INVALID_WORK_GROUP_SIZE);
exit(1);
}
elapsedTime += endTime - startTime;
err = clEnqueueReadBuffer(queue, d_fx, CL_TRUE, 0, sizeof(float) * natoms, fx, 0, NULL, NULL);
err |= clEnqueueReadBuffer(queue, d_fy, CL_TRUE, 0, sizeof(float) * natoms, fy, 0, NULL, NULL);
err |= clEnqueueReadBuffer(queue, d_fz, CL_TRUE, 0, sizeof(float) * natoms, fz, 0, NULL, NULL);
err |= clEnqueueReadBuffer(queue, d_virialArray, CL_TRUE, 0, sizeof(float) * numBlocks, virialArrayTemp, 0, NULL, NULL);
err |= clEnqueueReadBuffer(queue, d_potentialArray, CL_TRUE, 0, sizeof(float) * numBlocks, potentialArrayTemp, 0, NULL, NULL);
if(err < 0) {
printf("Couldn't read fx buffer\n");
printf("%d\n",err );
printf("CL_INVALID_COMMAND_QUEUE: %d\n",CL_INVALID_COMMAND_QUEUE);
printf("CL_INVALID_CONTEXT: %d\n", CL_INVALID_CONTEXT);
printf("CL_INVALID_MEM_OBJECT: %d\n", CL_INVALID_MEM_OBJECT);
printf("CL_INVALID_VALUE: %d\n",CL_INVALID_VALUE);
printf("CL_INVALID_EVENT_WAIT_LIST: %d\n", CL_INVALID_EVENT_WAIT_LIST);
printf("CL_MEM_OBJECT_ALLOCATION_FAILURE: %d\n",CL_MEM_OBJECT_ALLOCATION_FAILURE);
printf("CL_OUT_OF_HOST_MEMORY: %d\n", CL_OUT_OF_HOST_MEMORY);
exit(1);
}
clFinish(queue);
virial = 0.0;
potential = 0.0;
int tempInd = 0;
for (tempInd =0; tempInd < numBlocks; tempInd++)
{
potential += potentialArrayTemp[tempInd];
virial += virialArrayTemp[tempInd];
}
virial *= 48.0/3.0;
potential *= 4.0;
// printf ("\nReturned from force: potential = %f, virial = %f, kinetic = %f\n",potential, virial, kinetic);
// output_particles(rx,ry,rz,vx,vy,vz,fx,fy,fz,0);
for(step=1;step<=nstep;step++){
// if(step>=85)printf ("\nStarted step %d\n",step);
movea (rx, ry, rz, vx, vy, vz, fx, fy, fz, dt, natoms);
// check_cells(rx, ry, rz, head, list, mx, my, mz, natoms,step,step);
// if(step>85)printf ("\nReturned from movea\n");
movout (rx, ry, rz, vx, vy, vz, sfx, sfy, sfz, head, list, mx, my, mz, natoms);
// if(step>85) printf ("\nReturned from movout\n");
// check_cells(rx, ry, rz, head, list, mx, my, mz, natoms,step,step);
clReleaseMemObject(d_rx);
clReleaseMemObject(d_ry);
clReleaseMemObject(d_rz);
clReleaseMemObject(d_fx);
clReleaseMemObject(d_fy);
clReleaseMemObject(d_fz);
clReleaseMemObject(d_head);
clReleaseMemObject(d_list);
clReleaseMemObject(d_virialArray);
clReleaseMemObject(d_potentialArray);
d_rx = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * natoms * 2, rx, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_ry = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * natoms * 2, ry, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_rz = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * natoms * 2, rz, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_fx = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * natoms, fx, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_fy = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * natoms, fy, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_fz = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * natoms, fz, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_head = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, (mx+2)*(my+2)*(mz+2)*sizeof(int), head, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_list = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, 2*natoms*sizeof(int), list, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_virialArray = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * (numBlocks), virialArray, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
d_potentialArray = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, sizeof(float) * (numBlocks), potentialArray, &err);
if(err < 0) {
perror("Couldn't create a command queue");
exit(1);
}
err = clSetKernelArg(force_kernel, 0, sizeof(cl_mem), &d_virialArray);
err |= clSetKernelArg(force_kernel, 1, sizeof(cl_mem), &d_potentialArray);
err |= clSetKernelArg(force_kernel, 2, sizeof(cl_mem), &d_rx);
err |= clSetKernelArg(force_kernel, 3, sizeof(cl_mem), &d_ry);
err |= clSetKernelArg(force_kernel, 4, sizeof(cl_mem), &d_rz);
err |= clSetKernelArg(force_kernel, 5, sizeof(cl_mem), &d_fx);
err |= clSetKernelArg(force_kernel, 6, sizeof(cl_mem), &d_fy);
err |= clSetKernelArg(force_kernel, 7, sizeof(cl_mem), &d_fz);
err |= clSetKernelArg(force_kernel, 8, sizeof(sigma), &sigma);
err |= clSetKernelArg(force_kernel, 9, sizeof(rcut), &rcut);
err |= clSetKernelArg(force_kernel, 10, sizeof(vrcut), &vrcut);
err |= clSetKernelArg(force_kernel, 11, sizeof(dvrc12), &dvrc12);
err |= clSetKernelArg(force_kernel, 12, sizeof(dvrcut), &dvrcut);
err |= clSetKernelArg(force_kernel, 13, sizeof(cl_mem), &d_head);
err |= clSetKernelArg(force_kernel, 14, sizeof(cl_mem), &d_list);
err |= clSetKernelArg(force_kernel, 15, sizeof(mx), &mx);
err |= clSetKernelArg(force_kernel, 16, sizeof(my), &my);
err |= clSetKernelArg(force_kernel, 17, sizeof(mz), &mz);
err |= clSetKernelArg(force_kernel, 18, sizeof(natoms), &natoms);
err |= clSetKernelArg(force_kernel, 19, sizeof(sfx), &sfx);
err |= clSetKernelArg(force_kernel, 20, sizeof(sfy), &sfy);
err |= clSetKernelArg(force_kernel, 21, sizeof(sfz), &sfz);
if(err < 0) {
printf("Couldn't set an argument for the transpose kernel");
exit(1);
}
global_size[0] = BLOCK_WIDTH * ceil(natoms / (float) BLOCK_WIDTH);
local_size[0] = BLOCK_WIDTH;
//printf("Global Size: %d\n", global_size[0]);
//printf("Local Size: %d\n", local_size[0]);
clFinish(queue);
startTime = get_tick();
err = clEnqueueNDRangeKernel(queue, force_kernel, 1, NULL, global_size, local_size, 0, NULL, NULL);
clFinish(queue);
endTime = get_tick();
elapsedTime += endTime - startTime;
if(err < 0) {
printf("Couldn't enqueue force kernel\n");
exit(1);
}
//float fxTest[natoms];
//size_t sizy = sizeof(float) * (natoms);
err = clEnqueueReadBuffer(queue, d_fx, CL_TRUE, 0, sizeof(float) * natoms, fx, 0, NULL, NULL);
err |= clEnqueueReadBuffer(queue, d_fy, CL_TRUE, 0, sizeof(float) * natoms, fy, 0, NULL, NULL);
err |= clEnqueueReadBuffer(queue, d_fz, CL_TRUE, 0, sizeof(float) * natoms, fz, 0, NULL, NULL);
err |= clEnqueueReadBuffer(queue, d_virialArray, CL_TRUE, 0, sizeof(float) * numBlocks, virialArrayTemp, 0, NULL, NULL);
err |= clEnqueueReadBuffer(queue, d_potentialArray, CL_TRUE, 0, sizeof(float) * numBlocks, potentialArrayTemp, 0, NULL, NULL);
if(err < 0) {
printf("Couldn't read buffer\n");
printf("%d\n",err );
printf("CL_INVALID_COMMAND_QUEUE: %d\n",CL_INVALID_COMMAND_QUEUE);
printf("CL_INVALID_CONTEXT: %d\n", CL_INVALID_CONTEXT);
printf("CL_INVALID_MEM_OBJECT: %d\n", CL_INVALID_MEM_OBJECT);
printf("CL_INVALID_VALUE: %d\n",CL_INVALID_VALUE);
printf("CL_INVALID_EVENT_WAIT_LIST: %d\n", CL_INVALID_EVENT_WAIT_LIST);
printf("CL_MEM_OBJECT_ALLOCATION_FAILURE: %d\n",CL_MEM_OBJECT_ALLOCATION_FAILURE);
printf("CL_OUT_OF_HOST_MEMORY: %d\n", CL_OUT_OF_HOST_MEMORY);
exit(1);
}
clFinish(queue);
//numInc = 0;
//globalThreads = ceil(numBlocks / (float)BLOCK_WIDTH);
// startTime = get_tick();
virial = 0.0;
potential = 0.0;
int tempInd = 0;
for (tempInd =0; tempInd < numBlocks; tempInd++)
{
potential += potentialArrayTemp[tempInd];
virial += virialArrayTemp[tempInd];
}
virial *= 48.0/3.0;
potential *= 4.0;
// if(step>85)printf ("\nReturned from force: potential = %f, virial = %f, kinetic = %f\n",potential, virial, kinetic);
// fflush(stdout);
moveb (&kinetic, vx, vy, vz, fx, fy, fz, dt, natoms);
// check_cells(rx, ry, rz, head, list, mx, my, mz, natoms,step,step);
// if(step>85) printf ("\nReturned from moveb: potential = %f, virial = %f, kinetic = %f\n",potential, virial, kinetic);
sum_energies (potential, kinetic, virial, &vg, &wg, &kg);
hloop (kinetic, step, vg, wg, kg, freex, dens, sigma, eqtemp, &tmpx, &ace, &acv, &ack, &acp, &acesq, &acvsq, &acksq, &acpsq, vx, vy, vz, iscale, iprint, nequil, natoms);
}
tidyup (ace, ack, acv, acp, acesq, acksq, acvsq, acpsq, nstep, nequil);
elapsedTime = elapsedTime / (float) 1000;
printf("\n%Lf seconds have elapsed\n", elapsedTime);
return 0;
}
int main ( int argc, char *argv[])
{
float sigma, rcut, dt, eqtemp, dens, boxlx, boxly, boxlz, sfx, sfy, sfz, sr6, vrcut, dvrcut, dvrc12, freex;
int nstep, nequil, iscale, nc, mx, my, mz, iprint, map[MAPSIZ];
float *rx, *ry, *rz, *vx, *vy, *vz, *fx, *fy, *fz;
float ace, acv, ack, acp, acesq, acvsq, acksq, acpsq, vg, kg, wg;
int *head, *list;
int natoms=0;
int ierror;
int jstart, step, itemp;
float potential, virial, kinetic;
float tmpx;
int i, icell;
ierror = input_parameters (&sigma, &rcut, &dt, &eqtemp, &dens, &boxlx, &boxly, &boxlz, &sfx, &sfy, &sfz, &sr6, &vrcut, &dvrcut, &dvrc12, &freex, &nstep, &nequil, &iscale, &nc, &natoms, &mx, &my, &mz, &iprint, map);
//printf ("\nReturned from input_parameters, natoms = %d\n", natoms);
rx = (float *)malloc(2*natoms*sizeof(float));
ry = (float *)malloc(2*natoms*sizeof(float));
rz = (float *)malloc(2*natoms*sizeof(float));
vx = (float *)malloc(natoms*sizeof(float));
vy = (float *)malloc(natoms*sizeof(float));
vz = (float *)malloc(natoms*sizeof(float));
fx = (float *)malloc(natoms*sizeof(float));
fy = (float *)malloc(natoms*sizeof(float));
fz = (float *)malloc(natoms*sizeof(float));
list = (int *)malloc(2*natoms*sizeof(int));
head = (int *)malloc((mx+2)*(my+2)*(mz+2)*sizeof(int));
initialise_particles (rx, ry, rz, vx, vy, vz, nc);
//printf ("\nReturned from initialise_particles\n");
loop_initialise(&ace, &acv, &ack, &acp, &acesq, &acvsq, &acksq, &acpsq, sigma, rcut, dt);
//printf ("\nReturned from loop_initialise\n");
output_particles(rx,ry,rz,vx,vy,vz,fx,fy,fz,0);
movout (rx, ry, rz, vx, vy, vz, sfx, sfy, sfz, head, list, mx, my, mz, natoms);
//printf ("\nReturned from movout\n");
// check_cells(rx, ry, rz, head, list, mx, my, mz, natoms,0,0);
force (&potential, &virial, rx, ry, rz, fx, fy, fz, sigma, rcut, vrcut, dvrc12, dvrcut, head, list, map, mx, my, mz, natoms,0);
//printf ("\nReturned from force: potential = %f, virial = %f, kinetic = %f\n",potential, virial, kinetic);
output_particles(rx,ry,rz,vx,vy,vz,fx,fy,fz,0);
for(step=1;step<=nstep;step++){
//printf ("\nStarted step %d\n",step);
movea (rx, ry, rz, vx, vy, vz, fx, fy, fz, dt, natoms);
// check_cells(rx, ry, rz, head, list, mx, my, mz, natoms,step,step);
//printf ("\nReturned from movea\n");
movout (rx, ry, rz, vx, vy, vz, sfx, sfy, sfz, head, list, mx, my, mz, natoms);
// printf ("\nReturned from movout\n");
// check_cells(rx, ry, rz, head, list, mx, my, mz, natoms,step,step);
force (&potential, &virial, rx, ry, rz, fx, fy, fz, sigma, rcut, vrcut, dvrc12, dvrcut, head, list, map, mx, my, mz, natoms, step);
//printf ("\nReturned from force: potential = %f, virial = %f, kinetic = %f\n",potential, virial, kinetic);
moveb (&kinetic, vx, vy, vz, fx, fy, fz, dt, natoms);
// check_cells(rx, ry, rz, head, list, mx, my, mz, natoms,step,step);
// printf ("\nReturned from moveb: potential = %f, virial = %f, kinetic = %f\n",potential, virial, kinetic);
sum_energies (potential, kinetic, virial, &vg, &wg, &kg);
hloop (kinetic, step, vg, wg, kg, freex, dens, sigma, eqtemp, &tmpx, &ace, &acv, &ack, &acp, &acesq, &acvsq, &acksq, &acpsq, vx, vy, vz, iscale, iprint, nequil, natoms);
}
tidyup (ace, ack, acv, acp, acesq, acksq, acvsq, acpsq, nstep, nequil);
return 0;
}
int cochleo_stream::run(const parameters& param)
{
static const std::size_t frames_per_buffer = 64;
try
{
portaudio::AutoSystem autoSys;
portaudio::System &sys = portaudio::System::instance();
cout << "===================================================" << endl << endl;
auto& device = sys.deviceByIndex(param.device_id());
BOOST_LOG_TRIVIAL(info) << "Opening device " << device.name();
// mono capture interleaved
portaudio::DirectionSpecificStreamParameters input_parameters(device,1,portaudio::FLOAT32,true,0.0,NULL);
portaudio::StreamParameters stream_params(input_parameters,
portaudio::DirectionSpecificStreamParameters::null(),
device.defaultSampleRate(), frames_per_buffer, paNoFlag);
// signal_renderer renderer(stream.sampleRate(), 5);
// portaudio::MemFunCallbackStream<signal_renderer> stream(stream_params, renderer, &signal_renderer::callback);
// BOOST_LOG_TRIVIAL(info) << "Starting 5 s recording";
// stream.start();
// stream.stop();
// stream.close();
// sys.terminate();
}
catch(const portaudio::PaException &e)
{
std::cout << "A PortAudio error occured: " << e.paErrorText() << std::endl;
}
catch(const portaudio::PaCppException &e)
{
std::cout << "A PortAudioCpp error occured: " << e.what() << std::endl;
}
catch(const std::exception &e)
{
std::cout << "A generic exception occured: " << e.what() << std::endl;
}
catch(...)
{
std::cout << "An unknown exception occured." << std::endl;
}
// BOOST_LOG_TRIVIAL(info) << "Input file is " << params.input() << ", " << audio.to_string();
// // initialize filterbank
// filterbank fb(audio.sample_frequency(),
// params.low_frequency(),
// params.high_frequency(),
// params.nb_channels());
// BOOST_LOG_TRIVIAL(info) << "Gammatone filtering on "
// << params.nb_channels() << " channels from "
// << (int)fb.begin()->center_frequency() << "Hz to "
// << (int)fb.rbegin()->center_frequency() << "Hz";
// // declare the resulting multichannel cochleogram.
// // cochleogram[i][j] where i is audio channel, j is the
// // corresponding cochleogram
// std::vector<std::vector<double> > cochleogram(audio.nb_channels(),
// std::vector<double>(xsize*ysize));
// // xaxis is time, yaxis are center frequencies
// const auto xaxis = gammatone::detail::linspace(0.0, audio.duration(), audio.size());
// const auto yaxis = fb.center_frequency();
// const auto xsize = xaxis.size();
// const auto ysize = yaxis.size();
// // process separatly on each audio channel
// for(size_t i=0; i<audio.nb_channels(); i++)
// {
// fb.reset();
// fb.compute(xsize,ysize,audio.channel(i).data(),cochleogram[i].data());
// if(params.normalize()) normalization(xsize,ysize,cochleogram[i].data());
// }
// BOOST_LOG_TRIVIAL(info) << "Entering " << renderer::vtk_version();
// renderer vtk(16/9.0);
// vtk.render(xaxis,yaxis,cochleogram[0].data());
return 0;
}
int main(void)
{
DIR *dirp;
struct dirent *direntp;
FILE *input,*output;
int i,p,nTIME,nVS,nVSSC,nVERC,nVERCIR;
extern void shell(unsigned long n, double a[]);
double *time;
double *vS,*vSSC,*vERC,*vERCIR;
double *LSave,*LSSCave,*LERCave,*LERCIRave;
double vsum,vsumMIN,vsumMAX,Lsum,L;
double theta,tobsMIN;
int average(const char *name,double *time,int nTIME,int *nV,double **v,double **Lvave);
extern int locate(double xx[],unsigned long n,double x);
extern double linear(double x,double x1,double y1,double x2,double y2);
int nRAD,nG;
double *r;
float tempg,tempN;
double *g,**Ng,*Ngave;
char *filename,*rad;
input_parameters();
/* average electrons */
dirp = opendir(".");
nRAD = 0;
while((direntp=readdir(dirp))!=NULL)
if(strncmp(direntp->d_name,"Ng_",(size_t)3)==0)
nRAD++;
if (nRAD>0){
r = dvector(1,nRAD);
(void)rewinddir(dirp);
i = 0;
while((direntp=readdir(dirp))!=NULL)
if(strncmp(direntp->d_name,"Ng_",(size_t)3)==0)
r[++i] = (double)atof((direntp->d_name)+3);
shell((unsigned long)nRAD,r);
printf("\nCalculating Ngave ... ");
fflush(stdout);
/* determine nG */
filename = (char *)malloc((size_t)(20*sizeof(char)));
rad = (char *)malloc((size_t)(20*sizeof(char)));
strcpy(filename,"Ng_");
sprintf(rad,"%.6f",r[1]);
strcat(filename,rad);
input = fopen(filename,"r");
nG = 0;
while(fscanf(input,"%f %f",&tempg,&tempN)!=EOF)
nG++;
fclose(input);
/* allocate memory for g, Ng and Ngave */
g = dvector(1,nG);
Ng = dmatrix(1,nRAD,1,nG);
Ngave = dvector(1,nG);
/* read electron densities */
strcpy(filename,"Ng_");
sprintf(rad,"%.6f",r[1]);
strcat(filename,rad);
input = fopen(filename,"r");
for(p=1;p<=nG;p++){
fscanf(input,"%f %f",&tempg,&tempN);
g[p] = (double)tempg;
Ng[1][p] = (tempN==0.0) ? 0.0 : pow(10.0,(double)tempN);
}
fclose(input);
for(i=2;i<=nRAD;i++){
strcpy(filename,"Ng_");
sprintf(rad,"%.6f",r[i]);
strcat(filename,rad);
input = fopen(filename,"r");
for(p=1;p<=nG;p++) {
fscanf(input,"%f %f",&tempg,&tempN);
Ng[i][p] = (tempN==0.0) ? 0.0 : pow(10.0,(double)tempN);
}
fclose(input);
}
free(rad);
/* average */
output = fopen("Ngave","w");
for(p=1;p<=nG;p++){
Ngave[p] = 0.0;
for(i=1;i<=nRAD;i++)
Ngave[p] += Ng[i][p]/nRAD;
fprintf(output,"%e %e\n",g[p],(Ngave[p] > 0.0) ? log10(Ngave[p]) : 0.0);
}
fclose(output);
free_dvector(g,1,nG);
free_dmatrix(Ng,1,nRAD,1,nG);
free_dvector(Ngave,1,nG);
printf("done.\n");
}
(void)closedir(dirp);
/* read time */
dirp = opendir(".");
nTIME=0;
while((direntp=readdir(dirp))!=NULL)
if(strncmp(direntp->d_name,"LS_",(size_t)3)==0)
nTIME++;
time=dvector(1,nTIME);
(void)rewinddir(dirp);
i=0;
while((direntp=readdir(dirp))!=NULL)
if(strncmp(direntp->d_name,"LS_",(size_t)3)==0)
time[++i]=(double)atof((direntp->d_name)+3);
(void)closedir(dirp);
/* sort time */
shell((unsigned long)nTIME,time);
/* time range */
// theta = (THETAOBS<THETAJ) ? 0.0 : (THETAOBS-THETAJ);
//tobsMIN = (double)R0*(1.0-beta(GAMMA)*cos(theta))/(LIGHT_SPEED*beta(GAMMA));
/* check averaging limits */
//if ((TAVMIN>0.0 && TAVMIN<time[1]*tobsMIN) || TAVMAX>time[nTIME]*tobsMIN)
if ((TAVMIN>0.0 && TAVMIN<time[1]) || TAVMAX>time[nTIME])
fprintf(stderr,"Error: averaging boundry out of range in avekn.c!\n");
vsumMIN = 1.0e10; /* default values */
vsumMAX = 1.0e20;
if(SYN){
average("LS",time,nTIME,&nVS,&vS,&LSave);
if (vS[1]<vsumMIN)
vsumMIN = vS[1];
if (vS[nVS]>vsumMAX)
vsumMAX = vS[nVS];
}
if(SSC){
average("LSSC",time,nTIME,&nVSSC,&vSSC,&LSSCave);
if (vSSC[1]<vsumMIN)
vsumMIN = vSSC[1];
if (vSSC[nVSSC]>vsumMAX)
vsumMAX = vSSC[nVSSC];
}
if(ERC){
average("LERC",time,nTIME,&nVERC,&vERC,&LERCave);
if (vERC[1]<vsumMIN)
vsumMIN = vERC[1];
if (vERC[nVERC]>vsumMAX)
vsumMAX = vERC[nVERC];
}
if(ERCIR){
average("LERCIR",time,nTIME,&nVERCIR,&vERCIR,&LERCIRave);
if (vERCIR[1]<vsumMIN)
vsumMIN = vERCIR[1];
if (vERCIR[nVERCIR]>vsumMAX)
vsumMAX = vERCIR[nVERCIR];
}
/* complete averaged spectra */
output = fopen("Lave","w");
printf("\nCalculating Lave ... ");
fflush(stdout);
for(i=1;i<=NVSUM;i++){
vsum = vsumMIN*pow(vsumMAX/vsumMIN,(i-1.0)/(NVSUM-1.0));
Lsum = 0.0;
if(SYN && vsum>vS[1] && vsum<vS[nVS]){
p = locate(vS,nVS,vsum);
L = linear(vsum,vS[p],LSave[p],vS[p+1],LSave[p+1]);
Lsum += L;
}
if(SSC && vsum>vSSC[1] && vsum<vSSC[nVSSC]){
p = locate(vSSC,nVSSC,vsum);
L = linear(vsum,vSSC[p],LSSCave[p],vSSC[p+1],LSSCave[p+1]);
Lsum += L;
}
if(ERC && vsum>vERC[1] && vsum<vERC[nVERC]){
p = locate(vERC,nVERC,vsum);
L = linear(vsum,vERC[p],LERCave[p],vERC[p+1],LERCave[p+1]);
Lsum += L;
}
if(ERCIR && vsum>vERCIR[1] && vsum<vERCIR[nVERCIR]){
p = locate(vERCIR,nVERCIR,vsum);
L = linear(vsum,vERCIR[p],LERCIRave[p],vERCIR[p+1],LERCIRave[p+1]);
Lsum += L;
}
fprintf(output,"%e %e\n",log10(vsum),(Lsum==0.0) ? 0.0 : log10(Lsum));
}
fclose(output);
printf("done.\n");
/* free memory */
if(ERCIR){
free_dvector(LERCIRave,1,nVERCIR);
free_dvector(vERCIR,1,nVERCIR);
}
if(ERC){
free_dvector(LERCave,1,nVERC);
free_dvector(vERC,1,nVERC);
}
if(SSC){
free_dvector(LSSCave,1,nVSSC);
free_dvector(vSSC,1,nVSSC);
}
if(SYN){
free_dvector(LSave,1,nVS);
free_dvector(vS,1,nVS);
}
free_dvector(time,1,nTIME);
return 0;
}
