CFix operator*(const Fix &x, const CFix &y) { return CFix(x.get_re() * y.get_re(), x.get_re() * y.get_im(), x.get_shift() + y.get_shift(), 0, 0); }
CFix operator/(const CFix &x, const Fix &y) { return CFix(x.get_re() / y.get_re(), x.get_im() / y.get_re(), x.get_shift() - y.get_shift(), 0, 0); }
CFix operator/(const Fix &x, const CFix &y) { fixrep denominator = y.get_re() * y.get_re() + y.get_im() * y.get_im(); return CFix(x.get_re() * y.get_re() / denominator, -x.get_re() * y.get_im() / denominator, x.get_shift() - y.get_shift(), 0, 0); }
void ComputeSlice::extract_one(int m, double *vec, int stride) { int i,j; // invoke the appropriate compute if needed if (which[m] == COMPUTE) { Compute *compute = modify->compute[value2index[m]]; if (argindex[m] == 0) { if (!(compute->invoked_flag & INVOKED_VECTOR)) { compute->compute_vector(); compute->invoked_flag |= INVOKED_VECTOR; } double *cvector = compute->vector; j = 0; for (i = nstart; i < nstop; i += nskip) { vec[j] = cvector[i-1]; j += stride; } } else { if (!(compute->invoked_flag & INVOKED_ARRAY)) { compute->compute_array(); compute->invoked_flag |= INVOKED_ARRAY; } double **carray = compute->array; int icol = argindex[m]-1; j = 0; for (i = nstart; i < nstop; i += nskip) { vec[j] = carray[i-1][icol]; j += stride; } } // access fix fields, check if fix frequency is a match } else if (which[m] == FIX) { if (update->ntimestep % modify->fix[value2index[m]]->global_freq) error->all(FLERR,"Fix used in compute slice not computed at compatible time"); Fix *fix = modify->fix[value2index[m]]; if (argindex[m] == 0) { j = 0; for (i = nstart; i < nstop; i += nskip) { vec[j] = fix->compute_vector(i-1); j += stride; } } else { int icol = argindex[m]-1; j = 0; for (i = nstart; i < nstop; i += nskip) { vec[j] = fix->compute_array(i-1,icol); j += stride; } } } }
Constraint::Constraint(ConstraintKind kind, Fix fix, Type first, Type second, ConstraintLocator *locator, ArrayRef<TypeVariableType *> typeVars) : Kind(kind), TheFix(fix.getKind()), FixData(fix.getData()), HasRestriction(false), HasFix(true), IsActive(false), RememberChoice(false), IsFavored(false), NumTypeVariables(typeVars.size()), Types{ first, second, Identifier() }, Locator(locator) { assert(!first.isNull()); assert(!second.isNull()); std::copy(typeVars.begin(), typeVars.end(), getTypeVariablesBuffer().begin()); }
CFix operator-(const Fix &x, const CFix &y) { return CFix(x.get_re() - y.get_re(), -y.get_im(), assert_shifts(y, x), 0, 0); }
CFix operator+(const CFix &x, const Fix &y) { return CFix(x.get_re() + y.get_re(), x.get_im(), assert_shifts(x, y), 0, 0); }
double Properties::max_radius() { const double maxtype = max_type(); double maxRadius = -1.0; // check local particles for (int i=0;i<atom->nlocal;i++) { const double irad = atom->radius[i]; // maximum if (irad > maxRadius) maxRadius = irad; } // check all fixes // such as fix insert, fix change/type, fix wall, fix pour for(int i=0;i<modify->nfix;i++) { // checks Fix *fix = modify->fix[i]; if(!fix->use_rad_for_cut_neigh_and_ghost()) continue; // loop over all types since min_rad(int) and max_rad(int) need a type for (int j=1;j<maxtype+1;j++) { const double f_maxrad = fix->max_rad(j); if(f_maxrad > SMALL && f_maxrad > maxRadius) maxRadius = f_maxrad; } } //Get min/max from other procs double maxRadius_all; MPI_Allreduce(&maxRadius,&maxRadius_all, 1, MPI_DOUBLE, MPI_MAX, world); maxRadius = maxRadius_all; //error check if(maxRadius <= SMALL) error->all(FLERR,"Atom radius must be bigger than zero for granular simulations"); return maxRadius; }
void *lammps_extract_fix(void *ptr, char *id, int style, int type, int i, int j) { LAMMPS *lmp = (LAMMPS *) ptr; int ifix = lmp->modify->find_fix(id); if (ifix < 0) return NULL; Fix *fix = lmp->modify->fix[ifix]; if (style == 0) { double *dptr = (double *) malloc(sizeof(double)); if (type == 0) { if (!fix->scalar_flag) return NULL; *dptr = fix->compute_scalar(); return (void *) dptr; } if (type == 1) { if (!fix->vector_flag) return NULL; *dptr = fix->compute_vector(i); return (void *) dptr; } if (type == 2) { if (!fix->array_flag) return NULL; *dptr = fix->compute_array(i,j); return (void *) dptr; } } if (style == 1) { if (!fix->peratom_flag) return NULL; if (type == 1) return (void *) fix->vector_atom; if (type == 2) return (void *) fix->array_atom; } if (style == 2) { if (!fix->local_flag) return NULL; if (type == 1) return (void *) fix->vector_local; if (type == 2) return (void *) fix->array_local; } return NULL; }
void FixGrem::init() { if (domain->triclinic) error->all(FLERR,"Triclinic cells are not supported"); // set temperature and pressure ptrs int icompute = modify->find_compute(id_temp); if (icompute < 0) error->all(FLERR,"Temperature compute ID for fix grem does not exist"); temperature = modify->compute[icompute]; icompute = modify->find_compute(id_ke); if (icompute < 0) error->all(FLERR,"KE compute ID for fix grem does not exist"); ke = modify->compute[icompute]; icompute = modify->find_compute(id_pe); if (icompute < 0) error->all(FLERR,"PE compute ID for fix grem does not exist"); pe = modify->compute[icompute]; int ifix = modify->find_fix(id_nh); if (ifix < 0) error->all(FLERR,"Fix id for nvt or npt fix does not exist"); Fix *nh = modify->fix[ifix]; double *t_start = (double *)nh->extract("t_start",ifix); double *t_stop = (double *)nh->extract("t_stop",ifix); if ((t_start != NULL) && (t_stop != NULL) && (ifix == 0)) { tbath = *t_start; if (*t_start != *t_stop) error->all(FLERR,"Thermostat temperature ramp not allowed"); } else error->all(FLERR,"Problem extracting target temperature from fix nvt or npt"); pressref = 0.0; if (pressflag) { int *p_flag = (int *)nh->extract("p_flag",ifix); double *p_start = (double *) nh->extract("p_start",ifix); double *p_stop = (double *) nh->extract("p_stop",ifix); if ((p_flag != NULL) && (p_start != NULL) && (p_stop != NULL) && (ifix == 1)) { ifix = 0; pressref = p_start[0]; if ((p_start[0] != p_stop[0]) || (p_flag[0] != 1)) ++ ifix; if ((p_start[1] != p_stop[1]) || (p_flag[0] != 1)) ++ ifix; if ((p_start[2] != p_stop[2]) || (p_flag[0] != 1)) ++ ifix; if ((p_start[0] != p_start[1]) || (p_start[1] != p_start[2])) ++ifix; if ((p_flag[3] != 0) || (p_flag[4] != 0) || (p_flag[5] != 0)) ++ifix; if (ifix > 0) error->all(FLERR,"Unsupported pressure settings in fix npt"); } else error->all(FLERR,"Problem extracting target pressure from fix npt"); } }
int Properties::max_type() { // loop over all particles to check how many atom types are present mintype = 100000; maxtype = 1; for (int i=0;i<atom->nlocal;i++) { if (atom->type[i]<mintype) mintype=atom->type[i]; if (atom->type[i]>maxtype) maxtype=atom->type[i]; } // check all fixes // such as fix insert, fix change/type, fix wall, fix pour for(int i=0;i<modify->nfix;i++) { // checks Fix *fix = modify->fix[i]; if(fix->min_type() > 0 && fix->min_type() < mintype) mintype = fix->min_type(); if(fix->max_type() > 0 && fix->max_type() > maxtype) maxtype = fix->max_type(); } //Get min/max from other procs int mintype_all,maxtype_all; MPI_Allreduce(&mintype,&mintype_all, 1, MPI_INT, MPI_MIN, world); MPI_Allreduce(&maxtype,&maxtype_all, 1, MPI_INT, MPI_MAX, world); mintype = mintype_all; maxtype = maxtype_all; //error check if(mintype != 1) error->all(FLERR,"Atom types must start from 1 for granular simulations"); if(maxtype > atom->ntypes) error->all(FLERR,"Please increase the number of atom types in the 'create_box' command to match the number of atom types you use in the simulation"); return maxtype; }
int FixAppendAtoms::get_spatial() { if (update->ntimestep % freq == 0) { int ifix = modify->find_fix(spatialid); if (ifix < 0) error->all(FLERR,"Fix ID for fix ave/spatial does not exist"); Fix *fix = modify->fix[ifix]; int failed = 0; int count = 0; while (failed < 2) { double tmp = fix->compute_vector(2*count); if (tmp == 0.0) failed++; else failed = 0; count++; } double *pos = new double[count-2]; double *val = new double[count-2]; for (int loop=0; loop < count-2; loop++) { pos[loop] = fix->compute_vector(2*loop); val[loop] = fix->compute_vector(2*loop+1); } // always ignore the first and last double binsize = 2.0; double min_energy=0.0; double max_energy=0.0; int header = static_cast<int> (size / binsize); advance = 0; for (int loop=1; loop <= header; loop++) { max_energy += val[loop]; } for (int loop=count-2-2*header; loop <=count-3-header; loop++) { min_energy += val[loop]; } max_energy /= header; min_energy /= header; double shockfront_min = 0.0; double shockfront_max = 0.0; double shockfront_loc = 0.0; int front_found1 = 0; for (int loop=count-3-header; loop > header; loop--) { if (front_found1 == 1) continue; if (val[loop] > min_energy + 0.1*(max_energy - min_energy)) { shockfront_max = pos[loop]; front_found1=1; } } int front_found2 = 0; for (int loop=header+1; loop <=count-3-header; loop++) { if (val[loop] > min_energy + 0.6*(max_energy - min_energy)) { shockfront_min = pos[loop]; front_found2=1; } } if (front_found1 + front_found2 == 0) shockfront_loc = 0.0; else if (front_found1 + front_found2 == 1) shockfront_loc = shockfront_max + shockfront_min; else if (front_found1 == 1 && front_found2 == 1 && shockfront_max-shockfront_min > spatlead/2.0) shockfront_loc = shockfront_max; else shockfront_loc = (shockfront_max + shockfront_min) / 2.0; if (comm->me == 0) printf("SHOCK: %g %g %g %g %g\n", shockfront_loc, shockfront_min, shockfront_max, domain->boxlo[2], domain->boxhi[2]); if (domain->boxhi[2] - shockfront_loc < spatlead) advance = 1; delete [] pos; delete [] val; } advance_sum = 0; MPI_Allreduce(&advance,&advance_sum,1,MPI_INT,MPI_SUM,world); if (advance_sum > 0) return 1; else return 0; }
void CreateAtoms::command(int narg, char **arg) { if (domain->box_exist == 0) error->all(FLERR,"Create_atoms command before simulation box is defined"); if (modify->nfix_restart_peratom) error->all(FLERR,"Cannot create_atoms after " "reading restart file with per-atom info"); // parse arguments if (narg < 2) error->all(FLERR,"Illegal create_atoms command"); itype = force->inumeric(FLERR,arg[0]); if (itype <= 0 || itype > atom->ntypes) error->all(FLERR,"Invalid atom type in create_atoms command"); int iarg = 0; if (strcmp(arg[1],"box") == 0) { style = BOX; iarg = 2; } else if (strcmp(arg[1],"region") == 0) { style = REGION; if (narg < 3) error->all(FLERR,"Illegal create_atoms command"); nregion = domain->find_region(arg[2]); if (nregion == -1) error->all(FLERR, "Create_atoms region ID does not exist"); domain->regions[nregion]->init(); iarg = 3;; } else if (strcmp(arg[1],"single") == 0) { style = SINGLE; if (narg < 5) error->all(FLERR,"Illegal create_atoms command"); xone[0] = force->numeric(FLERR,arg[2]); xone[1] = force->numeric(FLERR,arg[3]); xone[2] = force->numeric(FLERR,arg[4]); iarg = 5; } else if (strcmp(arg[1],"random") == 0) { style = RANDOM; if (narg < 5) error->all(FLERR,"Illegal create_atoms command"); nrandom = force->inumeric(FLERR,arg[2]); seed = force->inumeric(FLERR,arg[3]); if (strcmp(arg[4],"NULL") == 0) nregion = -1; else { nregion = domain->find_region(arg[4]); if (nregion == -1) error->all(FLERR, "Create_atoms region ID does not exist"); domain->regions[nregion]->init(); } iarg = 5; } else error->all(FLERR,"Illegal create_atoms command"); // process optional keywords int scaleflag = 1; remapflag = 0; nbasis = domain->lattice->nbasis; basistype = new int[nbasis]; for (int i = 0; i < nbasis; i++) basistype[i] = itype; while (iarg < narg) { if (strcmp(arg[iarg],"basis") == 0) { if (iarg+3 > narg) error->all(FLERR,"Illegal create_atoms command"); int ibasis = force->inumeric(FLERR,arg[iarg+1]); itype = force->inumeric(FLERR,arg[iarg+2]); if (ibasis <= 0 || ibasis > nbasis || itype <= 0 || itype > atom->ntypes) error->all(FLERR,"Invalid basis setting in create_atoms command"); basistype[ibasis-1] = itype; iarg += 3; } else if (strcmp(arg[iarg],"remap") == 0) { if (iarg+2 > narg) error->all(FLERR,"Illegal create_atoms command"); if (strcmp(arg[iarg+1],"yes") == 0) remapflag = 1; else if (strcmp(arg[iarg+1],"no") == 0) remapflag = 0; else error->all(FLERR,"Illegal create_atoms command"); iarg += 2; } else if (strcmp(arg[iarg],"units") == 0) { if (iarg+2 > narg) error->all(FLERR,"Illegal create_atoms command"); if (strcmp(arg[iarg+1],"box") == 0) scaleflag = 0; else if (strcmp(arg[iarg+1],"lattice") == 0) scaleflag = 1; else error->all(FLERR,"Illegal create_atoms command"); iarg += 2; } else error->all(FLERR,"Illegal create_atoms command"); } // error checks if (style == RANDOM) { if (nrandom < 0) error->all(FLERR,"Illegal create_atoms command"); if (seed <= 0) error->all(FLERR,"Illegal create_atoms command"); } // demand non-none lattice be defined for BOX and REGION // else setup scaling for SINGLE and RANDOM // could use domain->lattice->lattice2box() to do conversion of // lattice to box, but not consistent with other uses of units=lattice // triclinic remapping occurs in add_single() if (style == BOX || style == REGION) { if (nbasis == 0) error->all(FLERR,"Cannot create atoms with undefined lattice"); } else if (scaleflag == 1) { xone[0] *= domain->lattice->xlattice; xone[1] *= domain->lattice->ylattice; xone[2] *= domain->lattice->zlattice; } // set bounds for my proc in sublo[3] & subhi[3] // if periodic and style = BOX or REGION, i.e. using lattice: // should create exactly 1 atom when 2 images are both "on" the boundary // either image may be slightly inside/outside true box due to round-off // if I am lo proc, decrement lower bound by EPSILON // this will insure lo image is created // if I am hi proc, decrement upper bound by 2.0*EPSILON // this will insure hi image is not created // thus insertion box is EPSILON smaller than true box // and is shifted away from true boundary // which is where atoms are likely to be generated triclinic = domain->triclinic; double epsilon[3]; if (triclinic) epsilon[0] = epsilon[1] = epsilon[2] = EPSILON; else { epsilon[0] = domain->prd[0] * EPSILON; epsilon[1] = domain->prd[1] * EPSILON; epsilon[2] = domain->prd[2] * EPSILON; } if (triclinic == 0) { sublo[0] = domain->sublo[0]; subhi[0] = domain->subhi[0]; sublo[1] = domain->sublo[1]; subhi[1] = domain->subhi[1]; sublo[2] = domain->sublo[2]; subhi[2] = domain->subhi[2]; } else { sublo[0] = domain->sublo_lamda[0]; subhi[0] = domain->subhi_lamda[0]; sublo[1] = domain->sublo_lamda[1]; subhi[1] = domain->subhi_lamda[1]; sublo[2] = domain->sublo_lamda[2]; subhi[2] = domain->subhi_lamda[2]; } if (style == BOX || style == REGION) { if (domain->xperiodic) { if (comm->myloc[0] == 0) sublo[0] -= epsilon[0]; if (comm->myloc[0] == comm->procgrid[0]-1) subhi[0] -= 2.0*epsilon[0]; } if (domain->yperiodic) { if (comm->myloc[1] == 0) sublo[1] -= epsilon[1]; if (comm->myloc[1] == comm->procgrid[1]-1) subhi[1] -= 2.0*epsilon[1]; } if (domain->zperiodic) { if (comm->myloc[2] == 0) sublo[2] -= epsilon[2]; if (comm->myloc[2] == comm->procgrid[2]-1) subhi[2] -= 2.0*epsilon[2]; } } // add atoms in one of 3 ways bigint natoms_previous = atom->natoms; int nlocal_previous = atom->nlocal; if (style == SINGLE) add_single(); else if (style == RANDOM) add_random(); else add_lattice(); // invoke set_arrays() for fixes that need initialization of new atoms int nlocal = atom->nlocal; for (int m = 0; m < modify->nfix; m++) { Fix *fix = modify->fix[m]; if (fix->create_attribute) { fix->pre_set_arrays(); for (int i = nlocal_previous; i < nlocal; i++) fix->set_arrays(i); } } // clean up if (domain->lattice) delete [] basistype; // new total # of atoms bigint nblocal = atom->nlocal; MPI_Allreduce(&nblocal,&atom->natoms,1,MPI_LMP_BIGINT,MPI_SUM,world); if (atom->natoms < 0 || atom->natoms > MAXBIGINT) error->all(FLERR,"Too many total atoms"); // print status if (comm->me == 0) { if (screen) fprintf(screen,"Created " BIGINT_FORMAT " atoms\n", atom->natoms-natoms_previous); if (logfile) fprintf(logfile,"Created " BIGINT_FORMAT " atoms\n", atom->natoms-natoms_previous); } // reset simulation now that more atoms are defined // add tags for newly created atoms if possible // if global map exists, reset it // change these to MAXTAGINT when allow tagint = bigint if (atom->natoms > MAXSMALLINT) { if (comm->me == 0) error->warning(FLERR,"Total atom count exceeds ID limit, " "atoms will not have individual IDs"); atom->tag_enable = 0; } if (atom->natoms <= MAXSMALLINT) atom->tag_extend(); if (atom->map_style) { atom->nghost = 0; atom->map_init(); atom->map_set(); } // if a molecular system, set nspecial to 0 for new atoms // NOTE: 31May12, don't think this is needed, avec->create_atom() does it //if (atom->molecular) { // int **nspecial = atom->nspecial; // for (int i = nlocal_previous; i < atom->nlocal; i++) { // nspecial[i][0] = 0; // nspecial[i][1] = 0; // nspecial[i][2] = 0; // } //} // error checks on coarsegraining if(force->cg_active()) error->cg(FLERR,"create_atoms"); }
FixGrem::FixGrem(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg) { if (narg < 7) error->all(FLERR,"Illegal fix grem command"); scalar_flag = 1; vector_flag = 1; size_vector = 3; global_freq = 1; extscalar = 1; extvector = 1; scale_grem = 1.0; // tbath - temp of bath, the same as defined in thermostat lambda = force->numeric(FLERR,arg[3]); eta = force->numeric(FLERR,arg[4]); h0 = force->numeric(FLERR,arg[5]); int n = strlen(arg[6])+1; id_nh = new char[n]; strcpy(id_nh,arg[6]); // create a new compute temp style // id = fix-ID + temp // compute group = all since pressure is always global (group all) // and thus its KE/temperature contribution should use group all n = strlen(id) + 6; id_temp = new char[n]; strcpy(id_temp,id); strcat(id_temp,"_temp"); char **newarg = new char*[3]; newarg[0] = id_temp; newarg[1] = (char *) "all"; newarg[2] = (char *) "temp"; modify->add_compute(3,newarg); delete [] newarg; // create a new compute pressure style // id = fix-ID + press, compute group = all // pass id_temp as 4th arg to pressure constructor n = strlen(id) + 7; id_press = new char[n]; strcpy(id_press,id); strcat(id_press,"_press"); newarg = new char*[5]; newarg[0] = id_press; newarg[1] = (char *) "all"; newarg[2] = (char *) "PRESSURE/GREM"; newarg[3] = id_temp; newarg[4] = id; modify->add_compute(5,newarg); delete [] newarg; // create a new compute ke style // id = fix-ID + ke n = strlen(id) + 8; id_ke = new char[n]; strcpy(id_ke,id); strcat(id_ke,"_ke"); newarg = new char*[3]; newarg[0] = id_ke; newarg[1] = (char *) "all"; newarg[2] = (char *) "ke"; modify->add_compute(3,newarg); delete [] newarg; // create a new compute pe style // id = fix-ID + pe n = strlen(id) + 9; id_pe = new char[n]; strcpy(id_pe,id); strcat(id_pe,"_pe"); newarg = new char*[3]; newarg[0] = id_pe; newarg[1] = (char *) "all"; newarg[2] = (char *) "pe"; modify->add_compute(3,newarg); delete [] newarg; int ifix = modify->find_fix(id_nh); if (ifix < 0) error->all(FLERR,"Fix id for nvt or npt fix does not exist"); Fix *nh = modify->fix[ifix]; pressflag = 0; int *p_flag = (int *)nh->extract("p_flag",ifix); if ((p_flag == NULL) || (ifix != 1) || (p_flag[0] == 0) || (p_flag[1] == 0) || (p_flag[2] == 0)) { pressflag = 0; } else if ((p_flag[0] == 1) && (p_flag[1] == 1) && (p_flag[2] == 1) && (ifix == 1)) { pressflag = 1; char *modargs[2]; modargs[0] = (char *) "press"; modargs[1] = id_press; nh->modify_param(2,modargs); } }
void FixAveTime::invoke_vector(bigint ntimestep) { int i,j,m; // zero if first step if (irepeat == 0) for (i = 0; i < nrows; i++) for (j = 0; j < nvalues; j++) array[i][j] = 0.0; // accumulate results of computes,fixes,variables to local copy // compute/fix/variable may invoke computes so wrap with clear/add modify->clearstep_compute(); for (j = 0; j < nvalues; j++) { m = value2index[j]; // invoke compute if not previously invoked if (which[j] == COMPUTE) { Compute *compute = modify->compute[m]; if (argindex[j] == 0) { if (!(compute->invoked_flag & INVOKED_VECTOR)) { compute->compute_vector(); compute->invoked_flag |= INVOKED_VECTOR; } double *cvector = compute->vector; for (i = 0; i < nrows; i++) column[i] = cvector[i]; } else { if (!(compute->invoked_flag & INVOKED_ARRAY)) { compute->compute_array(); compute->invoked_flag |= INVOKED_ARRAY; } double **carray = compute->array; int icol = argindex[j]-1; for (i = 0; i < nrows; i++) column[i] = carray[i][icol]; } // access fix fields, guaranteed to be ready } else if (which[j] == FIX) { Fix *fix = modify->fix[m]; if (argindex[j] == 0) for (i = 0; i < nrows; i++) column[i] = fix->compute_vector(i); else { int icol = argindex[j]-1; for (i = 0; i < nrows; i++) column[i] = fix->compute_array(i,icol); } } // add columns of values to array or just set directly if offcol is set if (offcol[j]) { for (i = 0; i < nrows; i++) array[i][j] = column[i]; } else { for (i = 0; i < nrows; i++) array[i][j] += column[i]; } } // done if irepeat < nrepeat // else reset irepeat and nvalid irepeat++; if (irepeat < nrepeat) { nvalid += nevery; modify->addstep_compute(nvalid); return; } irepeat = 0; nvalid = ntimestep+nfreq - (nrepeat-1)*nevery; modify->addstep_compute(nvalid); // average the final result for the Nfreq timestep double repeat = nrepeat; for (i = 0; i < nrows; i++) for (j = 0; j < nvalues; j++) if (offcol[j] == 0) array[i][j] /= repeat; // if ave = ONE, only single Nfreq timestep value is needed // if ave = RUNNING, combine with all previous Nfreq timestep values // if ave = WINDOW, combine with nwindow most recent Nfreq timestep values if (ntimestep >= startstep) { if (ave == ONE) { for (i = 0; i < nrows; i++) for (j = 0; j < nvalues; j++) array_total[i][j] = array[i][j]; norm = 1; } else if (ave == RUNNING) { for (i = 0; i < nrows; i++) for (j = 0; j < nvalues; j++) array_total[i][j] += array[i][j]; norm++; } else if (ave == WINDOW) { for (i = 0; i < nrows; i++) for (j = 0; j < nvalues; j++) { array_total[i][j] += array[i][j]; if (window_limit) array_total[i][j] -= array_list[iwindow][i][j]; array_list[iwindow][i][j] = array[i][j]; } iwindow++; if (iwindow == nwindow) { iwindow = 0; window_limit = 1; } if (window_limit) norm = nwindow; else norm = iwindow; } } // insure any columns with offcol set are effectively set to last value for (i = 0; i < nrows; i++) for (j = 0; j < nvalues; j++) if (offcol[j]) array_total[i][j] = norm*array[i][j]; // output result to file if (fp && me == 0) { fprintf(fp,BIGINT_FORMAT " %d\n",ntimestep,nrows); for (i = 0; i < nrows; i++) { fprintf(fp,"%d",i+1); for (j = 0; j < nvalues; j++) fprintf(fp," %g",array_total[i][j]/norm); fprintf(fp,"\n"); } fflush(fp); } }
void ComputeChunkSpreadAtom::compute_peratom() { invoked_peratom = update->ntimestep; // grow local vector_atom or array_atom if necessary if (atom->nmax > nmax) { if (nvalues == 1) { memory->destroy(vector_atom); nmax = atom->nmax; memory->create(vector_atom,nmax,"chunk/spread/atom:vector_atom"); } else { memory->destroy(array_atom); nmax = atom->nmax; memory->create(array_atom,nmax,nvalues,"chunk/spread/atom:array_atom"); } } // compute chunk/atom assigns atoms to chunk IDs // extract ichunk index vector from compute // ichunk = 1 to Nchunk for included atoms, 0 for excluded atoms int nchunk = cchunk->setup_chunks(); cchunk->compute_ichunk(); int *ichunk = cchunk->ichunk; // loop over values, access compute or fix // loop over atoms, use chunk ID of each atom to store value from compute/fix int *mask = atom->mask; int nlocal = atom->nlocal; int i,m,n,index,nstride; double *ptr; for (m = 0; m < nvalues; m++) { n = value2index[m]; // copy compute/fix values into vector_atom or array_atom // nstride between values for each atom if (nvalues == 1) { ptr = vector_atom; nstride = 1; } else { ptr = &array_atom[0][m]; nstride = nvalues; } // invoke compute if not previously invoked if (which[m] == COMPUTE) { Compute *compute = modify->compute[n]; if (argindex[m] == 0) { if (!(compute->invoked_flag & INVOKED_VECTOR)) { compute->compute_vector(); compute->invoked_flag |= INVOKED_VECTOR; } double *cvector = compute->vector; for (i = 0; i < nlocal; i++, ptr += nstride) { *ptr = 0.0; if (!(mask[i] & groupbit)) continue; index = ichunk[i]-1; if (index < 0 || index >= nchunk) continue; *ptr = cvector[index]; } } else { if (!(compute->invoked_flag & INVOKED_ARRAY)) { compute->compute_array(); compute->invoked_flag |= INVOKED_ARRAY; } int icol = argindex[m]-1; double **carray = compute->array; for (i = 0; i < nlocal; i++, ptr += nstride) { *ptr = 0.0; if (!(mask[i] & groupbit)) continue; index = ichunk[i]-1; if (index < 0 || index >= nchunk) continue; *ptr = carray[index][icol]; } } // access fix data, check if fix frequency is a match // are assuming the fix global vector/array is per-chunk data // check if index exceeds fix output length/rows } else if (which[m] == FIX) { Fix *fix = modify->fix[n]; if (update->ntimestep % fix->global_freq) error->all(FLERR,"Fix used in compute chunk/spread/atom not " "computed at compatible time"); if (argindex[m] == 0) { int nfix = fix->size_vector; for (i = 0; i < nlocal; i++, ptr += nstride) { *ptr = 0.0; if (!(mask[i] & groupbit)) continue; index = ichunk[i]-1; if (index < 0 || index >= nchunk || index >= nfix) continue; *ptr = fix->compute_vector(index); } } else { int icol = argindex[m]-1; int nfix = fix->size_array_rows; for (i = 0; i < nlocal; i++, ptr += nstride) { *ptr = 0.0; if (!(mask[i] & groupbit)) continue; index = ichunk[i]-1; if (index < 0 || index >= nchunk || index >= nfix) continue; *ptr = fix->compute_array(index,icol); } } } } }
Fix operator*(const int x, const Fix &y) { return Fix(x * y.get_re(), y.get_shift(), 0, 0); }
Fix operator/(const int x, const Fix &y) { return Fix(x / y.get_re(), -y.get_shift(), 0, 0); }
void FixAveTime::invoke_vector(bigint ntimestep) { int i,j,m; // first sample within single Nfreq epoch // zero out arrays that accumulate over many samples, but not across epochs // invoke setup_chunks() to determine current nchunk // re-allocate per-chunk arrays if needed // invoke lock() in two cases: // if nrepeat > 1: so nchunk cannot change until Nfreq epoch is over, // will be unlocked on last repeat of this Nfreq // if ave = RUNNING/WINDOW and not yet locked: // set forever, will be unlocked in fix destructor // wrap setup_chunks in clearstep/addstep b/c it may invoke computes // both nevery and nfreq are future steps, // since call below to cchunk->ichunk() // does not re-invoke internal cchunk compute on this same step if (irepeat == 0) { if (any_variable_length) { modify->clearstep_compute(); int nrows_new = column_length(1); modify->addstep_compute(ntimestep+nevery); modify->addstep_compute(ntimestep+nfreq); if (all_variable_length && nrows_new != nrows) { nrows = nrows_new; memory->destroy(column); memory->create(column,nrows,"ave/time:column"); allocate_arrays(); } bigint ntimestep = update->ntimestep; int lockforever_flag = 0; for (i = 0; i < nvalues; i++) { if (!varlen[i]) continue; if (nrepeat > 1 && ave == ONE) { Compute *compute = modify->compute[value2index[i]]; compute->lock(this,ntimestep,ntimestep+(nrepeat-1)*nevery); } else if ((ave == RUNNING || ave == WINDOW) && !lockforever) { Compute *compute = modify->compute[value2index[i]]; compute->lock(this,update->ntimestep,-1); lockforever_flag = 1; } } if (lockforever_flag) lockforever = 1; } for (i = 0; i < nrows; i++) for (j = 0; j < nvalues; j++) array[i][j] = 0.0; } // accumulate results of computes,fixes,variables to local copy // compute/fix/variable may invoke computes so wrap with clear/add modify->clearstep_compute(); for (j = 0; j < nvalues; j++) { m = value2index[j]; // invoke compute if not previously invoked if (which[j] == COMPUTE) { Compute *compute = modify->compute[m]; if (argindex[j] == 0) { if (!(compute->invoked_flag & INVOKED_VECTOR)) { compute->compute_vector(); compute->invoked_flag |= INVOKED_VECTOR; } double *cvector = compute->vector; for (i = 0; i < nrows; i++) column[i] = cvector[i]; } else { if (!(compute->invoked_flag & INVOKED_ARRAY)) { compute->compute_array(); compute->invoked_flag |= INVOKED_ARRAY; } double **carray = compute->array; int icol = argindex[j]-1; for (i = 0; i < nrows; i++) column[i] = carray[i][icol]; } // access fix fields, guaranteed to be ready } else if (which[j] == FIX) { Fix *fix = modify->fix[m]; if (argindex[j] == 0) for (i = 0; i < nrows; i++) column[i] = fix->compute_vector(i); else { int icol = argindex[j]-1; for (i = 0; i < nrows; i++) column[i] = fix->compute_array(i,icol); } } // add columns of values to array or just set directly if offcol is set if (offcol[j]) { for (i = 0; i < nrows; i++) array[i][j] = column[i]; } else { for (i = 0; i < nrows; i++) array[i][j] += column[i]; } } // done if irepeat < nrepeat // else reset irepeat and nvalid irepeat++; if (irepeat < nrepeat) { nvalid += nevery; modify->addstep_compute(nvalid); return; } irepeat = 0; nvalid = ntimestep+nfreq - (nrepeat-1)*nevery; modify->addstep_compute(nvalid); // unlock any variable length computes at end of Nfreq epoch // do not unlock if ave = RUNNING or WINDOW if (any_variable_length && nrepeat > 1 && ave == ONE) { for (i = 0; i < nvalues; i++) { if (!varlen[i]) continue; Compute *compute = modify->compute[value2index[i]]; compute->unlock(this); } } // average the final result for the Nfreq timestep double repeat = nrepeat; for (i = 0; i < nrows; i++) for (j = 0; j < nvalues; j++) if (offcol[j] == 0) array[i][j] /= repeat; // if ave = ONE, only single Nfreq timestep value is needed // if ave = RUNNING, combine with all previous Nfreq timestep values // if ave = WINDOW, combine with nwindow most recent Nfreq timestep values if (ave == ONE) { for (i = 0; i < nrows; i++) for (j = 0; j < nvalues; j++) array_total[i][j] = array[i][j]; norm = 1; } else if (ave == RUNNING) { for (i = 0; i < nrows; i++) for (j = 0; j < nvalues; j++) array_total[i][j] += array[i][j]; norm++; } else if (ave == WINDOW) { for (i = 0; i < nrows; i++) for (j = 0; j < nvalues; j++) { array_total[i][j] += array[i][j]; if (window_limit) array_total[i][j] -= array_list[iwindow][i][j]; array_list[iwindow][i][j] = array[i][j]; } iwindow++; if (iwindow == nwindow) { iwindow = 0; window_limit = 1; } if (window_limit) norm = nwindow; else norm = iwindow; } // insure any columns with offcol set are effectively set to last value for (i = 0; i < nrows; i++) for (j = 0; j < nvalues; j++) if (offcol[j]) array_total[i][j] = norm*array[i][j]; // output result to file if (fp && me == 0) { if (overwrite) fseek(fp,filepos,SEEK_SET); fprintf(fp,BIGINT_FORMAT " %d\n",ntimestep,nrows); for (i = 0; i < nrows; i++) { fprintf(fp,"%d",i+1); for (j = 0; j < nvalues; j++) fprintf(fp,format,array_total[i][j]/norm); fprintf(fp,"\n"); } fflush(fp); if (overwrite) { long fileend = ftell(fp); if (fileend > 0) ftruncate(fileno(fp),fileend); } } }
Fix operator-(const Fix &x, const int y) { return Fix(x.get_re() - y, assert_shifts(x, y), 0, 0); }
Fix operator/(const Fix &x, const int y) { return Fix(x.get_re() / y, x.get_shift(), 0, 0); }
Fix operator+(const int x, const Fix &y) { return Fix(x + y.get_re(), assert_shifts(y, x), 0, 0); }
void FixAveHisto::end_of_step() { int i,j,m; // skip if not step which requires doing something // error check if timestep was reset in an invalid manner bigint ntimestep = update->ntimestep; if (ntimestep < nvalid_last || ntimestep > nvalid) error->all(FLERR,"Invalid timestep reset for fix ave/histo"); if (ntimestep != nvalid) return; nvalid_last = nvalid; // zero if first step if (irepeat == 0) { stats[0] = stats[1] = 0.0; stats[2] = BIG; stats[3] = -BIG; for (i = 0; i < nbins; i++) bin[i] = 0.0; } // accumulate results of computes,fixes,variables to local copy // compute/fix/variable may invoke computes so wrap with clear/add modify->clearstep_compute(); for (i = 0; i < nvalues; i++) { m = value2index[i]; j = argindex[i]; // atom attributes if (which[i] == X) bin_atoms(&atom->x[0][j],3); else if (which[i] == V) bin_atoms(&atom->v[0][j],3); else if (which[i] == F) bin_atoms(&atom->f[0][j],3); // invoke compute if not previously invoked if (which[i] == COMPUTE) { Compute *compute = modify->compute[m]; if (kind == GLOBAL && mode == SCALAR) { if (j == 0) { if (!(compute->invoked_flag & INVOKED_SCALAR)) { compute->compute_scalar(); compute->invoked_flag |= INVOKED_SCALAR; } bin_one(compute->scalar); } else { if (!(compute->invoked_flag & INVOKED_VECTOR)) { compute->compute_vector(); compute->invoked_flag |= INVOKED_VECTOR; } bin_one(compute->vector[j-1]); } } else if (kind == GLOBAL && mode == VECTOR) { if (j == 0) { if (!(compute->invoked_flag & INVOKED_VECTOR)) { compute->compute_vector(); compute->invoked_flag |= INVOKED_VECTOR; } bin_vector(compute->size_vector,compute->vector,1); } else { if (!(compute->invoked_flag & INVOKED_ARRAY)) { compute->compute_array(); compute->invoked_flag |= INVOKED_ARRAY; } if (compute->array) bin_vector(compute->size_array_rows,&compute->array[0][j-1], compute->size_array_cols); } } else if (kind == PERATOM) { if (!(compute->invoked_flag & INVOKED_PERATOM)) { compute->compute_peratom(); compute->invoked_flag |= INVOKED_PERATOM; } if (j == 0) bin_atoms(compute->vector_atom,1); else if (compute->array_atom) bin_atoms(&compute->array_atom[0][j-1],compute->size_peratom_cols); } else if (kind == LOCAL) { if (!(compute->invoked_flag & INVOKED_LOCAL)) { compute->compute_local(); compute->invoked_flag |= INVOKED_LOCAL; } if (j == 0) bin_vector(compute->size_local_rows,compute->vector_local,1); else if (compute->array_local) bin_vector(compute->size_local_rows,&compute->array_local[0][j-1], compute->size_local_cols); } // access fix fields, guaranteed to be ready } else if (which[i] == FIX) { Fix *fix = modify->fix[m]; if (kind == GLOBAL && mode == SCALAR) { if (j == 0) bin_one(fix->compute_scalar()); else bin_one(fix->compute_vector(j-1)); } else if (kind == GLOBAL && mode == VECTOR) { if (j == 0) { int n = fix->size_vector; for (i = 0; i < n; i++) bin_one(fix->compute_vector(i)); } else { int n = fix->size_vector; for (i = 0; i < n; i++) bin_one(fix->compute_array(i,j-1)); } } else if (kind == PERATOM) { if (j == 0) bin_atoms(fix->vector_atom,1); else if (fix->array_atom) bin_atoms(fix->array_atom[j-1],fix->size_peratom_cols); } else if (kind == LOCAL) { if (j == 0) bin_vector(fix->size_local_rows,fix->vector_local,1); else if (fix->array_local) bin_vector(fix->size_local_rows,&fix->array_local[0][j-1], fix->size_local_cols); } // evaluate equal-style variable } else if (which[i] == VARIABLE && kind == GLOBAL) { bin_one(input->variable->compute_equal(m)); } else if (which[i] == VARIABLE && kind == PERATOM) { if (atom->nlocal > maxatom) { memory->destroy(vector); maxatom = atom->nmax; memory->create(vector,maxatom,"ave/histo:vector"); } input->variable->compute_atom(m,igroup,vector,1,0); bin_atoms(vector,1); } } // done if irepeat < nrepeat // else reset irepeat and nvalid irepeat++; if (irepeat < nrepeat) { nvalid += nevery; modify->addstep_compute(nvalid); return; } irepeat = 0; nvalid = ntimestep + nfreq - (nrepeat-1)*nevery; modify->addstep_compute(nvalid); // merge histogram stats across procs if necessary if (kind == PERATOM || kind == LOCAL) { MPI_Allreduce(stats,stats_all,2,MPI_DOUBLE,MPI_SUM,world); MPI_Allreduce(&stats[2],&stats_all[2],1,MPI_DOUBLE,MPI_MIN,world); MPI_Allreduce(&stats[3],&stats_all[3],1,MPI_DOUBLE,MPI_MAX,world); MPI_Allreduce(bin,bin_all,nbins,MPI_DOUBLE,MPI_SUM,world); stats[0] = stats_all[0]; stats[1] = stats_all[1]; stats[2] = stats_all[2]; stats[3] = stats_all[3]; for (i = 0; i < nbins; i++) bin[i] = bin_all[i]; } // if ave = ONE, only single Nfreq timestep value is needed // if ave = RUNNING, combine with all previous Nfreq timestep values // if ave = WINDOW, combine with nwindow most recent Nfreq timestep values if (ave == ONE) { stats_total[0] = stats[0]; stats_total[1] = stats[1]; stats_total[2] = stats[2]; stats_total[3] = stats[3]; for (i = 0; i < nbins; i++) bin_total[i] = bin[i]; } else if (ave == RUNNING) { stats_total[0] += stats[0]; stats_total[1] += stats[1]; stats_total[2] = MIN(stats_total[2],stats[2]); stats_total[3] = MAX(stats_total[3],stats[3]); for (i = 0; i < nbins; i++) bin_total[i] += bin[i]; } else if (ave == WINDOW) { stats_total[0] += stats[0]; if (window_limit) stats_total[0] -= stats_list[iwindow][0]; stats_list[iwindow][0] = stats[0]; stats_total[1] += stats[1]; if (window_limit) stats_total[1] -= stats_list[iwindow][1]; stats_list[iwindow][1] = stats[1]; if (window_limit) m = nwindow; else m = iwindow+1; stats_list[iwindow][2] = stats[2]; stats_total[2] = stats_list[0][2]; for (i = 1; i < m; i++) stats_total[2] = MIN(stats_total[2],stats_list[i][2]); stats_list[iwindow][3] = stats[3]; stats_total[3] = stats_list[0][3]; for (i = 1; i < m; i++) stats_total[3] = MAX(stats_total[3],stats_list[i][3]); for (i = 0; i < nbins; i++) { bin_total[i] += bin[i]; if (window_limit) bin_total[i] -= bin_list[iwindow][i]; bin_list[iwindow][i] = bin[i]; } iwindow++; if (iwindow == nwindow) { iwindow = 0; window_limit = 1; } } // output result to file if (fp && me == 0) { if (overwrite) fseek(fp,filepos,SEEK_SET); fprintf(fp,BIGINT_FORMAT " %d %g %g %g %g\n",ntimestep,nbins, stats_total[0],stats_total[1],stats_total[2],stats_total[3]); if (stats_total[0] != 0.0) for (i = 0; i < nbins; i++) fprintf(fp,"%d %g %g %g\n", i+1,coord[i],bin_total[i],bin_total[i]/stats_total[0]); else for (i = 0; i < nbins; i++) fprintf(fp,"%d %g %g %g\n",i+1,coord[i],0.0,0.0); fflush(fp); if (overwrite) { long fileend = ftell(fp); ftruncate(fileno(fp),fileend); } } }
int NeighborKokkos::init_lists_kokkos() { int i; for (i = 0; i < nlist_host; i++) delete lists_host[i]; delete [] lists_host; delete [] pair_build_host; delete [] stencil_create_host; nlist_host = 0; for (i = 0; i < nlist_device; i++) delete lists_device[i]; delete [] lists_device; delete [] pair_build_device; delete [] stencil_create_device; nlist_device = 0; nlist = 0; for (i = 0; i < nrequest; i++) { if (requests[i]->kokkos_device) nlist_device++; else if (requests[i]->kokkos_host) nlist_host++; else nlist++; } lists_host = new NeighListKokkos<LMPHostType>*[nrequest]; pair_build_host = new PairPtrHost[nrequest]; stencil_create_host = new StencilPtrHost[nrequest]; for (i = 0; i < nrequest; i++) { lists_host[i] = NULL; pair_build_host[i] = NULL; stencil_create_host[i] = NULL; } for (i = 0; i < nrequest; i++) { if (!requests[i]->kokkos_host) continue; lists_host[i] = new NeighListKokkos<LMPHostType>(lmp); lists_host[i]->index = i; lists_host[i]->dnum = requests[i]->dnum; if (requests[i]->pair) { Pair *pair = (Pair *) requests[i]->requestor; pair->init_list(requests[i]->id,lists_host[i]); } if (requests[i]->fix) { Fix *fix = (Fix *) requests[i]->requestor; fix->init_list(requests[i]->id,lists_host[i]); } } lists_device = new NeighListKokkos<LMPDeviceType>*[nrequest]; pair_build_device = new PairPtrDevice[nrequest]; stencil_create_device = new StencilPtrDevice[nrequest]; for (i = 0; i < nrequest; i++) { lists_device[i] = NULL; pair_build_device[i] = NULL; stencil_create_device[i] = NULL; } for (i = 0; i < nrequest; i++) { if (!requests[i]->kokkos_device) continue; lists_device[i] = new NeighListKokkos<LMPDeviceType>(lmp); lists_device[i]->index = i; lists_device[i]->dnum = requests[i]->dnum; if (requests[i]->pair) { Pair *pair = (Pair *) requests[i]->requestor; pair->init_list(requests[i]->id,lists_device[i]); } if (requests[i]->fix) { Fix *fix = (Fix *) requests[i]->requestor; fix->init_list(requests[i]->id,lists_device[i]); } } // 1st time allocation of xhold if (dist_check) xhold = DAT::tdual_x_array("neigh:xhold",maxhold); // return # of non-Kokkos lists return nlist; }