void option_menu(t_data *data, int selected_index)
{
t_bunny_position pos;
t_bunny_position size;
int margin;
margin = 20;
size = pos_(WIDTH / 2 - 60, 50);
size.y = (data->config->height - margin - (margin * 10)) / 10;
pos.x = WIDTH / 2 - size.x / 2 - 30;
pos.y = margin;
(selected_index == 0) ? (data->rect_opt[0] = label(data, true, size, pos)) :
(data->rect_opt[0] = label(data, false, size, pos));
check_box(data, data->config->fullscreen, data->rect_opt[0].pos);
size = pos_(WIDTH / 2, 50);
size.y = (data->config->height - margin - (margin * 10)) / 10;
pos.x = data->config->width / 2 - data->rect_opt[0].size.x / 2 - 30;
pos.y = data->rect_opt[0].pos.y + data->rect_opt[0].size.y + margin;
data->rect_opt[1] = label(data, false, size, pos);
pos.x = data->config->width / 2 - data->rect_opt[1].size.x / 2;
pos.y = data->rect_opt[1].pos.y + data->rect_opt[1].size.y + margin;
(selected_index == 1) ? (data->rect_opt[2] = label(data, true, size, pos)) :
(data->rect_opt[2] = label(data, false, size, pos));
option_menu_2(data, selected_index, pos, size);
}
void test_construction()
{
typedef typename bg::coordinate_type<P>::type T;
bg::model::box<P> b1 = bg::make_zero<bg::model::box<P> >();
check_box(b1, T(),T(),T(),T(),T(),T());
bg::model::box<P> b2(create_box<P>());
check_box(b2, 1,2,5,3,4,6);
bg::model::box<P> b3 = bg::make_inverse<bg::model::box<P> >();
check_box(b3, boost::numeric::bounds<T>::highest(),
boost::numeric::bounds<T>::highest(),
boost::numeric::bounds<T>::highest(),
boost::numeric::bounds<T>::lowest(),
boost::numeric::bounds<T>::lowest(),
boost::numeric::bounds<T>::lowest());
}
bool start(successfull result[ITEMS], box current_matrix)
{
box new_matrix = {};
planch working_planch, temp_planch;
for (int i = 0; i < ITEMS; i++) {
if (in_result(i, result)) continue;
for (int position = 0; position < 6; position++){
for (short level = 0; level < 2; level++) {
for (short uturn = 0; uturn < 2; uturn++) {
if (uturn) {
turn_upside_down(items[i], working_planch);
} else {
memcpy(working_planch, items[i], ITEMS_SIZE);
}
for (short can_turn = 0; can_turn < 2; can_turn++) {
if (can_turn) {
turn(working_planch, temp_planch);
memcpy(working_planch, temp_planch, ITEMS_SIZE);
}
++INDEX;
memcpy(new_matrix, current_matrix, MATRIX_SIZE);
add_planch(position, working_planch, new_matrix, level);
if (check_box(new_matrix)) {
successfull temp_result[ITEMS];
memcpy(temp_result, result, RESULT_SIZE);
temp_result[i].ready = true;
temp_result[i].position = position;
temp_result[i].item = i;
temp_result[i].turn = can_turn;
temp_result[i].turn_upside_down = uturn;
if (check_result(temp_result)) {
FOUND++;
show_solution(temp_result, new_matrix, FOUND);
return true;
}
start(temp_result, new_matrix);
}
}
}
}
}
}
return false;
}
void test_assignment()
{
bg::model::box<P> b(create_box<P>());
bg::set<0>(b.min_corner(), 10);
bg::set<1>(b.min_corner(), 20);
bg::set<2>(b.min_corner(), 30);
bg::set<0>(b.max_corner(), 40);
bg::set<1>(b.max_corner(), 50);
bg::set<2>(b.max_corner(), 60);
check_box(b, 10,20,30,40,50,60);
}
void LLWidgetReg::initClass(bool register_widgets)
{
// Only need to register if the Windows linker has optimized away the
// references to the object files.
if (register_widgets)
{
LLDefaultChildRegistry::Register<LLButton> button("button");
LLDefaultChildRegistry::Register<LLMenuButton> menu_button("menu_button");
LLDefaultChildRegistry::Register<LLCheckBoxCtrl> check_box("check_box");
LLDefaultChildRegistry::Register<LLComboBox> combo_box("combo_box");
LLDefaultChildRegistry::Register<LLFilterEditor> filter_editor("filter_editor");
LLDefaultChildRegistry::Register<LLFlyoutButton> flyout_button("flyout_button");
LLDefaultChildRegistry::Register<LLContainerView> container_view("container_view");
LLDefaultChildRegistry::Register<LLIconCtrl> icon("icon");
LLDefaultChildRegistry::Register<LLLoadingIndicator> loading_indicator("loading_indicator");
LLDefaultChildRegistry::Register<LLLineEditor> line_editor("line_editor");
LLDefaultChildRegistry::Register<LLMenuItemSeparatorGL> menu_item_separator("menu_item_separator");
LLDefaultChildRegistry::Register<LLMenuItemCallGL> menu_item_call_gl("menu_item_call");
LLDefaultChildRegistry::Register<LLMenuItemCheckGL> menu_item_check_gl("menu_item_check");
LLDefaultChildRegistry::Register<LLMenuGL> menu("menu");
LLDefaultChildRegistry::Register<LLMenuBarGL> menu_bar("menu_bar");
LLDefaultChildRegistry::Register<LLContextMenu> context_menu("context_menu");
LLDefaultChildRegistry::Register<LLMultiSlider> multi_slider_bar("multi_slider_bar");
LLDefaultChildRegistry::Register<LLMultiSliderCtrl> multi_slider("multi_slider");
LLDefaultChildRegistry::Register<LLPanel> panel("panel", &LLPanel::fromXML);
LLDefaultChildRegistry::Register<LLLayoutStack> layout_stack("layout_stack");
LLDefaultChildRegistry::Register<LLProgressBar> progress_bar("progress_bar");
LLDefaultChildRegistry::Register<LLRadioGroup> radio_group("radio_group");
LLDefaultChildRegistry::Register<LLSearchEditor> search_editor("search_editor");
LLDefaultChildRegistry::Register<LLScrollContainer> scroll_container("scroll_container");
LLDefaultChildRegistry::Register<LLScrollingPanelList> scrolling_panel_list("scrolling_panel_list");
LLDefaultChildRegistry::Register<LLScrollListCtrl> scroll_list("scroll_list");
LLDefaultChildRegistry::Register<LLSlider> slider_bar("slider_bar");
LLDefaultChildRegistry::Register<LLSliderCtrl> slider("slider");
LLDefaultChildRegistry::Register<LLSpinCtrl> spinner("spinner");
LLDefaultChildRegistry::Register<LLStatBar> stat_bar("stat_bar");
//LLDefaultChildRegistry::Register<LLPlaceHolderPanel> placeholder("placeholder");
LLDefaultChildRegistry::Register<LLTabContainer> tab_container("tab_container");
LLDefaultChildRegistry::Register<LLTextBox> text("text");
LLDefaultChildRegistry::Register<LLTimeCtrl> time("time");
LLDefaultChildRegistry::Register<LLTextEditor> simple_text_editor("simple_text_editor");
LLDefaultChildRegistry::Register<LLUICtrl> ui_ctrl("ui_ctrl");
LLDefaultChildRegistry::Register<LLStatView> stat_view("stat_view");
//LLDefaultChildRegistry::Register<LLUICtrlLocate> locate("locate");
//LLDefaultChildRegistry::Register<LLUICtrlLocate> pad("pad");
LLDefaultChildRegistry::Register<LLViewBorder> view_border("view_border");
}
// *HACK: Usually this is registered as a viewer text editor
LLDefaultChildRegistry::Register<LLTextEditor> text_editor("text_editor");
}
t_intersect get_intersect_ply(t_obj *obj, t_ray *ray)
{
t_intersect inter;
inter.dir = ray->dir;
inter.mat = obj->mat;
inter.dist = -1.0;
if (!obj->ply.ply || !check_box(obj, ray))
return (inter);
inter.obj = obj;
if (!obj->ply.ply)
return (inter);
inter.dir = ray->dir;
inter.mat = obj->mat;
node_intersect(obj->ply.node, ray, &inter);
inter.obj = obj;
return (inter);
}
static void solve(unsigned char (*field)[9]) {
int y, x, nr, found, number;
for (y=0; y<9; ++y) {
for (x=0; x<9; ++x) {
if(field[y][x] == 0) {
found=0;
for(nr=1; nr<10; ++nr) {
if(check_horizontal(field, y, nr) == FALSE) {
if(check_vertical(field, x, nr) == FALSE) {
if(check_box(field, y, x, nr) == FALSE) {
if(ADVANCED_MODE == TRUE) {
if (advanced_algo(field, y, x, nr) == TRUE){
field[y][x] = nr;
solve(field);
}
}
found++;
number = nr;
}
}
}
}
if(found == 1) {
field[y][x] = number;
solve(field);
}
}
}
}
}
t_intersect get_intersect_tore(t_obj *obj, t_ray *ray)
{
t_intersect inter;
t_vec3 u;
inter.dir = ray->dir;
inter.mat = obj->mat;
if (!check_box(obj, ray))
return (inter);
get_dist_tore(ray, &inter, obj);
if (inter.dist < 0.0 || inter.dist == NOT_A_SOLUTION)
{
inter.dist = -1.0;
return (inter);
}
inter.pos = add_vec3(mult_vec3(ray->dir, inter.dist), ray->pos);
u = sub_vec3(inter.pos, obj->pos);
u.z = 0.0;
u = mult_vec3(vec3_normalize(u), obj->torus.radius_hole);
u = add_vec3(u, obj->pos);
inter.norm = vec3_normalize(sub_vec3(inter.pos, u));
return (inter);
}
unsigned check_box3(const wstring& text, TriState value, FARDIALOGITEMFLAGS flags = 0) {
return check_box(text, value == triUndef ? BSTATE_3STATE : value == triTrue ? BSTATE_CHECKED : BSTATE_UNCHECKED, flags | DIF_3STATE);
}
int gmx_editconf(int argc, char *argv[])
{
const char
*desc[] =
{
"editconf converts generic structure format to [TT].gro[tt], [TT].g96[tt]",
"or [TT].pdb[tt].",
"[PAR]",
"The box can be modified with options [TT]-box[tt], [TT]-d[tt] and",
"[TT]-angles[tt]. Both [TT]-box[tt] and [TT]-d[tt]",
"will center the system in the box, unless [TT]-noc[tt] is used.",
"[PAR]",
"Option [TT]-bt[tt] determines the box type: [TT]triclinic[tt] is a",
"triclinic box, [TT]cubic[tt] is a rectangular box with all sides equal",
"[TT]dodecahedron[tt] represents a rhombic dodecahedron and",
"[TT]octahedron[tt] is a truncated octahedron.",
"The last two are special cases of a triclinic box.",
"The length of the three box vectors of the truncated octahedron is the",
"shortest distance between two opposite hexagons.",
"The volume of a dodecahedron is 0.71 and that of a truncated octahedron",
"is 0.77 of that of a cubic box with the same periodic image distance.",
"[PAR]",
"Option [TT]-box[tt] requires only",
"one value for a cubic box, dodecahedron and a truncated octahedron.",
"[PAR]",
"With [TT]-d[tt] and a [TT]triclinic[tt] box the size of the system in the x, y",
"and z directions is used. With [TT]-d[tt] and [TT]cubic[tt],",
"[TT]dodecahedron[tt] or [TT]octahedron[tt] boxes, the dimensions are set",
"to the diameter of the system (largest distance between atoms) plus twice",
"the specified distance.",
"[PAR]",
"Option [TT]-angles[tt] is only meaningful with option [TT]-box[tt] and",
"a triclinic box and can not be used with option [TT]-d[tt].",
"[PAR]",
"When [TT]-n[tt] or [TT]-ndef[tt] is set, a group",
"can be selected for calculating the size and the geometric center,",
"otherwise the whole system is used.",
"[PAR]",
"[TT]-rotate[tt] rotates the coordinates and velocities.",
"[PAR]",
"[TT]-princ[tt] aligns the principal axes of the system along the",
"coordinate axes, this may allow you to decrease the box volume,",
"but beware that molecules can rotate significantly in a nanosecond.",
"[PAR]",
"Scaling is applied before any of the other operations are",
"performed. Boxes and coordinates can be scaled to give a certain density (option",
"[TT]-density[tt]). Note that this may be inaccurate in case a gro",
"file is given as input. A special feature of the scaling option, when the",
"factor -1 is given in one dimension, one obtains a mirror image,",
"mirrored in one of the plains, when one uses -1 in three dimensions",
"a point-mirror image is obtained.[PAR]",
"Groups are selected after all operations have been applied.[PAR]",
"Periodicity can be removed in a crude manner.",
"It is important that the box sizes at the bottom of your input file",
"are correct when the periodicity is to be removed.",
"[PAR]",
"When writing [TT].pdb[tt] files, B-factors can be",
"added with the [TT]-bf[tt] option. B-factors are read",
"from a file with with following format: first line states number of",
"entries in the file, next lines state an index",
"followed by a B-factor. The B-factors will be attached per residue",
"unless an index is larger than the number of residues or unless the",
"[TT]-atom[tt] option is set. Obviously, any type of numeric data can",
"be added instead of B-factors. [TT]-legend[tt] will produce",
"a row of CA atoms with B-factors ranging from the minimum to the",
"maximum value found, effectively making a legend for viewing.",
"[PAR]",
"With the option -mead a special pdb (pqr) file for the MEAD electrostatics",
"program (Poisson-Boltzmann solver) can be made. A further prerequisite",
"is that the input file is a run input file.",
"The B-factor field is then filled with the Van der Waals radius",
"of the atoms while the occupancy field will hold the charge.",
"[PAR]",
"The option -grasp is similar, but it puts the charges in the B-factor",
"and the radius in the occupancy.",
"[PAR]",
"Option [TT]-align[tt] allows alignment",
"of the principal axis of a specified group against the given vector, ",
"with an optional center of rotation specified by [TT]-aligncenter[tt].",
"[PAR]",
"Finally with option [TT]-label[tt] editconf can add a chain identifier",
"to a pdb file, which can be useful for analysis with e.g. rasmol.",
"[PAR]",
"To convert a truncated octrahedron file produced by a package which uses",
"a cubic box with the corners cut off (such as Gromos) use:[BR]",
"[TT]editconf -f <in> -rotate 0 45 35.264 -bt o -box <veclen> -o <out>[tt][BR]",
"where [TT]veclen[tt] is the size of the cubic box times sqrt(3)/2." };
const char *bugs[] =
{
"For complex molecules, the periodicity removal routine may break down, ",
"in that case you can use trjconv." };
static real dist = 0.0, rbox = 0.0, to_diam = 0.0;
static gmx_bool bNDEF = FALSE, bRMPBC = FALSE, bCenter = FALSE, bReadVDW =
FALSE, bCONECT = FALSE;
static gmx_bool peratom = FALSE, bLegend = FALSE, bOrient = FALSE, bMead =
FALSE, bGrasp = FALSE, bSig56 = FALSE;
static rvec scale =
{ 1, 1, 1 }, newbox =
{ 0, 0, 0 }, newang =
{ 90, 90, 90 };
static real rho = 1000.0, rvdw = 0.12;
static rvec center =
{ 0, 0, 0 }, translation =
{ 0, 0, 0 }, rotangles =
{ 0, 0, 0 }, aligncenter =
{ 0, 0, 0 }, targetvec =
{ 0, 0, 0 };
static const char *btype[] =
{ NULL, "triclinic", "cubic", "dodecahedron", "octahedron", NULL },
*label = "A";
static rvec visbox =
{ 0, 0, 0 };
t_pargs
pa[] =
{
{ "-ndef", FALSE, etBOOL,
{ &bNDEF }, "Choose output from default index groups" },
{ "-visbox", FALSE, etRVEC,
{ visbox },
"HIDDENVisualize a grid of boxes, -1 visualizes the 14 box images" },
{ "-bt", FALSE, etENUM,
{ btype }, "Box type for -box and -d" },
{ "-box", FALSE, etRVEC,
{ newbox }, "Box vector lengths (a,b,c)" },
{ "-angles", FALSE, etRVEC,
{ newang }, "Angles between the box vectors (bc,ac,ab)" },
{ "-d", FALSE, etREAL,
{ &dist }, "Distance between the solute and the box" },
{ "-c", FALSE, etBOOL,
{ &bCenter },
"Center molecule in box (implied by -box and -d)" },
{ "-center", FALSE, etRVEC,
{ center }, "Coordinates of geometrical center" },
{ "-aligncenter", FALSE, etRVEC,
{ aligncenter }, "Center of rotation for alignment" },
{ "-align", FALSE, etRVEC,
{ targetvec },
"Align to target vector" },
{ "-translate", FALSE, etRVEC,
{ translation }, "Translation" },
{ "-rotate", FALSE, etRVEC,
{ rotangles },
"Rotation around the X, Y and Z axes in degrees" },
{ "-princ", FALSE, etBOOL,
{ &bOrient },
"Orient molecule(s) along their principal axes" },
{ "-scale", FALSE, etRVEC,
{ scale }, "Scaling factor" },
{ "-density", FALSE, etREAL,
{ &rho },
"Density (g/l) of the output box achieved by scaling" },
{ "-pbc", FALSE, etBOOL,
{ &bRMPBC },
"Remove the periodicity (make molecule whole again)" },
{ "-grasp", FALSE, etBOOL,
{ &bGrasp },
"Store the charge of the atom in the B-factor field and the radius of the atom in the occupancy field" },
{
"-rvdw", FALSE, etREAL,
{ &rvdw },
"Default Van der Waals radius (in nm) if one can not be found in the database or if no parameters are present in the topology file" },
{ "-sig56", FALSE, etREAL,
{ &bSig56 },
"Use rmin/2 (minimum in the Van der Waals potential) rather than sigma/2 " },
{
"-vdwread", FALSE, etBOOL,
{ &bReadVDW },
"Read the Van der Waals radii from the file vdwradii.dat rather than computing the radii based on the force field" },
{ "-atom", FALSE, etBOOL,
{ &peratom }, "Force B-factor attachment per atom" },
{ "-legend", FALSE, etBOOL,
{ &bLegend }, "Make B-factor legend" },
{ "-label", FALSE, etSTR,
{ &label }, "Add chain label for all residues" },
{
"-conect", FALSE, etBOOL,
{ &bCONECT },
"Add CONECT records to a pdb file when written. Can only be done when a topology is present" } };
#define NPA asize(pa)
FILE *out;
const char *infile, *outfile;
char title[STRLEN];
int outftp, inftp, natom, i, j, n_bfac, itype, ntype;
double *bfac = NULL, c6, c12;
int *bfac_nr = NULL;
t_topology *top = NULL;
t_atoms atoms;
char *grpname, *sgrpname, *agrpname;
int isize, ssize, tsize, asize;
atom_id *index, *sindex, *tindex, *aindex;
rvec *x, *v, gc, min, max, size;
int ePBC;
matrix box,rotmatrix,trans;
rvec princd,tmpvec;
gmx_bool bIndex, bSetSize, bSetAng, bCubic, bDist, bSetCenter, bAlign;
gmx_bool bHaveV, bScale, bRho, bTranslate, bRotate, bCalcGeom, bCalcDiam;
real xs, ys, zs, xcent, ycent, zcent, diam = 0, mass = 0, d, vdw;
gmx_atomprop_t aps;
gmx_conect conect;
output_env_t oenv;
t_filenm fnm[] =
{
{ efSTX, "-f", NULL, ffREAD },
{ efNDX, "-n", NULL, ffOPTRD },
{ efSTO, NULL, NULL, ffOPTWR },
{ efPQR, "-mead", "mead", ffOPTWR },
{ efDAT, "-bf", "bfact", ffOPTRD } };
#define NFILE asize(fnm)
CopyRight(stderr, argv[0]);
parse_common_args(&argc, argv, PCA_CAN_VIEW, NFILE, fnm, NPA, pa,
asize(desc), desc, asize(bugs), bugs, &oenv);
bIndex = opt2bSet("-n", NFILE, fnm) || bNDEF;
bMead = opt2bSet("-mead", NFILE, fnm);
bSetSize = opt2parg_bSet("-box", NPA, pa);
bSetAng = opt2parg_bSet("-angles", NPA, pa);
bSetCenter = opt2parg_bSet("-center", NPA, pa);
bDist = opt2parg_bSet("-d", NPA, pa);
bAlign = opt2parg_bSet("-align", NPA, pa);
/* Only automatically turn on centering without -noc */
if ((bDist || bSetSize || bSetCenter) && !opt2parg_bSet("-c", NPA, pa))
{
bCenter = TRUE;
}
bScale = opt2parg_bSet("-scale", NPA, pa);
bRho = opt2parg_bSet("-density", NPA, pa);
bTranslate = opt2parg_bSet("-translate", NPA, pa);
bRotate = opt2parg_bSet("-rotate", NPA, pa);
if (bScale && bRho)
fprintf(stderr, "WARNING: setting -density overrides -scale\n");
bScale = bScale || bRho;
bCalcGeom = bCenter || bRotate || bOrient || bScale;
bCalcDiam = btype[0][0] == 'c' || btype[0][0] == 'd' || btype[0][0] == 'o';
infile = ftp2fn(efSTX, NFILE, fnm);
if (bMead)
outfile = ftp2fn(efPQR, NFILE, fnm);
else
outfile = ftp2fn(efSTO, NFILE, fnm);
outftp = fn2ftp(outfile);
inftp = fn2ftp(infile);
aps = gmx_atomprop_init();
if (bMead && bGrasp)
{
printf("Incompatible options -mead and -grasp. Turning off -grasp\n");
bGrasp = FALSE;
}
if (bGrasp && (outftp != efPDB))
gmx_fatal(FARGS, "Output file should be a .pdb file"
" when using the -grasp option\n");
if ((bMead || bGrasp) && !((fn2ftp(infile) == efTPR) ||
(fn2ftp(infile) == efTPA) ||
(fn2ftp(infile) == efTPB)))
gmx_fatal(FARGS,"Input file should be a .tp[abr] file"
" when using the -mead option\n");
get_stx_coordnum(infile,&natom);
init_t_atoms(&atoms,natom,TRUE);
snew(x,natom);
snew(v,natom);
read_stx_conf(infile,title,&atoms,x,v,&ePBC,box);
if (fn2ftp(infile) == efPDB)
{
get_pdb_atomnumber(&atoms,aps);
}
printf("Read %d atoms\n",atoms.nr);
/* Get the element numbers if available in a pdb file */
if (fn2ftp(infile) == efPDB)
get_pdb_atomnumber(&atoms,aps);
if (ePBC != epbcNONE)
{
real vol = det(box);
printf("Volume: %g nm^3, corresponds to roughly %d electrons\n",
vol,100*((int)(vol*4.5)));
}
if (bMead || bGrasp || bCONECT)
top = read_top(infile,NULL);
if (bMead || bGrasp)
{
if (atoms.nr != top->atoms.nr)
gmx_fatal(FARGS,"Atom numbers don't match (%d vs. %d)",atoms.nr,top->atoms.nr);
snew(atoms.pdbinfo,top->atoms.nr);
ntype = top->idef.atnr;
for(i=0; (i<atoms.nr); i++) {
/* Determine the Van der Waals radius from the force field */
if (bReadVDW) {
if (!gmx_atomprop_query(aps,epropVDW,
*top->atoms.resinfo[top->atoms.atom[i].resind].name,
*top->atoms.atomname[i],&vdw))
vdw = rvdw;
}
else {
itype = top->atoms.atom[i].type;
c12 = top->idef.iparams[itype*ntype+itype].lj.c12;
c6 = top->idef.iparams[itype*ntype+itype].lj.c6;
if ((c6 != 0) && (c12 != 0)) {
real sig6;
if (bSig56)
sig6 = 2*c12/c6;
else
sig6 = c12/c6;
vdw = 0.5*pow(sig6,1.0/6.0);
}
else
vdw = rvdw;
}
/* Factor of 10 for nm -> Angstroms */
vdw *= 10;
if (bMead) {
atoms.pdbinfo[i].occup = top->atoms.atom[i].q;
atoms.pdbinfo[i].bfac = vdw;
}
else {
atoms.pdbinfo[i].occup = vdw;
atoms.pdbinfo[i].bfac = top->atoms.atom[i].q;
}
}
}
bHaveV=FALSE;
for (i=0; (i<natom) && !bHaveV; i++)
for (j=0; (j<DIM) && !bHaveV; j++)
bHaveV=bHaveV || (v[i][j]!=0);
printf("%selocities found\n",bHaveV?"V":"No v");
if (visbox[0] > 0) {
if (bIndex)
gmx_fatal(FARGS,"Sorry, can not visualize box with index groups");
if (outftp != efPDB)
gmx_fatal(FARGS,"Sorry, can only visualize box with a pdb file");
} else if (visbox[0] == -1)
visualize_images("images.pdb",ePBC,box);
/* remove pbc */
if (bRMPBC)
rm_gropbc(&atoms,x,box);
if (bCalcGeom) {
if (bIndex) {
fprintf(stderr,"\nSelect a group for determining the system size:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&ssize,&sindex,&sgrpname);
} else {
ssize = atoms.nr;
sindex = NULL;
}
diam=calc_geom(ssize,sindex,x,gc,min,max,bCalcDiam);
rvec_sub(max, min, size);
printf(" system size :%7.3f%7.3f%7.3f (nm)\n",
size[XX], size[YY], size[ZZ]);
if (bCalcDiam)
printf(" diameter :%7.3f (nm)\n",diam);
printf(" center :%7.3f%7.3f%7.3f (nm)\n", gc[XX], gc[YY], gc[ZZ]);
printf(" box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf(" box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY],box[ZZ])),
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[ZZ])),
norm2(box[YY])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[YY])));
printf(" box volume :%7.2f (nm^3)\n",det(box));
}
if (bRho || bOrient || bAlign)
mass = calc_mass(&atoms,!fn2bTPX(infile),aps);
if (bOrient) {
atom_id *index;
char *grpnames;
/* Get a group for principal component analysis */
fprintf(stderr,"\nSelect group for the determining the orientation\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),1,&isize,&index,&grpnames);
/* Orient the principal axes along the coordinate axes */
orient_princ(&atoms,isize,index,natom,x,bHaveV ? v : NULL, NULL);
sfree(index);
sfree(grpnames);
}
if ( bScale ) {
/* scale coordinates and box */
if (bRho) {
/* Compute scaling constant */
real vol,dens;
vol = det(box);
dens = (mass*AMU)/(vol*NANO*NANO*NANO);
fprintf(stderr,"Volume of input %g (nm^3)\n",vol);
fprintf(stderr,"Mass of input %g (a.m.u.)\n",mass);
fprintf(stderr,"Density of input %g (g/l)\n",dens);
if (vol==0 || mass==0)
gmx_fatal(FARGS,"Cannot scale density with "
"zero mass (%g) or volume (%g)\n",mass,vol);
scale[XX] = scale[YY] = scale[ZZ] = pow(dens/rho,1.0/3.0);
fprintf(stderr,"Scaling all box vectors by %g\n",scale[XX]);
}
scale_conf(atoms.nr,x,box,scale);
}
if (bAlign) {
if (bIndex) {
fprintf(stderr,"\nSelect a group that you want to align:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&asize,&aindex,&agrpname);
} else {
asize = atoms.nr;
snew(aindex,asize);
for (i=0;i<asize;i++)
aindex[i]=i;
}
printf("Aligning %d atoms (out of %d) to %g %g %g, center of rotation %g %g %g\n",asize,natom,
targetvec[XX],targetvec[YY],targetvec[ZZ],
aligncenter[XX],aligncenter[YY],aligncenter[ZZ]);
/*subtract out pivot point*/
for(i=0; i<asize; i++)
rvec_dec(x[aindex[i]],aligncenter);
/*now determine transform and rotate*/
/*will this work?*/
principal_comp(asize,aindex,atoms.atom,x, trans,princd);
unitv(targetvec,targetvec);
printf("Using %g %g %g as principal axis\n", trans[0][2],trans[1][2],trans[2][2]);
tmpvec[XX]=trans[0][2]; tmpvec[YY]=trans[1][2]; tmpvec[ZZ]=trans[2][2];
calc_rotmatrix(tmpvec, targetvec, rotmatrix);
/* rotmatrix finished */
for (i=0;i<asize;++i)
{
mvmul(rotmatrix,x[aindex[i]],tmpvec);
copy_rvec(tmpvec,x[aindex[i]]);
}
/*add pivot point back*/
for(i=0; i<asize; i++)
rvec_inc(x[aindex[i]],aligncenter);
if (!bIndex)
sfree(aindex);
}
if (bTranslate) {
if (bIndex) {
fprintf(stderr,"\nSelect a group that you want to translate:\n");
get_index(&atoms,ftp2fn_null(efNDX,NFILE,fnm),
1,&ssize,&sindex,&sgrpname);
} else {
ssize = atoms.nr;
sindex = NULL;
}
printf("Translating %d atoms (out of %d) by %g %g %g nm\n",ssize,natom,
translation[XX],translation[YY],translation[ZZ]);
if (sindex) {
for(i=0; i<ssize; i++)
rvec_inc(x[sindex[i]],translation);
}
else {
for(i=0; i<natom; i++)
rvec_inc(x[i],translation);
}
}
if (bRotate) {
/* Rotate */
printf("Rotating %g, %g, %g degrees around the X, Y and Z axis respectively\n",rotangles[XX],rotangles[YY],rotangles[ZZ]);
for(i=0; i<DIM; i++)
rotangles[i] *= DEG2RAD;
rotate_conf(natom,x,v,rotangles[XX],rotangles[YY],rotangles[ZZ]);
}
if (bCalcGeom) {
/* recalc geometrical center and max and min coordinates and size */
calc_geom(ssize,sindex,x,gc,min,max,FALSE);
rvec_sub(max, min, size);
if (bScale || bOrient || bRotate)
printf("new system size : %6.3f %6.3f %6.3f\n",
size[XX],size[YY],size[ZZ]);
}
if (bSetSize || bDist || (btype[0][0]=='t' && bSetAng)) {
ePBC = epbcXYZ;
if (!(bSetSize || bDist))
for (i=0; i<DIM; i++)
newbox[i] = norm(box[i]);
clear_mat(box);
/* calculate new boxsize */
switch(btype[0][0]){
case 't':
if (bDist)
for(i=0; i<DIM; i++)
newbox[i] = size[i]+2*dist;
if (!bSetAng) {
box[XX][XX] = newbox[XX];
box[YY][YY] = newbox[YY];
box[ZZ][ZZ] = newbox[ZZ];
} else {
matrix_convert(box,newbox,newang);
}
break;
case 'c':
case 'd':
case 'o':
if (bSetSize)
d = newbox[0];
else
d = diam+2*dist;
if (btype[0][0] == 'c')
for(i=0; i<DIM; i++)
box[i][i] = d;
else if (btype[0][0] == 'd') {
box[XX][XX] = d;
box[YY][YY] = d;
box[ZZ][XX] = d/2;
box[ZZ][YY] = d/2;
box[ZZ][ZZ] = d*sqrt(2)/2;
} else {
box[XX][XX] = d;
box[YY][XX] = d/3;
box[YY][YY] = d*sqrt(2)*2/3;
box[ZZ][XX] = -d/3;
box[ZZ][YY] = d*sqrt(2)/3;
box[ZZ][ZZ] = d*sqrt(6)/3;
}
break;
}
}
/* calculate new coords for geometrical center */
if (!bSetCenter)
calc_box_center(ecenterDEF,box,center);
/* center molecule on 'center' */
if (bCenter)
center_conf(natom,x,center,gc);
/* print some */
if (bCalcGeom) {
calc_geom(ssize,sindex,x, gc, min, max, FALSE);
printf("new center :%7.3f%7.3f%7.3f (nm)\n",gc[XX],gc[YY],gc[ZZ]);
}
if (bOrient || bScale || bDist || bSetSize) {
printf("new box vectors :%7.3f%7.3f%7.3f (nm)\n",
norm(box[XX]), norm(box[YY]), norm(box[ZZ]));
printf("new box angles :%7.2f%7.2f%7.2f (degrees)\n",
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[YY],box[ZZ])),
norm2(box[ZZ])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[ZZ])),
norm2(box[YY])==0 ? 0 :
RAD2DEG*acos(cos_angle_no_table(box[XX],box[YY])));
printf("new box volume :%7.2f (nm^3)\n",det(box));
}
if (check_box(epbcXYZ,box))
printf("\nWARNING: %s\n",check_box(epbcXYZ,box));
if (bDist && btype[0][0]=='t')
{
if(TRICLINIC(box))
{
printf("\nWARNING: Your box is triclinic with non-orthogonal axes. In this case, the\n"
"distance from the solute to a box surface along the corresponding normal\n"
"vector might be somewhat smaller than your specified value %f.\n"
"You can check the actual value with g_mindist -pi\n",dist);
}
else
{
printf("\nWARNING: No boxtype specified - distance condition applied in each dimension.\n"
"If the molecule rotates the actual distance will be smaller. You might want\n"
"to use a cubic box instead, or why not try a dodecahedron today?\n");
}
}
if (bCONECT && (outftp == efPDB) && (inftp == efTPR))
conect = gmx_conect_generate(top);
else
conect = NULL;
if (bIndex) {
fprintf(stderr,"\nSelect a group for output:\n");
get_index(&atoms,opt2fn_null("-n",NFILE,fnm),
1,&isize,&index,&grpname);
if (opt2parg_bSet("-label",NPA,pa)) {
for(i=0; (i<atoms.nr); i++)
atoms.resinfo[atoms.atom[i].resind].chainid=label[0];
}
if (opt2bSet("-bf",NFILE,fnm) || bLegend)
{
gmx_fatal(FARGS,"Sorry, cannot do bfactors with an index group.");
}
if (outftp == efPDB)
{
out=ffopen(outfile,"w");
write_pdbfile_indexed(out,title,&atoms,x,ePBC,box,' ',1,isize,index,conect,TRUE);
ffclose(out);
}
else
{
write_sto_conf_indexed(outfile,title,&atoms,x,bHaveV?v:NULL,ePBC,box,isize,index);
}
}
else {
if ((outftp == efPDB) || (outftp == efPQR)) {
out=ffopen(outfile,"w");
if (bMead) {
set_pdb_wide_format(TRUE);
fprintf(out,"REMARK "
"The B-factors in this file hold atomic radii\n");
fprintf(out,"REMARK "
"The occupancy in this file hold atomic charges\n");
}
else if (bGrasp) {
fprintf(out,"GRASP PDB FILE\nFORMAT NUMBER=1\n");
fprintf(out,"REMARK "
"The B-factors in this file hold atomic charges\n");
fprintf(out,"REMARK "
"The occupancy in this file hold atomic radii\n");
}
else if (opt2bSet("-bf",NFILE,fnm)) {
read_bfac(opt2fn("-bf",NFILE,fnm),&n_bfac,&bfac,&bfac_nr);
set_pdb_conf_bfac(atoms.nr,atoms.nres,&atoms,
n_bfac,bfac,bfac_nr,peratom);
}
if (opt2parg_bSet("-label",NPA,pa)) {
for(i=0; (i<atoms.nr); i++)
atoms.resinfo[atoms.atom[i].resind].chainid=label[0];
}
write_pdbfile(out,title,&atoms,x,ePBC,box,' ',-1,conect,TRUE);
if (bLegend)
pdb_legend(out,atoms.nr,atoms.nres,&atoms,x);
if (visbox[0] > 0)
visualize_box(out,bLegend ? atoms.nr+12 : atoms.nr,
bLegend? atoms.nres=12 : atoms.nres,box,visbox);
ffclose(out);
}
else
write_sto_conf(outfile,title,&atoms,x,bHaveV?v:NULL,ePBC,box);
}
gmx_atomprop_destroy(aps);
do_view(oenv,outfile,NULL);
thanx(stderr);
return 0;
}
void ILaunchDialog::event_init_dialog()
{
try
{
m_config.load("ilaunch.xml");
}
catch(const ILaunchConfigException & e)
{
MessageBox(m_hwnd, e.get_message().c_str(),
"Error Loading Configuration", MB_OK | MB_ICONSTOP);
destroy();
return;
}
// Set the icon for the main window.
HICON hicon = LoadIcon(g_hinstance, MAKEINTRESOURCE(ID_ICO_IGNITION));
SendMessage(m_hwnd, WM_SETICON, ICON_SMALL,
reinterpret_cast<LPARAM>(hicon));
SendMessage(m_hwnd, WM_SETICON, ICON_BIG,
reinterpret_cast<LPARAM>(hicon));
// Show the client directory.
SetDlgItemText(m_hwnd, ID_ST_CLIENTDIR, m_config.get_client_dir());
SetDlgItemText(m_hwnd, ID_ST_IGNITIONCFG, m_config.get_ignition_cfg());
// Initialise checkboxes.
ButtonWrapper check_box(m_hwnd, ID_CH_INJECTION);
check_box.set_check(m_config.get_use_injection());
ButtonWrapper check_box2(m_hwnd, ID_CH_CLOSEWHENDONE);
check_box2.set_check(m_config.get_close());
// Fill combo boxes and activate last selections.
ComboBoxWrapper scombo(m_hwnd, ID_CB_SERVER);
update_servers_box();
int i = m_config.get_last_server();
if(i >= 0 && static_cast<size_t>(i) < m_config.get_servers().size())
{
scombo.set_current_selection(i);
m_address = m_config.get_servers()[i].m_address;
m_username = m_config.get_servers()[i].m_username;
m_password = m_config.get_servers()[i].m_password;
}
else
{
m_address = "";
m_username = "";
m_password = "";
}
// Show the address
SetDlgItemText(m_hwnd, ID_ST_ADDRESS, m_address.c_str());
ComboBoxWrapper ccombo(m_hwnd, ID_CB_CLIENT);
update_clients_box();
i = m_config.get_last_client();
if(i >= 0 && static_cast<size_t>(i) < m_config.get_clients().size())
{
ccombo.set_current_selection(i);
m_client_path = m_config.get_clients()[i].m_path;
}
else
m_client_path = "";
// Show the executable path
SetDlgItemText(m_hwnd, ID_ST_EXEPATH, m_client_path.c_str());
}
BOOL ILaunchDialog::event_command(int control_id, int notify_code)
{
if(control_id == IDCANCEL)
{
destroy();
return TRUE;
}
if(notify_code == BN_CLICKED)
{
switch(control_id)
{
case ID_BT_CLIENTDIR:
choose_client_dir();
return TRUE;
case ID_BT_SERVERS:
{
EditServersDialog dialog(m_config.get_servers());
// Returns zero if the dialog was cancelled.
if(dialog.open(m_hwnd) != 0)
{
m_config.set_servers(dialog.get_list());
update_servers_box();
}
return TRUE;
}
case ID_BT_CLIENTS:
{
EditClientsDialog dialog(m_config.get_clients());
// Returns zero if the dialog was cancelled.
if(dialog.open(m_hwnd) != 0)
{
m_config.set_clients(dialog.get_list());
update_clients_box();
}
return TRUE;
}
case ID_BT_IGNITIONCFG:
choose_ignition_cfg();
return TRUE;
case ID_CH_INJECTION:
{
ButtonWrapper check_box(m_hwnd, ID_CH_INJECTION);
m_config.set_use_injection(check_box.get_check());
return TRUE;
}
case ID_CH_CLOSEWHENDONE:
{
ButtonWrapper check_box(m_hwnd, ID_CH_CLOSEWHENDONE);
m_config.set_close(check_box.get_check());
return TRUE;
}
case ID_BT_LAUNCH:
{
ButtonWrapper check_box(m_hwnd, ID_CH_INJECTION);
m_config.set_use_injection(check_box.get_check());
// Open launch dialog.
if(m_launching_dialog.open(m_hwnd, m_config, m_address.c_str(),
m_username.c_str(), m_password.c_str(),
m_client_path.c_str()) && m_config.get_close())
// Close the program.
destroy();
return TRUE;
}
}
}
else if(notify_code == CBN_SELCHANGE)
{
if(control_id == ID_CB_SERVER)
{
ComboBoxWrapper combo(m_hwnd, ID_CB_SERVER);
int i = combo.get_current_selection();
if(i != -1)
{
ILaunchConfig::serverlist_t & servers=(m_config.get_servers());
if(i >= 0 && static_cast<size_t>(i) < servers.size())
{
m_address = servers[i].m_address;
m_username = servers[i].m_username;
m_password = servers[i].m_password;
m_config.set_last_server(i);
SetDlgItemText(m_hwnd, ID_ST_ADDRESS, m_address.c_str());
}
}
return TRUE;
}
else if(control_id == ID_CB_CLIENT)
{
ComboBoxWrapper combo(m_hwnd, ID_CB_CLIENT);
int i = combo.get_current_selection();
if(i != -1)
{
ILaunchConfig::clientlist_t & clients=(m_config.get_clients());
if(i >= 0 && static_cast<size_t>(i) < clients.size())
{
m_client_path = clients[i].m_path;
m_config.set_last_client(i);
SetDlgItemText(m_hwnd, ID_ST_EXEPATH,
m_client_path.c_str());
}
}
return TRUE;
}
}
return FALSE;
}
bool show() {
use_full_install_ui_ctrl_id = check_box(Far::get_msg(MSG_CONFIG_USE_FULL_INSTALL_UI), options.use_full_install_ui);
new_line();
update_stable_builds_ctrl_id = check_box(Far::get_msg(MSG_CONFIG_UPDATE_STABLE_BUILDS), options.update_stable_builds);
new_line();
logged_install_ctrl_id = check_box(Far::get_msg(MSG_CONFIG_LOGGED_INSTALL), options.logged_install);
new_line();
open_changelog_ctrl_id = check_box(Far::get_msg(MSG_CONFIG_OPEN_CHANGELOG), options.open_changelog);
new_line();
label(Far::get_msg(MSG_CONFIG_INSTALL_PROPERTIES));
install_properties_ctrl_id = edit_box(options.install_properties, 30);
new_line();
separator();
new_line();
use_proxy_ctrl_id = check_box(Far::get_msg(MSG_CONFIG_USE_PROXY), options.http.use_proxy);
new_line();
spacer(2);
label(Far::get_msg(MSG_CONFIG_PROXY_SERVER));
proxy_server_ctrl_id = edit_box(options.http.proxy_server, 20);
spacer(2);
label(Far::get_msg(MSG_CONFIG_PROXY_PORT));
proxy_port_ctrl_id = edit_box(options.http.proxy_port ? int_to_str(options.http.proxy_port) : wstring(), 6);
new_line();
spacer(2);
label(Far::get_msg(MSG_CONFIG_PROXY_AUTH_SCHEME));
vector<wstring> auth_scheme_list;
auth_scheme_list.push_back(Far::get_msg(MSG_CONFIG_PROXY_AUTH_BASIC));
auth_scheme_list.push_back(Far::get_msg(MSG_CONFIG_PROXY_AUTH_NTLM));
auth_scheme_list.push_back(Far::get_msg(MSG_CONFIG_PROXY_AUTH_PASSPORT));
auth_scheme_list.push_back(Far::get_msg(MSG_CONFIG_PROXY_AUTH_DIGEST));
auth_scheme_list.push_back(Far::get_msg(MSG_CONFIG_PROXY_AUTH_NEGOTIATE));
proxy_auth_scheme_ctrl_id = combo_box(auth_scheme_list, options.http.proxy_auth_scheme, AUTO_SIZE, DIF_DROPDOWNLIST);
new_line();
spacer(2);
label(Far::get_msg(MSG_CONFIG_PROXY_USER_NAME));
proxy_user_name_ctrl_id = edit_box(options.http.proxy_user_name, 15);
spacer(2);
label(Far::get_msg(MSG_CONFIG_PROXY_PASSWORD));
proxy_password_ctrl_id = edit_box(options.http.proxy_password, 15);
new_line();
separator();
new_line();
cache_enabled_ctrl_id = check_box(Far::get_msg(MSG_CONFIG_CACHE_ENABLED), options.cache_enabled);
new_line();
spacer(2);
label(Far::get_msg(MSG_CONFIG_CACHE_MAX_SIZE));
cache_max_size_ctrl_id = edit_box(int_to_str(options.cache_max_size), 2);
new_line();
spacer(2);
label(Far::get_msg(MSG_CONFIG_CACHE_DIR));
cache_dir_ctrl_id = edit_box(options.cache_dir, 30);
new_line();
separator();
new_line();
ok_ctrl_id = def_button(Far::get_msg(MSG_BUTTON_OK), DIF_CENTERGROUP);
cancel_ctrl_id = button(Far::get_msg(MSG_BUTTON_CANCEL), DIF_CENTERGROUP);
new_line();
int item = Far::Dialog::show();
return (item != -1) && (item != cancel_ctrl_id);
}
// Hooking into Check boxes
int CheckboxConverter::get_long()
{
return check_box()->check() ? 1 : 0;
}
void CheckboxConverter::set_long(int val)
{
check_box()->check(val ? true : false);
}
void init_forcerec(FILE *fp,
t_forcerec *fr,
t_inputrec *ir,
t_topology *top,
t_commrec *cr,
t_mdatoms *mdatoms,
t_nsborder *nsb,
matrix box,
bool bMolEpot,
char *tabfn,
bool bNoSolvOpt)
{
int i,j,m,natoms,ngrp,tabelemsize;
real q,zsq,nrdf,T;
rvec box_size;
double rtab;
t_block *mols,*cgs;
t_idef *idef;
if (check_box(box))
fatal_error(0,check_box(box));
cgs = &(top->blocks[ebCGS]);
mols = &(top->blocks[ebMOLS]);
idef = &(top->idef);
natoms = mdatoms->nr;
/* Shell stuff */
fr->fc_stepsize = ir->fc_stepsize;
/* Free energy */
fr->efep = ir->efep;
fr->sc_alpha = ir->sc_alpha;
fr->sc_sigma6 = pow(ir->sc_sigma,6);
/* Neighbour searching stuff */
fr->bGrid = (ir->ns_type == ensGRID);
fr->ndelta = ir->ndelta;
fr->ePBC = ir->ePBC;
fr->rlist = ir->rlist;
fr->rlistlong = max(ir->rlist,max(ir->rcoulomb,ir->rvdw));
fr->eeltype = ir->coulombtype;
fr->vdwtype = ir->vdwtype;
fr->bTwinRange = fr->rlistlong > fr->rlist;
fr->bEwald = fr->eeltype==eelPME || fr->eeltype==eelEWALD;
fr->bvdwtab = fr->vdwtype != evdwCUT;
fr->bRF = (fr->eeltype==eelRF || fr->eeltype==eelGRF) &&
fr->vdwtype==evdwCUT;
fr->bcoultab = (fr->eeltype!=eelCUT && !fr->bRF) || fr->bEwald;
#ifndef SPEC_CPU
if (getenv("GMX_FORCE_TABLES")) {
fr->bvdwtab = TRUE;
fr->bcoultab = TRUE;
}
#endif
if (fp) {
fprintf(fp,"Table routines are used for coulomb: %s\n",bool_names[fr->bcoultab]);
fprintf(fp,"Table routines are used for vdw: %s\n",bool_names[fr->bvdwtab ]);
}
/* Tables are used for direct ewald sum */
if(fr->bEwald) {
fr->ewaldcoeff=calc_ewaldcoeff(ir->rcoulomb, ir->ewald_rtol);
if (fp)
fprintf(fp,"Using a Gaussian width (1/beta) of %g nm for Ewald\n",
1/fr->ewaldcoeff);
}
/* Domain decomposition parallellism... */
fr->bDomDecomp = ir->bDomDecomp;
fr->Dimension = ir->decomp_dir;
/* Electrostatics */
fr->epsilon_r = ir->epsilon_r;
fr->fudgeQQ = ir->fudgeQQ;
fr->rcoulomb_switch = ir->rcoulomb_switch;
fr->rcoulomb = ir->rcoulomb;
#ifndef SPEC_CPU
if (bNoSolvOpt || getenv("GMX_NO_SOLV_OPT"))
fr->bSolvOpt = FALSE;
else
#endif
fr->bSolvOpt = TRUE;
/* Parameters for generalized RF */
fr->zsquare = 0.0;
fr->temp = 0.0;
if (fr->eeltype == eelGRF) {
zsq = 0.0;
for (i=0; (i<cgs->nr); i++) {
q = 0;
for(j=cgs->index[i]; (j<cgs->index[i+1]); j++)
q+=mdatoms->chargeT[cgs->a[j]];
if (fabs(q) > GMX_REAL_MIN)
/* Changed from square to fabs 990314 DvdS
* Does not make a difference for monovalent ions, but doe for
* divalent ions (Ca2+!!)
*/
zsq += fabs(q);
}
fr->zsquare = zsq;
T = 0.0;
nrdf = 0.0;
for(i=0; (i<ir->opts.ngtc); i++) {
nrdf += ir->opts.nrdf[i];
T += (ir->opts.nrdf[i] * ir->opts.ref_t[i]);
}
if (nrdf < GMX_REAL_MIN)
fatal_error(0,"No degrees of freedom!");
fr->temp = T/nrdf;
}
else if (EEL_LR(fr->eeltype) || (fr->eeltype == eelSHIFT) ||
(fr->eeltype == eelUSER) || (fr->eeltype == eelSWITCH)) {
/* We must use the long range cut-off for neighboursearching...
* An extra range of e.g. 0.1 nm (half the size of a charge group)
* is necessary for neighboursearching. This allows diffusion
* into the cut-off range (between neighborlist updates),
* and gives more accurate forces because all atoms within the short-range
* cut-off rc must be taken into account, while the ns criterium takes
* only those with the center of geometry within the cut-off.
* (therefore we have to add half the size of a charge group, plus
* something to account for diffusion if we have nstlist > 1)
*/
for(m=0; (m<DIM); m++)
box_size[m]=box[m][m];
if (fr->phi == NULL)
snew(fr->phi,mdatoms->nr);
if ((fr->eeltype==eelPPPM) || (fr->eeltype==eelPOISSON) ||
(fr->eeltype == eelSHIFT && fr->rcoulomb > fr->rcoulomb_switch))
set_shift_consts(fp,fr->rcoulomb_switch,fr->rcoulomb,box_size,fr);
}
/* Initiate arrays */
if (fr->bTwinRange) {
snew(fr->f_twin,natoms);
snew(fr->fshift_twin,SHIFTS);
}
if (EEL_LR(fr->eeltype)) {
snew(fr->f_pme,natoms);
}
/* Mask that says whether or not this NBF list should be computed */
/* if (fr->bMask == NULL) {
ngrp = ir->opts.ngener*ir->opts.ngener;
snew(fr->bMask,ngrp);*/
/* Defaults to always */
/* for(i=0; (i<ngrp); i++)
fr->bMask[i] = TRUE;
}*/
if (fr->cg_cm == NULL)
snew(fr->cg_cm,cgs->nr);
if (fr->shift_vec == NULL)
snew(fr->shift_vec,SHIFTS);
if (fr->fshift == NULL)
snew(fr->fshift,SHIFTS);
if (bMolEpot && (fr->nmol==0)) {
fr->nmol=mols->nr;
fr->mol_nr=make_invblock(mols,natoms);
snew(fr->mol_epot,fr->nmol);
fr->nstcalc=ir->nstenergy;
}
if (fr->nbfp == NULL) {
fr->ntype = idef->atnr;
fr->bBHAM = (idef->functype[0] == F_BHAM);
fr->nbfp = mk_nbfp(idef,fr->bBHAM);
}
/* Copy the energy group exclusions */
fr->eg_excl = ir->opts.eg_excl;
/* Van der Waals stuff */
fr->rvdw = ir->rvdw;
fr->rvdw_switch = ir->rvdw_switch;
if ((fr->vdwtype != evdwCUT) && (fr->vdwtype != evdwUSER) && !fr->bBHAM) {
if (fr->rvdw_switch >= fr->rvdw)
fatal_error(0,"rvdw_switch (%g) must be < rvdw (%g)",
fr->rvdw_switch,fr->rvdw);
if (fp)
fprintf(fp,"Using %s Lennard-Jones, switch between %g and %g nm\n",
(fr->eeltype==eelSWITCH) ? "switched":"shifted",
fr->rvdw_switch,fr->rvdw);
}
if (fp)
fprintf(fp,"Cut-off's: NS: %g Coulomb: %g %s: %g\n",
fr->rlist,fr->rcoulomb,fr->bBHAM ? "BHAM":"LJ",fr->rvdw);
if (ir->eDispCorr != edispcNO)
set_avcsix(fp,fr,mdatoms);
if (fr->bBHAM)
set_bham_b_max(fp,fr,mdatoms);
/* Now update the rest of the vars */
update_forcerec(fp,fr,box);
/* if we are using LR electrostatics, and they are tabulated,
* the tables will contain shifted coulomb interactions.
* Since we want to use the non-shifted ones for 1-4
* coulombic interactions, we must have an extra set of
* tables. This should be done in tables.c, instead of this
* ugly hack, but it works for now...
*/
#define MAX_14_DIST 1.0
/* Shell to account for the maximum chargegroup radius (2*0.2 nm) *
* and diffusion during nstlist steps (0.2 nm) */
#define TAB_EXT 0.6
/* Construct tables.
* A little unnecessary to make both vdw and coul tables sometimes,
* but what the heck... */
if (fr->bcoultab || fr->bvdwtab) {
if (EEL_LR(fr->eeltype)) {
bool bcoulsave,bvdwsave;
/* generate extra tables for 1-4 interactions only
* fake the forcerec so make_tables thinks it should
* just create the non shifted version
*/
bcoulsave=fr->bcoultab;
bvdwsave=fr->bvdwtab;
fr->bcoultab=FALSE;
fr->bvdwtab=FALSE;
fr->rtab=MAX_14_DIST;
make_tables(fp,fr,MASTER(cr),tabfn);
fr->bcoultab=bcoulsave;
fr->bvdwtab=bvdwsave;
fr->coulvdw14tab=fr->coulvdwtab;
fr->coulvdwtab=NULL;
}
fr->rtab = max(fr->rlistlong+TAB_EXT,MAX_14_DIST);
}
else if (fr->efep != efepNO) {
if (fr->rlistlong < GMX_REAL_MIN) {
char *ptr,*envvar="FEP_TABLE_LENGTH";
fr->rtab = 5;
#ifdef SPEC_CPU
ptr = NULL;
#else
ptr = getenv(envvar);
#endif
if (ptr) {
sscanf(ptr,"%lf",&rtab);
fr->rtab = rtab;
}
if (fp)
fprintf(fp,"\nNote: Setting the free energy table length to %g nm\n"
" You can set this value with the environment variable %s"
"\n\n",fr->rtab,envvar);
}
else
fr->rtab = max(fr->rlistlong+TAB_EXT,MAX_14_DIST);
}
else
fr->rtab = MAX_14_DIST;
/* make tables for ordinary interactions */
make_tables(fp,fr,MASTER(cr),tabfn);
if(!(EEL_LR(fr->eeltype) && (fr->bcoultab || fr->bvdwtab)))
fr->coulvdw14tab=fr->coulvdwtab;
/* Copy the contents of the table to separate coulomb and LJ
* tables too, to improve cache performance.
*/
tabelemsize=fr->bBHAM ? 16 : 12;
snew(fr->coultab,4*(fr->ntab+1)*sizeof(real));
snew(fr->vdwtab,(tabelemsize-4)*(fr->ntab+1)*sizeof(real));
for(i=0; i<=fr->ntab; i++) {
for(j=0; j<4; j++)
fr->coultab[4*i+j]=fr->coulvdwtab[tabelemsize*i+j];
for(j=0; j<tabelemsize-4; j++)
fr->vdwtab[(tabelemsize-4)*i+j]=fr->coulvdwtab[tabelemsize*i+4+j];
}
if (!fr->mno_index)
check_solvent(fp,top,fr,mdatoms,nsb);
}
unsigned check_box3(const wstring& text, bool value, bool value_defined, FARDIALOGITEMFLAGS flags = 0) {
return check_box(text, value_defined ? (value ? BSTATE_CHECKED : BSTATE_UNCHECKED) : BSTATE_3STATE, flags | DIF_3STATE);
}
unsigned check_box(const wstring& text, bool value, FARDIALOGITEMFLAGS flags = 0) {
return check_box(text, value ? BSTATE_CHECKED : BSTATE_UNCHECKED, flags);
}
//! Do the real arithmetic for filling the pbc struct
static void low_set_pbc(t_pbc *pbc, int ePBC,
const ivec dd_pbc, const matrix box)
{
int order[3] = { 0, -1, 1 };
ivec bPBC;
const char *ptr;
pbc->ePBC = ePBC;
pbc->ndim_ePBC = ePBC2npbcdim(ePBC);
copy_mat(box, pbc->box);
pbc->max_cutoff2 = 0;
pbc->dim = -1;
pbc->ntric_vec = 0;
for (int i = 0; (i < DIM); i++)
{
pbc->fbox_diag[i] = box[i][i];
pbc->hbox_diag[i] = pbc->fbox_diag[i]*0.5;
pbc->mhbox_diag[i] = -pbc->hbox_diag[i];
}
ptr = check_box(ePBC, box);
if (ePBC == epbcNONE)
{
pbc->ePBCDX = epbcdxNOPBC;
}
else if (ptr)
{
fprintf(stderr, "Warning: %s\n", ptr);
pr_rvecs(stderr, 0, " Box", box, DIM);
fprintf(stderr, " Can not fix pbc.\n\n");
pbc->ePBCDX = epbcdxUNSUPPORTED;
}
else
{
if (ePBC == epbcSCREW && NULL != dd_pbc)
{
/* This combinated should never appear here */
gmx_incons("low_set_pbc called with screw pbc and dd_nc != NULL");
}
int npbcdim = 0;
for (int i = 0; i < DIM; i++)
{
if ((dd_pbc && dd_pbc[i] == 0) || (ePBC == epbcXY && i == ZZ))
{
bPBC[i] = 0;
}
else
{
bPBC[i] = 1;
npbcdim++;
}
}
switch (npbcdim)
{
case 1:
/* 1D pbc is not an mdp option and it is therefore only used
* with single shifts.
*/
pbc->ePBCDX = epbcdx1D_RECT;
for (int i = 0; i < DIM; i++)
{
if (bPBC[i])
{
pbc->dim = i;
}
}
GMX_ASSERT(pbc->dim < DIM, "Dimension for PBC incorrect");
for (int i = 0; i < pbc->dim; i++)
{
if (pbc->box[pbc->dim][i] != 0)
{
pbc->ePBCDX = epbcdx1D_TRIC;
}
}
break;
case 2:
pbc->ePBCDX = epbcdx2D_RECT;
for (int i = 0; i < DIM; i++)
{
if (!bPBC[i])
{
pbc->dim = i;
}
}
for (int i = 0; i < DIM; i++)
{
if (bPBC[i])
{
for (int j = 0; j < i; j++)
{
if (pbc->box[i][j] != 0)
{
pbc->ePBCDX = epbcdx2D_TRIC;
}
}
}
}
break;
case 3:
if (ePBC != epbcSCREW)
{
if (TRICLINIC(box))
{
pbc->ePBCDX = epbcdxTRICLINIC;
}
else
{
pbc->ePBCDX = epbcdxRECTANGULAR;
}
}
else
{
pbc->ePBCDX = (box[ZZ][YY] == 0 ? epbcdxSCREW_RECT : epbcdxSCREW_TRIC);
if (pbc->ePBCDX == epbcdxSCREW_TRIC)
{
fprintf(stderr,
"Screw pbc is not yet implemented for triclinic boxes.\n"
"Can not fix pbc.\n");
pbc->ePBCDX = epbcdxUNSUPPORTED;
}
}
break;
default:
gmx_fatal(FARGS, "Incorrect number of pbc dimensions with DD: %d",
npbcdim);
}
pbc->max_cutoff2 = max_cutoff2(ePBC, box);
if (pbc->ePBCDX == epbcdxTRICLINIC ||
pbc->ePBCDX == epbcdx2D_TRIC ||
pbc->ePBCDX == epbcdxSCREW_TRIC)
{
if (debug)
{
pr_rvecs(debug, 0, "Box", box, DIM);
fprintf(debug, "max cutoff %.3f\n", sqrt(pbc->max_cutoff2));
}
/* We will only need single shifts here */
for (int kk = 0; kk < 3; kk++)
{
int k = order[kk];
if (!bPBC[ZZ] && k != 0)
{
continue;
}
for (int jj = 0; jj < 3; jj++)
{
int j = order[jj];
if (!bPBC[YY] && j != 0)
{
continue;
}
for (int ii = 0; ii < 3; ii++)
{
int i = order[ii];
if (!bPBC[XX] && i != 0)
{
continue;
}
/* A shift is only useful when it is trilinic */
if (j != 0 || k != 0)
{
rvec trial;
rvec pos;
real d2old = 0;
real d2new = 0;
for (int d = 0; d < DIM; d++)
{
trial[d] = i*box[XX][d] + j*box[YY][d] + k*box[ZZ][d];
/* Choose the vector within the brick around 0,0,0 that
* will become the shortest due to shift try.
*/
if (d == pbc->dim)
{
trial[d] = 0;
pos[d] = 0;
}
else
{
if (trial[d] < 0)
{
pos[d] = std::min( pbc->hbox_diag[d], -trial[d]);
}
else
{
pos[d] = std::max(-pbc->hbox_diag[d], -trial[d]);
}
}
d2old += gmx::square(pos[d]);
d2new += gmx::square(pos[d] + trial[d]);
}
if (BOX_MARGIN*d2new < d2old)
{
/* Check if shifts with one box vector less do better */
gmx_bool bUse = TRUE;
for (int dd = 0; dd < DIM; dd++)
{
int shift = (dd == 0 ? i : (dd == 1 ? j : k));
if (shift)
{
real d2new_c = 0;
for (int d = 0; d < DIM; d++)
{
d2new_c += gmx::square(pos[d] + trial[d] - shift*box[dd][d]);
}
if (d2new_c <= BOX_MARGIN*d2new)
{
bUse = FALSE;
}
}
}
if (bUse)
{
/* Accept this shift vector. */
if (pbc->ntric_vec >= MAX_NTRICVEC)
{
fprintf(stderr, "\nWARNING: Found more than %d triclinic correction vectors, ignoring some.\n"
" There is probably something wrong with your box.\n", MAX_NTRICVEC);
pr_rvecs(stderr, 0, " Box", box, DIM);
}
else
{
copy_rvec(trial, pbc->tric_vec[pbc->ntric_vec]);
pbc->tric_shift[pbc->ntric_vec][XX] = i;
pbc->tric_shift[pbc->ntric_vec][YY] = j;
pbc->tric_shift[pbc->ntric_vec][ZZ] = k;
pbc->ntric_vec++;
if (debug)
{
fprintf(debug, " tricvec %2d = %2d %2d %2d %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f\n",
pbc->ntric_vec, i, j, k,
sqrt(d2old), sqrt(d2new),
trial[XX], trial[YY], trial[ZZ],
pos[XX], pos[YY], pos[ZZ]);
}
}
}
}
}
}
}
}
}
}
}
bool show() {
label(Far::get_msg(MSG_SFX_OPTIONS_DLG_PROFILE));
vector<wstring> profile_names;
profile_names.reserve(profiles.size());
for (unsigned i = 0; i < profiles.size(); i++) {
profile_names.push_back(profiles[i].name);
}
profile_names.push_back(wstring());
profile_ctrl_id = combo_box(profile_names, profiles.size(), 30, DIF_DROPDOWNLIST);
new_line();
separator();
new_line();
label(Far::get_msg(MSG_SFX_OPTIONS_DLG_MODULE));
vector<wstring> module_names;
const SfxModules& sfx_modules = ArcAPI::sfx();
module_names.reserve(sfx_modules.size() + 1);
unsigned name_width = 0;
for_each(sfx_modules.begin(), sfx_modules.end(), [&] (const SfxModule& sfx_module) {
wstring name = sfx_module.description();
module_names.push_back(name);
if (name_width < name.size())
name_width = name.size();
});
module_names.push_back(wstring());
module_ctrl_id = combo_box(module_names, sfx_modules.find_by_name(options.name), name_width + 6, DIF_DROPDOWNLIST);
new_line();
replace_icon_ctrl_id = check_box(Far::get_msg(MSG_SFX_OPTIONS_DLG_REPLACE_ICON), options.replace_icon);
new_line();
spacer(2);
label(Far::get_msg(MSG_SFX_OPTIONS_DLG_ICON_PATH));
icon_path_ctrl_id = history_edit_box(options.icon_path, L"arclite.icon_path", AUTO_SIZE, DIF_EDITPATH | DIF_SELECTONENTRY);
new_line();
unsigned label_len = 0;
vector<wstring> labels;
labels.push_back(Far::get_msg(MSG_SFX_OPTIONS_DLG_VER_INFO_PRODUCT_NAME));
labels.push_back(Far::get_msg(MSG_SFX_OPTIONS_DLG_VER_INFO_VERSION));
labels.push_back(Far::get_msg(MSG_SFX_OPTIONS_DLG_VER_INFO_COMPANY_NAME));
labels.push_back(Far::get_msg(MSG_SFX_OPTIONS_DLG_VER_INFO_FILE_DESCRIPTION));
labels.push_back(Far::get_msg(MSG_SFX_OPTIONS_DLG_VER_INFO_COMMENTS));
labels.push_back(Far::get_msg(MSG_SFX_OPTIONS_DLG_VER_INFO_LEGAL_COPYRIGHT));
for (unsigned i = 0; i < labels.size(); i++)
if (label_len < labels[i].size())
label_len = labels[i].size();
label_len += 2;
vector<wstring>::const_iterator label_text = labels.cbegin();
replace_version_ctrl_id = check_box(Far::get_msg(MSG_SFX_OPTIONS_DLG_REPLACE_VERSION), options.replace_version);
new_line();
spacer(2);
label(*label_text++);
pad(label_len);
ver_info_product_name_ctrl_id = edit_box(options.ver_info.product_name, AUTO_SIZE, DIF_SELECTONENTRY);
new_line();
spacer(2);
label(*label_text++);
pad(label_len);
ver_info_version_ctrl_id = edit_box(options.ver_info.version, AUTO_SIZE, DIF_SELECTONENTRY);
new_line();
spacer(2);
label(*label_text++);
pad(label_len);
ver_info_company_name_ctrl_id = edit_box(options.ver_info.company_name, AUTO_SIZE, DIF_SELECTONENTRY);
new_line();
spacer(2);
label(*label_text++);
pad(label_len);
ver_info_file_description_ctrl_id = edit_box(options.ver_info.file_description, AUTO_SIZE, DIF_SELECTONENTRY);
new_line();
spacer(2);
label(*label_text++);
pad(label_len);
ver_info_comments_ctrl_id = edit_box(options.ver_info.comments, AUTO_SIZE, DIF_SELECTONENTRY);
new_line();
spacer(2);
label(*label_text++);
pad(label_len);
ver_info_legal_copyright_ctrl_id = edit_box(options.ver_info.legal_copyright, AUTO_SIZE, DIF_SELECTONENTRY);
new_line();
label_len = 0;
labels.clear();
labels.push_back(Far::get_msg(MSG_SFX_OPTIONS_DLG_INSTALL_CONFIG_TITLE));
labels.push_back(Far::get_msg(MSG_SFX_OPTIONS_DLG_INSTALL_CONFIG_BEGIN_PROMPT));
labels.push_back(Far::get_msg(MSG_SFX_OPTIONS_DLG_INSTALL_CONFIG_PROGRESS));
labels.push_back(Far::get_msg(MSG_SFX_OPTIONS_DLG_INSTALL_CONFIG_RUN_PROGRAM));
labels.push_back(Far::get_msg(MSG_SFX_OPTIONS_DLG_INSTALL_CONFIG_DIRECTORY));
labels.push_back(Far::get_msg(MSG_SFX_OPTIONS_DLG_INSTALL_CONFIG_EXECUTE_FILE));
labels.push_back(Far::get_msg(MSG_SFX_OPTIONS_DLG_INSTALL_CONFIG_EXECUTE_PARAMETERS));
for (unsigned i = 0; i < labels.size(); i++)
if (label_len < labels[i].size())
label_len = labels[i].size();
label_len += 2;
label_text = labels.cbegin();
append_install_config_ctrl_id = check_box(Far::get_msg(MSG_SFX_OPTIONS_DLG_APPEND_INSTALL_CONFIG), options.append_install_config);
new_line();
spacer(2);
label(*label_text++);
pad(label_len);
install_config_title_ctrl_id = edit_box(options.install_config.title, AUTO_SIZE, DIF_SELECTONENTRY);
new_line();
spacer(2);
label(*label_text++);
pad(label_len);
install_config_begin_prompt_ctrl_id = edit_box(options.install_config.begin_prompt, AUTO_SIZE, DIF_SELECTONENTRY);
new_line();
spacer(2);
label(*label_text++);
pad(label_len);
TriState value;
if (options.install_config.progress == L"yes")
value = triTrue;
else if (options.install_config.progress == L"no")
value = triFalse;
else
value = triUndef;
install_config_progress_ctrl_id = check_box3(wstring(), value);
new_line();
spacer(2);
label(*label_text++);
pad(label_len);
install_config_run_program_ctrl_id = edit_box(options.install_config.run_program, AUTO_SIZE, DIF_SELECTONENTRY);
new_line();
spacer(2);
label(*label_text++);
pad(label_len);
install_config_directory_ctrl_id = edit_box(options.install_config.directory, AUTO_SIZE, DIF_SELECTONENTRY);
new_line();
spacer(2);
label(*label_text++);
pad(label_len);
install_config_execute_file_ctrl_id = edit_box(options.install_config.execute_file, AUTO_SIZE, DIF_SELECTONENTRY);
new_line();
spacer(2);
label(*label_text++);
pad(label_len);
install_config_execute_parameters_ctrl_id = edit_box(options.install_config.execute_parameters, AUTO_SIZE, DIF_SELECTONENTRY);
new_line();
separator();
new_line();
ok_ctrl_id = def_button(Far::get_msg(MSG_BUTTON_OK), DIF_CENTERGROUP);
cancel_ctrl_id = button(Far::get_msg(MSG_BUTTON_CANCEL), DIF_CENTERGROUP);
new_line();
int item = Far::Dialog::show();
return (item != -1) && (item != cancel_ctrl_id);
}
static void low_set_pbc(t_pbc *pbc, int ePBC, ivec *dd_nc, matrix box)
{
int order[5] = {0, -1, 1, -2, 2};
int ii, jj, kk, i, j, k, d, dd, jc, kc, npbcdim, shift;
ivec bPBC;
real d2old, d2new, d2new_c;
rvec trial, pos;
gmx_bool bXY, bUse;
const char *ptr;
pbc->ndim_ePBC = ePBC2npbcdim(ePBC);
copy_mat(box, pbc->box);
pbc->bLimitDistance = FALSE;
pbc->max_cutoff2 = 0;
pbc->dim = -1;
for (i = 0; (i < DIM); i++)
{
pbc->fbox_diag[i] = box[i][i];
pbc->hbox_diag[i] = pbc->fbox_diag[i]*0.5;
pbc->mhbox_diag[i] = -pbc->hbox_diag[i];
}
ptr = check_box(ePBC, box);
if (ePBC == epbcNONE)
{
pbc->ePBCDX = epbcdxNOPBC;
}
else if (ptr)
{
fprintf(stderr, "Warning: %s\n", ptr);
pr_rvecs(stderr, 0, " Box", box, DIM);
fprintf(stderr, " Can not fix pbc.\n");
pbc->ePBCDX = epbcdxUNSUPPORTED;
pbc->bLimitDistance = TRUE;
pbc->limit_distance2 = 0;
}
else
{
if (ePBC == epbcSCREW && dd_nc)
{
/* This combinated should never appear here */
gmx_incons("low_set_pbc called with screw pbc and dd_nc != NULL");
}
npbcdim = 0;
for (i = 0; i < DIM; i++)
{
if ((dd_nc && (*dd_nc)[i] > 1) || (ePBC == epbcXY && i == ZZ))
{
bPBC[i] = 0;
}
else
{
bPBC[i] = 1;
npbcdim++;
}
}
switch (npbcdim)
{
case 1:
/* 1D pbc is not an mdp option and it is therefore only used
* with single shifts.
*/
pbc->ePBCDX = epbcdx1D_RECT;
for (i = 0; i < DIM; i++)
{
if (bPBC[i])
{
pbc->dim = i;
}
}
for (i = 0; i < pbc->dim; i++)
{
if (pbc->box[pbc->dim][i] != 0)
{
pbc->ePBCDX = epbcdx1D_TRIC;
}
}
break;
case 2:
pbc->ePBCDX = epbcdx2D_RECT;
for (i = 0; i < DIM; i++)
{
if (!bPBC[i])
{
pbc->dim = i;
}
}
for (i = 0; i < DIM; i++)
{
if (bPBC[i])
{
for (j = 0; j < i; j++)
{
if (pbc->box[i][j] != 0)
{
pbc->ePBCDX = epbcdx2D_TRIC;
}
}
}
}
break;
case 3:
if (ePBC != epbcSCREW)
{
if (TRICLINIC(box))
{
pbc->ePBCDX = epbcdxTRICLINIC;
}
else
{
pbc->ePBCDX = epbcdxRECTANGULAR;
}
}
else
{
pbc->ePBCDX = (box[ZZ][YY] == 0 ? epbcdxSCREW_RECT : epbcdxSCREW_TRIC);
if (pbc->ePBCDX == epbcdxSCREW_TRIC)
{
fprintf(stderr,
"Screw pbc is not yet implemented for triclinic boxes.\n"
"Can not fix pbc.\n");
pbc->ePBCDX = epbcdxUNSUPPORTED;
}
}
break;
default:
gmx_fatal(FARGS, "Incorrect number of pbc dimensions with DD: %d",
npbcdim);
}
pbc->max_cutoff2 = max_cutoff2(ePBC, box);
if (pbc->ePBCDX == epbcdxTRICLINIC ||
pbc->ePBCDX == epbcdx2D_TRIC ||
pbc->ePBCDX == epbcdxSCREW_TRIC)
{
if (debug)
{
pr_rvecs(debug, 0, "Box", box, DIM);
fprintf(debug, "max cutoff %.3f\n", sqrt(pbc->max_cutoff2));
}
pbc->ntric_vec = 0;
/* We will only use single shifts, but we will check a few
* more shifts to see if there is a limiting distance
* above which we can not be sure of the correct distance.
*/
for (kk = 0; kk < 5; kk++)
{
k = order[kk];
if (!bPBC[ZZ] && k != 0)
{
continue;
}
for (jj = 0; jj < 5; jj++)
{
j = order[jj];
if (!bPBC[YY] && j != 0)
{
continue;
}
for (ii = 0; ii < 3; ii++)
{
i = order[ii];
if (!bPBC[XX] && i != 0)
{
continue;
}
/* A shift is only useful when it is trilinic */
if (j != 0 || k != 0)
{
d2old = 0;
d2new = 0;
for (d = 0; d < DIM; d++)
{
trial[d] = i*box[XX][d] + j*box[YY][d] + k*box[ZZ][d];
/* Choose the vector within the brick around 0,0,0 that
* will become the shortest due to shift try.
*/
if (d == pbc->dim)
{
trial[d] = 0;
pos[d] = 0;
}
else
{
if (trial[d] < 0)
{
pos[d] = min( pbc->hbox_diag[d], -trial[d]);
}
else
{
pos[d] = max(-pbc->hbox_diag[d], -trial[d]);
}
}
d2old += sqr(pos[d]);
d2new += sqr(pos[d] + trial[d]);
}
if (BOX_MARGIN*d2new < d2old)
{
if (j < -1 || j > 1 || k < -1 || k > 1)
{
/* Check if there is a single shift vector
* that decreases this distance even more.
*/
jc = 0;
kc = 0;
if (j < -1 || j > 1)
{
jc = j/2;
}
if (k < -1 || k > 1)
{
kc = k/2;
}
d2new_c = 0;
for (d = 0; d < DIM; d++)
{
d2new_c += sqr(pos[d] + trial[d]
- jc*box[YY][d] - kc*box[ZZ][d]);
}
if (d2new_c > BOX_MARGIN*d2new)
{
/* Reject this shift vector, as there is no a priori limit
* to the number of shifts that decrease distances.
*/
if (!pbc->bLimitDistance || d2new < pbc->limit_distance2)
{
pbc->limit_distance2 = d2new;
}
pbc->bLimitDistance = TRUE;
}
}
else
{
/* Check if shifts with one box vector less do better */
bUse = TRUE;
for (dd = 0; dd < DIM; dd++)
{
shift = (dd == 0 ? i : (dd == 1 ? j : k));
if (shift)
{
d2new_c = 0;
for (d = 0; d < DIM; d++)
{
d2new_c += sqr(pos[d] + trial[d] - shift*box[dd][d]);
}
if (d2new_c <= BOX_MARGIN*d2new)
{
bUse = FALSE;
}
}
}
if (bUse)
{
/* Accept this shift vector. */
if (pbc->ntric_vec >= MAX_NTRICVEC)
{
fprintf(stderr, "\nWARNING: Found more than %d triclinic correction vectors, ignoring some.\n"
" There is probably something wrong with your box.\n", MAX_NTRICVEC);
pr_rvecs(stderr, 0, " Box", box, DIM);
}
else
{
copy_rvec(trial, pbc->tric_vec[pbc->ntric_vec]);
pbc->tric_shift[pbc->ntric_vec][XX] = i;
pbc->tric_shift[pbc->ntric_vec][YY] = j;
pbc->tric_shift[pbc->ntric_vec][ZZ] = k;
pbc->ntric_vec++;
}
}
}
if (debug)
{
fprintf(debug, " tricvec %2d = %2d %2d %2d %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f\n",
pbc->ntric_vec, i, j, k,
sqrt(d2old), sqrt(d2new),
trial[XX], trial[YY], trial[ZZ],
pos[XX], pos[YY], pos[ZZ]);
}
}
}
}
}
}
}
}
}