int updatePartCfg(int bonds_flag)
{
int j;
if(partCfg)
return 1;
partCfg = (Particle*)malloc(n_part*sizeof(Particle));
if (bonds_flag != WITH_BONDS)
mpi_get_particles(partCfg, NULL);
else
mpi_get_particles(partCfg,&partCfg_bl);
for(j=0; j<n_part; j++)
unfold_position(partCfg[j].r.p,partCfg[j].l.i);
partCfgSorted = 0;
#ifdef VIRTUAL_SITES
if (!sortPartCfg()) {
char *errtxt = runtime_error(128);
ERROR_SPRINTF(errtxt,"{094 could not sort partCfg} ");
return 0;
}
if (!updatePartCfg(bonds_flag)) {
char *errtxt = runtime_error(128);
ERROR_SPRINTF(errtxt,"{094 could not update positions of virtual sites in partcfg } ");
return 0;
}
#endif
return 1;
}
int mindist3(int part_id, double r_catch, int *ids) {
Particle *partCfgMD;
double dx,dy,dz;
int i, me, caught=0;
partCfgMD = (Particle*)malloc(n_part*sizeof(Particle));
mpi_get_particles(partCfgMD, NULL);
me = -1; /* Since 'mpi_get_particles' returns the particles unsorted, it's most likely that 'partCfgMD[i].p.identity != i'
--> prevent that! */
for(i=0; i<n_part; i++) if (partCfgMD[i].p.identity == part_id) me = i;
if (me == -1) {
ostringstream msg;
msg <<"failed to find desired particle " << part_id;
runtimeError(msg);
return 0;
}
for (i=0; i<n_part; i++) {
if (i != me) {
dx = partCfgMD[me].r.p[0] - partCfgMD[i].r.p[0]; dx -= dround(dx/box_l[0])*box_l[0];
dy = partCfgMD[me].r.p[1] - partCfgMD[i].r.p[1]; dy -= dround(dy/box_l[1])*box_l[1];
dz = partCfgMD[me].r.p[2] - partCfgMD[i].r.p[2]; dz -= dround(dz/box_l[2])*box_l[2];
if (sqrt(SQR(dx)+SQR(dy)+SQR(dz)) < r_catch) ids[caught++]=partCfgMD[i].p.identity;
}
}
free(partCfgMD);
return (caught);
}
void updatePartCfg(int bonds_flag)
{
int j;
if(partCfg)
return;
partCfg = malloc(n_total_particles*sizeof(Particle));
if (bonds_flag != WITH_BONDS)
mpi_get_particles(partCfg, NULL);
else
mpi_get_particles(partCfg,&partCfg_bl);
for(j=0; j<n_total_particles; j++)
unfold_position(partCfg[j].r.p,partCfg[j].l.i);
partCfgSorted = 0;
#ifdef VIRTUAL_SITES
if ((sortPartCfg()==0)||(update_mol_pos_cfg()==0)){
freePartCfg();
}
#endif
}
int collectBonds(int mode, int part_id, int N_P, int MPC, int type_bond, int **bond_out, int ***bonds_out) {
int i,j,k,ii,size, *bond=NULL, **bonds=NULL;
/* Get particle and bonding informations. */
IntList *bl;
Particle *prt, *sorted;
bl = (IntList*)malloc(1*sizeof(IntList));
prt = (Particle*)malloc(n_part*sizeof(Particle));
mpi_get_particles(prt, bl);
/* Sort the received informations. */
sorted = (Particle*)malloc(n_part*sizeof(Particle));
for(i = 0; i < n_part; i++)
memcpy(&sorted[prt[i].p.identity], &prt[i], sizeof(Particle));
free(prt);
prt = sorted;
if (mode == 1) {
/* Find all the bonds leading to and from the ending monomers of the chains. */
bond = (int*)malloc(2*N_P*sizeof(int));
bonds = (int**)malloc(2*N_P*sizeof(int *));
for (i=0; i < 2*N_P; i++) {
bond[i]=0;
bonds[i]= (int*)malloc(1*sizeof(int));
}
for (k=part_id; k < N_P*MPC + part_id; k++) {
i=0;
while(i < prt[k].bl.n) {
size = bonded_ia_params[prt[k].bl.e[i]].num;
if (prt[k].bl.e[i++] == type_bond) {
for(j=0; j<size; j++) {
if ((prt[k].p.identity % MPC == 0) || ( (prt[k].p.identity+1) % MPC == 0)) {
ii = prt[k].p.identity%MPC ? 2*(prt[k].p.identity+1)/MPC-1 : 2*prt[k].p.identity/MPC;
bonds[i] = (int*)realloc(bonds[i], (bond[i]+1)*sizeof(int));
bonds[ii][bond[ii]++] = prt[k].bl.e[i];
}
else if ((prt[k].bl.e[i] % MPC == 0) || ( (prt[k].bl.e[i]+1) % MPC == 0)) {
ii = prt[k].bl.e[i]%MPC ? 2*(prt[k].bl.e[i]+1)/MPC-1 : 2*prt[k].bl.e[i]/MPC;
bonds[i] = (int*)realloc(bonds[i], (bond[i]+1)*sizeof(int));
bonds[ii][bond[ii]++] = prt[k].p.identity;
}
i++;
}
}
else i += size;
}
}
POLY_TRACE(for (i=0; i < 2*N_P; i++) {
printf("(%d) %d:\t",i,i%2 ? (i+1)*MPC/2-1 : i*MPC/2); if(bond[i]>0) for(j=0;j<bond[i];j++) printf("%d ",bonds[i][j]); printf("\t=%d\n",bond[i]);
});
int updatePartCfg(int bonds_flag)
{
int j;
if(partCfg)
return 1;
partCfg = (Particle*)malloc(n_part*sizeof(Particle));
if (bonds_flag != WITH_BONDS)
mpi_get_particles(partCfg, NULL);
else
mpi_get_particles(partCfg,&partCfg_bl);
for(j=0; j<n_part; j++)
#ifdef LEES_EDWARDS
unfold_position(partCfg[j].r.p, partCfg[j].m.v, partCfg[j].l.i);
#else
unfold_position(partCfg[j].r.p, partCfg[j].l.i);
#endif
partCfgSorted = 0;
#ifdef VIRTUAL_SITES
if (!sortPartCfg()) {
ostringstream msg;
msg <<"could not sort partCfg";
runtimeError(msg);
return 0;
}
if (!updatePartCfg(bonds_flag)) {
ostringstream msg;
msg <<"could not update positions of virtual sites in partcfg";
runtimeError(msg);
return 0;
}
#endif
return 1;
}
double mindist4(double pos[3]) {
Particle *partCfgMD;
double mindist=30000.0, dx,dy,dz;
int i;
if (n_part ==0) return (dmin(dmin(box_l[0],box_l[1]),box_l[2]));
partCfgMD = (Particle*)malloc(n_part*sizeof(Particle));
mpi_get_particles(partCfgMD, NULL);
for (i=0; i<n_part; i++) {
dx = pos[0] - partCfgMD[i].r.p[0]; dx -= dround(dx/box_l[0])*box_l[0];
dy = pos[1] - partCfgMD[i].r.p[1]; dy -= dround(dy/box_l[1])*box_l[1];
dz = pos[2] - partCfgMD[i].r.p[2]; dz -= dround(dz/box_l[2])*box_l[2];
mindist = dmin(mindist, SQR(dx)+SQR(dy)+SQR(dz));
}
free(partCfgMD);
if (mindist<30000.0)
return (sqrt(mindist));
return (-1.0);
}
int tclcommand_inter_coulomb_parse_ewaldgpu_tunealpha(Tcl_Interp * interp, int argc, char ** argv)
{
double r_cut;
double alpha;
int num_kx;
int num_ky;
int num_kz;
double precision=0.000001;
IntList il;
init_intlist(&il);
//PARSE EWALD COMMAND LINE
if (argc < 3)
{
Tcl_AppendResult(interp, "\nWrong # arguments: <r_cut> (<K_cut> | {<K_cut,x> <K_cut,y><K_cut,z>}) <precision>", (char *) NULL);
return TCL_ERROR;
}
if (! ARG0_IS_D(r_cut))
{
Tcl_AppendResult(interp, "\n<r_cut> should be a double",(char *) NULL);
return TCL_ERROR;
}
if(! ARG_IS_I(1, num_kx))
{
if( ! ARG_IS_INTLIST(1, il) || !(il.n == 3) )
{
Tcl_AppendResult(interp, "\n(<K_cut> | {<K_cut,x> <K_cut,y><K_cut,z>}) integer or integer list of length 3 expected", (char *) NULL);
return TCL_ERROR;
}
else
{
num_kx = il.e[0];
num_ky = il.e[1];
num_kz = il.e[2];
}
}
else
{
num_kz = num_ky = num_kx;
}
if (! ARG_IS_D(2, precision))
{
Tcl_AppendResult(interp, "\n<precision> should be a double", (char *) NULL);
return TCL_ERROR;
}
//Compute alpha
Particle *particle;
particle = (Particle*)Utils::malloc(n_part*sizeof(Particle));
mpi_get_particles(particle, NULL);
double q_sqr = ewaldgpuForce->compute_q_sqare(particle);
alpha = ewaldgpuForce->compute_optimal_alpha(r_cut, num_kx, num_ky, num_kz, q_sqr, box_l, precision);
//Turn on ewaldgpu
if (!ewaldgpuForce) // inter coulomb ewaldgpu was never called before
{
ewaldgpuForce = new EwaldgpuForce(espressoSystemInterface, r_cut, num_kx, num_ky, num_kz, alpha);
forceActors.add(ewaldgpuForce);
energyActors.add(ewaldgpuForce);
}
//Broadcast parameters
coulomb.method = COULOMB_EWALD_GPU;
ewaldgpu_params.isTunedFlag = false;
ewaldgpu_params.isTuned = true;
rebuild_verletlist = 1;
mpi_bcast_coulomb_params();
return TCL_OK;
}
//Tuning
int EwaldgpuForce::adaptive_tune(char **log,SystemInterface &s)
{
ewaldgpu_params.isTuned = false;
int Kmax = ewaldgpu_params.K_max;
double alpha_array[Kmax]; //All computed alpha in dependence of K
double rcut_array[Kmax]; //All computed r_cut in dependence of all computed alpha
//Squared charge
Particle *particle;
particle = (Particle*)malloc(n_part*sizeof(Particle));
mpi_get_particles(particle, NULL);
double q_sqr = compute_q_sqare(particle);
char b[3*ES_INTEGER_SPACE + 3*ES_DOUBLE_SPACE + 128];
if (skin == -1) {
*log = strcat_alloc(*log, "ewaldgpu cannot be tuned, since the skin is not yet set");
return ES_ERROR;
}
//Compute alpha for all reciprocal k-sphere radius K
for(int K = 0; K < Kmax ;K++)
{
alpha_array[K] = tune_alpha(ewaldgpu_params.accuracy/sqrt(2), ewaldgpu_params.precision, K+1, box_l[0]*box_l[1]*box_l[2], q_sqr, n_part);
//printf("K:%i alpha:%f\n",K+1,alpha_array[K]);
}
//Compute r_cut for all computed alpha
for(int K = 0; K < Kmax ;K++)
{
rcut_array[K] = tune_rcut(ewaldgpu_params.accuracy/sqrt(2), ewaldgpu_params.precision, alpha_array[K], box_l[0]*box_l[1]*box_l[2], q_sqr, n_part);
//printf("K:%i rcut:%f \n",K+1,rcut_array[K]);
}
//Test if accuracy was reached
if(rcut_array[Kmax-1]<0)
{
return ES_ERROR;
}
/***********************************************************************************
PERFORMANCE TIME
***********************************************************************************/
//Test performance time for the diverent (K, rcut, alpha)
double int_time_best = 1E30;
int K_best = Kmax;
for(int K = 0; K < Kmax ;K++)
{
if(alpha_array[K]>0 and rcut_array[K]>0 and rcut_array[K]<(std::min(box_l[0],std::min(box_l[1],box_l[2])))/2.0-skin)
{
set_params(rcut_array[K], K+1, K+1, K+1, alpha_array[K]);
mpi_bcast_coulomb_params();
double int_time = time_force_calc(ewaldgpu_params.time_calc_steps);
if(int_time<int_time_best)
{
int_time_best = int_time;
K_best = K;
}
//printf("TIME K:%i int_time:%f\n",K+1,int_time);
}
}
set_params(rcut_array[K_best], K_best+1, K_best+1, K_best+1, alpha_array[K_best]);
ewaldgpu_params.isTuned = true;
mpi_bcast_coulomb_params();
//Print Status
sprintf(b, "ewaldgpu tune parameters: Accuracy goal = %f\n", ewaldgpu_params.accuracy);
*log = strcat_alloc(*log, b);
sprintf(b, "ewaldgpu tune parameters: Alpha = %f\n", ewaldgpu_params.alpha);
*log = strcat_alloc(*log, b);
sprintf(b, "ewaldgpu tune parameters: r_cut = %f\n", ewaldgpu_params.rcut);
*log = strcat_alloc(*log, b);
sprintf(b, "ewaldgpu tune parameters: num_kx = %i\n", ewaldgpu_params.num_kx);
*log = strcat_alloc(*log, b);
sprintf(b, "ewaldgpu tune parameters: num_ky = %i\n", ewaldgpu_params.num_ky);
*log = strcat_alloc(*log, b);
sprintf(b, "ewaldgpu tune parameters: num_kz = %i\n", ewaldgpu_params.num_kz);
*log = strcat_alloc(*log, b);
return ES_OK;
}
