int main() { put_structure("h", 2, 3); /* ?- X3 = h */ set_variable(2); /* (Z, */ set_variable(5); /* W), */ put_structure("f", 1, 4); /* X4 = f */ set_value(5); /* (W), */ put_structure("p", 3, 1); /* X1 = p */ set_value(2); /* (Z, */ set_value(3); /* X3, */ set_value(4); /* X4). */ print_register(1); /* drukowanie X1 */ dump_heap(); fail = false; get_structure("p", 3, 1); /* X1 = p */ unify_variable(2); /* (X2, */ unify_variable(3); /* X3, */ unify_variable(4); /* Y), */ get_structure("f", 1, 2); /* X2 = f */ unify_variable(5); /* (X), */ get_structure("h", 2, 3); /* X3 = h */ unify_value(4); /* (Y, */ unify_variable(6); /* X6), */ get_structure("f", 1, 6); /* X6 = f */ unify_variable(7); /* (X7), */ get_structure("a", 0, 7); /* X7 = a */ printf("fail = %d\n", (int)fail); print_register(1); /* drukowanie X1 */ dump_heap(); return 0; }
int main(int arfc, char **arfv) { /* arfv[1] is the input file with sequence on the first line and constraint on the second line takes constraints of the ( ) and [ ] variety arfv[2] is the list of structures output by subopt to check */ if (arfc != 3) { usage(arfv[0]); exit(1); } FILE *fin, *fout; int i, *pos, *neg; char *C; if (arfv[1][0] == '-' && arfv[1][1] == '\0') fin = stdin; else if (!(fin = fopen(arfv[1], "rb"))) { fprintf(stderr, "unable to open %s, bailing\n", arfv[1]); exit(1); } if (arfv[2][0] == '-' && arfv[2][1] == '\0') fout = stdin; else if (!(fout = fopen(arfv[2], "rb"))) { fprintf(stderr, "unable to open %s, bailing\n", arfv[2]); if (stdin != fin) fclose(fin); exit(1); } skip_sequence(fin); C = get_structure(fin); make_pair_table(C, &pos, &neg); printf("constraint string:\n%s\n", C); free(C); printf("forced pairs:"); for (i = 1; i <= len; ++i) { if (pos[i]) printf(" (%d,%d)", i, pos[i]); } printf("\n"); printf("forbidden pairs:"); for (i = 1; i <= len; ++i) { if (neg[i]) printf(" (%d,%d)", i, neg[i]); } printf("\n"); while (!feof(fout)) { char *s; int *ps; s = get_structure(fout); make_pair_table(s, &ps, NULL); if (s[0]) { compare(s, ps, pos, neg); } free(s); free(ps); } free(pos); free(neg); if (stdin != fin) fclose(fin); if (stdin != fin) fclose(fout); return 0; }
int gmx_make_edi(int argc, char *argv[]) { static const char *desc[] = { "[THISMODULE] generates an essential dynamics (ED) sampling input file to be used with [TT]mdrun[tt]", "based on eigenvectors of a covariance matrix ([gmx-covar]) or from a", "normal modes analysis ([gmx-nmeig]).", "ED sampling can be used to manipulate the position along collective coordinates", "(eigenvectors) of (biological) macromolecules during a simulation. Particularly,", "it may be used to enhance the sampling efficiency of MD simulations by stimulating", "the system to explore new regions along these collective coordinates. A number", "of different algorithms are implemented to drive the system along the eigenvectors", "([TT]-linfix[tt], [TT]-linacc[tt], [TT]-radfix[tt], [TT]-radacc[tt], [TT]-radcon[tt]),", "to keep the position along a certain (set of) coordinate(s) fixed ([TT]-linfix[tt]),", "or to only monitor the projections of the positions onto", "these coordinates ([TT]-mon[tt]).[PAR]", "References:[BR]", "A. Amadei, A.B.M. Linssen, B.L. de Groot, D.M.F. van Aalten and ", "H.J.C. Berendsen; An efficient method for sampling the essential subspace ", "of proteins., J. Biomol. Struct. Dyn. 13:615-626 (1996)[BR]", "B.L. de Groot, A. Amadei, D.M.F. van Aalten and H.J.C. Berendsen; ", "Towards an exhaustive sampling of the configurational spaces of the ", "two forms of the peptide hormone guanylin,", "J. Biomol. Struct. Dyn. 13 : 741-751 (1996)[BR]", "B.L. de Groot, A.Amadei, R.M. Scheek, N.A.J. van Nuland and H.J.C. Berendsen; ", "An extended sampling of the configurational space of HPr from E. coli", "Proteins: Struct. Funct. Gen. 26: 314-322 (1996)", "[PAR]You will be prompted for one or more index groups that correspond to the eigenvectors,", "reference structure, target positions, etc.[PAR]", "[TT]-mon[tt]: monitor projections of the coordinates onto selected eigenvectors.[PAR]", "[TT]-linfix[tt]: perform fixed-step linear expansion along selected eigenvectors.[PAR]", "[TT]-linacc[tt]: perform acceptance linear expansion along selected eigenvectors.", "(steps in the desired directions will be accepted, others will be rejected).[PAR]", "[TT]-radfix[tt]: perform fixed-step radius expansion along selected eigenvectors.[PAR]", "[TT]-radacc[tt]: perform acceptance radius expansion along selected eigenvectors.", "(steps in the desired direction will be accepted, others will be rejected).", "[BB]Note:[bb] by default the starting MD structure will be taken as origin of the first", "expansion cycle for radius expansion. If [TT]-ori[tt] is specified, you will be able", "to read in a structure file that defines an external origin.[PAR]", "[TT]-radcon[tt]: perform acceptance radius contraction along selected eigenvectors", "towards a target structure specified with [TT]-tar[tt].[PAR]", "NOTE: each eigenvector can be selected only once. [PAR]", "[TT]-outfrq[tt]: frequency (in steps) of writing out projections etc. to [TT].xvg[tt] file[PAR]", "[TT]-slope[tt]: minimal slope in acceptance radius expansion. A new expansion", "cycle will be started if the spontaneous increase of the radius (in nm/step)", "is less than the value specified.[PAR]", "[TT]-maxedsteps[tt]: maximum number of steps per cycle in radius expansion", "before a new cycle is started.[PAR]", "Note on the parallel implementation: since ED sampling is a 'global' thing", "(collective coordinates etc.), at least on the 'protein' side, ED sampling", "is not very parallel-friendly from an implementation point of view. Because", "parallel ED requires some extra communication, expect the performance to be", "lower as in a free MD simulation, especially on a large number of nodes and/or", "when the ED group contains a lot of atoms. [PAR]", "Please also note that if your ED group contains more than a single protein,", "then the [TT].tpr[tt] file must contain the correct PBC representation of the ED group.", "Take a look on the initial RMSD from the reference structure, which is printed", "out at the start of the simulation; if this is much higher than expected, one", "of the ED molecules might be shifted by a box vector. [PAR]", "All ED-related output of [TT]mdrun[tt] (specify with [TT]-eo[tt]) is written to a [TT].xvg[tt] file", "as a function of time in intervals of OUTFRQ steps.[PAR]", "[BB]Note[bb] that you can impose multiple ED constraints and flooding potentials in", "a single simulation (on different molecules) if several [TT].edi[tt] files were concatenated", "first. The constraints are applied in the order they appear in the [TT].edi[tt] file. ", "Depending on what was specified in the [TT].edi[tt] input file, the output file contains for each ED dataset[PAR]", "[TT]*[tt] the RMSD of the fitted molecule to the reference structure (for atoms involved in fitting prior to calculating the ED constraints)[BR]", "[TT]*[tt] projections of the positions onto selected eigenvectors[BR]", "[PAR][PAR]", "FLOODING:[PAR]", "with [TT]-flood[tt], you can specify which eigenvectors are used to compute a flooding potential,", "which will lead to extra forces expelling the structure out of the region described", "by the covariance matrix. If you switch -restrain the potential is inverted and the structure", "is kept in that region.", "[PAR]", "The origin is normally the average structure stored in the [TT]eigvec.trr[tt] file.", "It can be changed with [TT]-ori[tt] to an arbitrary position in configuration space.", "With [TT]-tau[tt], [TT]-deltaF0[tt], and [TT]-Eflnull[tt] you control the flooding behaviour.", "Efl is the flooding strength, it is updated according to the rule of adaptive flooding.", "Tau is the time constant of adaptive flooding, high [GRK]tau[grk] means slow adaption (i.e. growth). ", "DeltaF0 is the flooding strength you want to reach after tau ps of simulation.", "To use constant Efl set [TT]-tau[tt] to zero.", "[PAR]", "[TT]-alpha[tt] is a fudge parameter to control the width of the flooding potential. A value of 2 has been found", "to give good results for most standard cases in flooding of proteins.", "[GRK]alpha[grk] basically accounts for incomplete sampling, if you sampled further the width of the ensemble would", "increase, this is mimicked by [GRK]alpha[grk] > 1.", "For restraining, [GRK]alpha[grk] < 1 can give you smaller width in the restraining potential.", "[PAR]", "RESTART and FLOODING:", "If you want to restart a crashed flooding simulation please find the values deltaF and Efl in", "the output file and manually put them into the [TT].edi[tt] file under DELTA_F0 and EFL_NULL." }; /* Save all the params in this struct and then save it in an edi file. * ignoring fields nmass,massnrs,mass,tmass,nfit,fitnrs,edo */ static t_edipar edi_params; enum { evStepNr = evRADFIX + 1 }; static const char* evSelections[evNr] = {NULL, NULL, NULL, NULL, NULL, NULL}; static const char* evOptions[evNr] = {"-linfix", "-linacc", "-flood", "-radfix", "-radacc", "-radcon", "-mon"}; static const char* evParams[evStepNr] = {NULL, NULL}; static const char* evStepOptions[evStepNr] = {"-linstep", "-accdir", "-not_used", "-radstep"}; static const char* ConstForceStr; static real * evStepList[evStepNr]; static real radstep = 0.0; static real deltaF0 = 150; static real deltaF = 0; static real tau = .1; static real constEfl = 0.0; static real alpha = 1; static int eqSteps = 0; static int * listen[evNr]; static real T = 300.0; const real kB = 2.5 / 300.0; /* k_boltzmann in MD units */ static gmx_bool bRestrain = FALSE; static gmx_bool bHesse = FALSE; static gmx_bool bHarmonic = FALSE; t_pargs pa[] = { { "-mon", FALSE, etSTR, {&evSelections[evMON]}, "Indices of eigenvectors for projections of x (e.g. 1,2-5,9) or 1-100:10 means 1 11 21 31 ... 91" }, { "-linfix", FALSE, etSTR, {&evSelections[0]}, "Indices of eigenvectors for fixed increment linear sampling" }, { "-linacc", FALSE, etSTR, {&evSelections[1]}, "Indices of eigenvectors for acceptance linear sampling" }, { "-radfix", FALSE, etSTR, {&evSelections[3]}, "Indices of eigenvectors for fixed increment radius expansion" }, { "-radacc", FALSE, etSTR, {&evSelections[4]}, "Indices of eigenvectors for acceptance radius expansion" }, { "-radcon", FALSE, etSTR, {&evSelections[5]}, "Indices of eigenvectors for acceptance radius contraction" }, { "-flood", FALSE, etSTR, {&evSelections[2]}, "Indices of eigenvectors for flooding"}, { "-outfrq", FALSE, etINT, {&edi_params.outfrq}, "Freqency (in steps) of writing output in [TT].xvg[tt] file" }, { "-slope", FALSE, etREAL, { &edi_params.slope}, "Minimal slope in acceptance radius expansion"}, { "-linstep", FALSE, etSTR, {&evParams[0]}, "Stepsizes (nm/step) for fixed increment linear sampling (put in quotes! \"1.0 2.3 5.1 -3.1\")"}, { "-accdir", FALSE, etSTR, {&evParams[1]}, "Directions for acceptance linear sampling - only sign counts! (put in quotes! \"-1 +1 -1.1\")"}, { "-radstep", FALSE, etREAL, {&radstep}, "Stepsize (nm/step) for fixed increment radius expansion"}, { "-maxedsteps", FALSE, etINT, {&edi_params.maxedsteps}, "Maximum number of steps per cycle" }, { "-eqsteps", FALSE, etINT, {&eqSteps}, "Number of steps to run without any perturbations "}, { "-deltaF0", FALSE, etREAL, {&deltaF0}, "Target destabilization energy for flooding"}, { "-deltaF", FALSE, etREAL, {&deltaF}, "Start deltaF with this parameter - default 0, nonzero values only needed for restart"}, { "-tau", FALSE, etREAL, {&tau}, "Coupling constant for adaption of flooding strength according to deltaF0, 0 = infinity i.e. constant flooding strength"}, { "-Eflnull", FALSE, etREAL, {&constEfl}, "The starting value of the flooding strength. The flooding strength is updated " "according to the adaptive flooding scheme. For a constant flooding strength use [TT]-tau[tt] 0. "}, { "-T", FALSE, etREAL, {&T}, "T is temperature, the value is needed if you want to do flooding "}, { "-alpha", FALSE, etREAL, {&alpha}, "Scale width of gaussian flooding potential with alpha^2 "}, { "-restrain", FALSE, etBOOL, {&bRestrain}, "Use the flooding potential with inverted sign -> effects as quasiharmonic restraining potential"}, { "-hessian", FALSE, etBOOL, {&bHesse}, "The eigenvectors and eigenvalues are from a Hessian matrix"}, { "-harmonic", FALSE, etBOOL, {&bHarmonic}, "The eigenvalues are interpreted as spring constant"}, { "-constF", FALSE, etSTR, {&ConstForceStr}, "Constant force flooding: manually set the forces for the eigenvectors selected with -flood " "(put in quotes! \"1.0 2.3 5.1 -3.1\"). No other flooding parameters are needed when specifying the forces directly."} }; #define NPA asize(pa) rvec *xref1; int nvec1, *eignr1 = NULL; rvec *xav1, **eigvec1 = NULL; t_atoms *atoms = NULL; int nav; /* Number of atoms in the average structure */ char *grpname; const char *indexfile; int i; atom_id *index, *ifit; int nfit; /* Number of atoms in the reference/fit structure */ int ev_class; /* parameter _class i.e. evMON, evRADFIX etc. */ int nvecs; real *eigval1 = NULL; /* in V3.3 this is parameter of read_eigenvectors */ const char *EdiFile; const char *TargetFile; const char *OriginFile; const char *EigvecFile; output_env_t oenv; /*to read topology file*/ t_topology top; int ePBC; char title[STRLEN]; matrix topbox; rvec *xtop; gmx_bool bTop, bFit1; t_filenm fnm[] = { { efTRN, "-f", "eigenvec", ffREAD }, { efXVG, "-eig", "eigenval", ffOPTRD }, { efTPS, NULL, NULL, ffREAD }, { efNDX, NULL, NULL, ffOPTRD }, { efSTX, "-tar", "target", ffOPTRD}, { efSTX, "-ori", "origin", ffOPTRD}, { efEDI, "-o", "sam", ffWRITE } }; #define NFILE asize(fnm) edi_params.outfrq = 100; edi_params.slope = 0.0; edi_params.maxedsteps = 0; if (!parse_common_args(&argc, argv, 0, NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv)) { return 0; } indexfile = ftp2fn_null(efNDX, NFILE, fnm); EdiFile = ftp2fn(efEDI, NFILE, fnm); TargetFile = opt2fn_null("-tar", NFILE, fnm); OriginFile = opt2fn_null("-ori", NFILE, fnm); for (ev_class = 0; ev_class < evNr; ++ev_class) { if (opt2parg_bSet(evOptions[ev_class], NPA, pa)) { /*get list of eigenvectors*/ nvecs = sscan_list(&(listen[ev_class]), opt2parg_str(evOptions[ev_class], NPA, pa), evOptions[ev_class]); if (ev_class < evStepNr-2) { /*if apropriate get list of stepsizes for these eigenvectors*/ if (opt2parg_bSet(evStepOptions[ev_class], NPA, pa)) { evStepList[ev_class] = scan_vecparams(opt2parg_str(evStepOptions[ev_class], NPA, pa), evStepOptions[ev_class], nvecs); } else /*if list is not given fill with zeros */ { snew(evStepList[ev_class], nvecs); for (i = 0; i < nvecs; i++) { evStepList[ev_class][i] = 0.0; } } } else if (ev_class == evRADFIX) { snew(evStepList[ev_class], nvecs); for (i = 0; i < nvecs; i++) { evStepList[ev_class][i] = radstep; } } else if (ev_class == evFLOOD) { snew(evStepList[ev_class], nvecs); /* Are we doing constant force flooding? In that case, we read in * the fproj values from the command line */ if (opt2parg_bSet("-constF", NPA, pa)) { evStepList[ev_class] = scan_vecparams(opt2parg_str("-constF", NPA, pa), "-constF", nvecs); } } else { }; /*to avoid ambiguity */ } else /* if there are no eigenvectors for this option set list to zero */ { listen[ev_class] = NULL; snew(listen[ev_class], 1); listen[ev_class][0] = 0; } } /* print the interpreted list of eigenvectors - to give some feedback*/ for (ev_class = 0; ev_class < evNr; ++ev_class) { printf("Eigenvector list %7s consists of the indices: ", evOptions[ev_class]); i = 0; while (listen[ev_class][i]) { printf("%d ", listen[ev_class][i++]); } printf("\n"); } EigvecFile = NULL; EigvecFile = opt2fn("-f", NFILE, fnm); /*read eigenvectors from eigvec.trr*/ read_eigenvectors(EigvecFile, &nav, &bFit1, &xref1, &edi_params.fitmas, &xav1, &edi_params.pcamas, &nvec1, &eignr1, &eigvec1, &eigval1); bTop = read_tps_conf(ftp2fn(efTPS, NFILE, fnm), title, &top, &ePBC, &xtop, NULL, topbox, 0); atoms = &top.atoms; printf("\nSelect an index group of %d elements that corresponds to the eigenvectors\n", nav); get_index(atoms, indexfile, 1, &i, &index, &grpname); /*if indexfile != NULL parameter 'atoms' is ignored */ if (i != nav) { gmx_fatal(FARGS, "you selected a group with %d elements instead of %d", i, nav); } printf("\n"); if (xref1 == NULL) { if (bFit1) { /* if g_covar used different coordinate groups to fit and to do the PCA */ printf("\nNote: the structure in %s should be the same\n" " as the one used for the fit in g_covar\n", ftp2fn(efTPS, NFILE, fnm)); printf("\nSelect the index group that was used for the least squares fit in g_covar\n"); } else { printf("\nNote: Apparently no fitting was done in g_covar.\n" " However, you need to select a reference group for fitting in mdrun\n"); } get_index(atoms, indexfile, 1, &nfit, &ifit, &grpname); snew(xref1, nfit); for (i = 0; i < nfit; i++) { copy_rvec(xtop[ifit[i]], xref1[i]); } } else { nfit = nav; ifit = index; } if (opt2parg_bSet("-constF", NPA, pa)) { /* Constant force flooding is special: Most of the normal flooding * options are not needed. */ edi_params.flood.bConstForce = TRUE; } else { /* For normal flooding read eigenvalues and store them in evSteplist[evFLOOD] */ if (listen[evFLOOD][0] != 0) { read_eigenvalues(listen[evFLOOD], opt2fn("-eig", NFILE, fnm), evStepList[evFLOOD], bHesse, kB*T); } edi_params.flood.tau = tau; edi_params.flood.deltaF0 = deltaF0; edi_params.flood.deltaF = deltaF; edi_params.presteps = eqSteps; edi_params.flood.kT = kB*T; edi_params.flood.bHarmonic = bHarmonic; if (bRestrain) { /* Trick: invert sign of Efl and alpha2 then this will give the same sign in the exponential and inverted sign outside */ edi_params.flood.constEfl = -constEfl; edi_params.flood.alpha2 = -sqr(alpha); } else { edi_params.flood.constEfl = constEfl; edi_params.flood.alpha2 = sqr(alpha); } } edi_params.ned = nav; /*number of system atoms */ edi_params.nini = atoms->nr; /*store reference and average structure in edi_params*/ make_t_edx(&edi_params.sref, nfit, xref1, ifit ); make_t_edx(&edi_params.sav, nav, xav1, index); /* Store target positions in edi_params */ if (opt2bSet("-tar", NFILE, fnm)) { if (0 != listen[evFLOOD][0]) { fprintf(stderr, "\nNote: Providing a TARGET structure has no effect when using flooding.\n" " You may want to use -ori to define the flooding potential center.\n\n"); } get_structure(atoms, indexfile, TargetFile, &edi_params.star, nfit, ifit, nav, index); } else { make_t_edx(&edi_params.star, 0, NULL, index); } /* Store origin positions */ if (opt2bSet("-ori", NFILE, fnm)) { get_structure(atoms, indexfile, OriginFile, &edi_params.sori, nfit, ifit, nav, index); } else { make_t_edx(&edi_params.sori, 0, NULL, index); } /* Write edi-file */ write_the_whole_thing(gmx_ffopen(EdiFile, "w"), &edi_params, eigvec1, nvec1, listen, evStepList); return 0; }