}
-static void check_gbsa_params(t_inputrec *ir, gpp_atomtype_t atype)
+static void check_gbsa_params(gpp_atomtype_t atype)
{
int nmiss, i;
if (ir->implicit_solvent != eisNO)
{
/* Now we have renumbered the atom types, we can check the GBSA params */
- check_gbsa_params(ir, atype);
+ check_gbsa_params(atype);
/* Check that all atoms that have charge and/or LJ-parameters also have
* sensible GB-parameters
return d;
}
-static void sort_pdbatoms(int nrtp, t_restp restp[], t_hackblock hb[],
+static void sort_pdbatoms(t_restp restp[],
int natoms, t_atoms **pdbaptr, rvec **x,
t_blocka *block, char ***gnames)
{
{
block = new_blocka();
snew(gnames, 1);
- sort_pdbatoms(pdba->nres, restp_chain, hb_chain,
- natom, &pdba, &x, block, &gnames);
+ sort_pdbatoms(restp_chain, natom, &pdba, &x, block, &gnames);
natom = remove_duplicate_atoms(pdba, x, bVerbose);
if (ftp2bSet(efNDX, NFILE, fnm))
{
cmp_real(fp, "ir->adress->ex_forcecap", -1, ad1->ex_forcecap, ad2->ex_forcecap, ftol, abstol);
}
-static void cmp_pull(FILE *fp, t_pull *pull1, t_pull *pull2, real ftol, real abstol)
+static void cmp_pull(FILE *fp)
{
fprintf(fp, "WARNING: Both files use COM pulling, but comparing of the pull struct is not implemented (yet). The pull parameters could be the same or different.\n");
}
cmp_int(fp, "inputrec->ePull", -1, ir1->ePull, ir2->ePull);
if (ir1->ePull == ir2->ePull && ir1->ePull != epullNO)
{
- cmp_pull(fp, ir1->pull, ir2->pull, ftol, abstol);
+ cmp_pull(fp);
}
cmp_int(fp, "inputrec->eDisre", -1, ir1->eDisre, ir2->eDisre);
static void cmp_energies(FILE *fp, int step1, int step2,
t_energy e1[], t_energy e2[],
- gmx_enxnm_t *enm1, gmx_enxnm_t *enm2,
+ gmx_enxnm_t *enm1,
real ftol, real abstol,
int nre, int *ind1, int *ind2, int maxener)
{
if ((fr1->nre >= nre) && (fr2->nre >= nre))
{
cmp_energies(stdout, fr1->step, fr1->step, fr1->ener, fr2->ener,
- enm1, enm2, ftol, abstol, nre, ind1, ind2, maxener);
+ enm1, ftol, abstol, nre, ind1, ind2, maxener);
}
/*cmp_disres(fr1,fr2,ftol,abstol);*/
cmp_eblocks(fr1, fr2, ftol, abstol);
mtop->natoms = top.atoms.nr;
}
-static void zeroq(int n, atom_id index[], gmx_mtop_t *mtop)
+static void zeroq(atom_id index[], gmx_mtop_t *mtop)
{
int mt, i;
}
else if (bZeroQ)
{
- zeroq(gnx, index, &mtop);
+ zeroq(index, &mtop);
fprintf(stderr, "Zero-ing charges for group %s\n", grpname);
}
else
/* generate the list of membrane molecules that overlap with the molecule to be embedded. *
* The molecule to be embedded is already reduced in size. */
static int gen_rm_list(rm_t *rm_p, t_block *ins_at, t_block *rest_at, t_pbc *pbc, gmx_mtop_t *mtop,
- rvec *r, rvec *r_ins, mem_t *mem_p, pos_ins_t *pos_ins, real probe_rad,
+ rvec *r, mem_t *mem_p, pos_ins_t *pos_ins, real probe_rad,
int low_up_rm, gmx_bool bALLOW_ASYMMETRY)
{
int i, j, k, l, at, at2, mol_id;
}
/*remove all lipids and waters overlapping and update all important structures (e.g. state and mtop)*/
-static void rm_group(t_inputrec *ir, gmx_groups_t *groups, gmx_mtop_t *mtop, rm_t *rm_p, t_state *state,
+static void rm_group(gmx_groups_t *groups, gmx_mtop_t *mtop, rm_t *rm_p, t_state *state,
t_block *ins_at, pos_ins_t *pos_ins)
{
int i, j, k, n, rm, mol_id, at, block;
}
/* Write a topology where the number of molecules is correct for the system after embedding */
-static void top_update(const char *topfile, char *ins, rm_t *rm_p, gmx_mtop_t *mtop)
+static void top_update(const char *topfile, rm_t *rm_p, gmx_mtop_t *mtop)
{
#define TEMP_FILENM "temp.top"
int bMolecules = 0;
set_pbc(pbc, inputrec->ePBC, state->box);
snew(rm_p, 1);
- lip_rm = gen_rm_list(rm_p, ins_at, rest_at, pbc, mtop, state->x, r_ins, mem_p, pos_ins,
+ lip_rm = gen_rm_list(rm_p, ins_at, rest_at, pbc, mtop, state->x, mem_p, pos_ins,
probe_rad, low_up_rm, bALLOW_ASYMMETRY);
lip_rm -= low_up_rm;
}
/*remove all lipids and waters overlapping and update all important structures*/
- rm_group(inputrec, groups, mtop, rm_p, state, ins_at, pos_ins);
+ rm_group(groups, mtop, rm_p, state, ins_at, pos_ins);
rm_bonded_at = rm_bonded(ins_at, mtop);
if (rm_bonded_at != ins_at->nr)
if (ftp2bSet(efTOP, nfile, fnm))
{
- top_update(opt2fn("-mp", nfile, fnm), ins, rm_p, mtop);
+ top_update(opt2fn("-mp", nfile, fnm), rm_p, mtop);
}
sfree(pbc);
} t_gmx_repl_ex;
-static gmx_bool repl_quantity(FILE *fplog, const gmx_multisim_t *ms,
+static gmx_bool repl_quantity(const gmx_multisim_t *ms,
struct gmx_repl_ex *re, int ere, real q)
{
real *qall;
}
re->type = -1;
- bTemp = repl_quantity(fplog, ms, re, ereTEMP, re->temp);
+ bTemp = repl_quantity(ms, re, ereTEMP, re->temp);
if (ir->efep != efepNO)
{
- bLambda = repl_quantity(fplog, ms, re, ereLAMBDA, (real)ir->fepvals->init_fep_state);
+ bLambda = repl_quantity(ms, re, ereLAMBDA, (real)ir->fepvals->init_fep_state);
}
if (re->type == -1) /* nothing was assigned */
{
}
}
-static void print_transition_matrix(FILE *fplog, const char *leg, int n, int **nmoves, int *nattempt)
+static void print_transition_matrix(FILE *fplog, int n, int **nmoves, int *nattempt)
{
int i, j, ntot;
float Tprint;
fprintf(fplog, "\n");
}
-static void print_allswitchind(FILE *fplog, int n, int *ind, int *pind, int *allswaps, int *tmpswap)
+static void print_allswitchind(FILE *fplog, int n, int *pind, int *allswaps, int *tmpswap)
{
int i;
}
}
re->nattempt[0]++; /* keep track of total permutation trials here */
- print_allswitchind(fplog, re->nrepl, re->ind, pind, re->allswaps, re->tmpswap);
+ print_allswitchind(fplog, re->nrepl, pind, re->allswaps, re->tmpswap);
}
else
{
}
static void
-cyclic_decomposition(FILE *fplog,
- const int *destinations,
+cyclic_decomposition(const int *destinations,
int **cyclic,
gmx_bool *incycle,
const int nrepl,
/* Identify the cyclic decomposition of the permutation (very
* fast if neighbor replica exchange). */
- cyclic_decomposition(fplog, destinations, cyclic, incycle, nrepl, maxswap);
+ cyclic_decomposition(destinations, cyclic, incycle, nrepl, maxswap);
/* Now translate the decomposition into a replica exchange
* order at each step. */
fprintf(fplog, "\n");
}
/* print the transition matrix */
- print_transition_matrix(fplog, "", re->nrepl, re->nmoves, re->nattempt);
+ print_transition_matrix(fplog, re->nrepl, re->nmoves, re->nattempt);
}