void read_adressparams(int *ninp_p,t_inpfile **inp_p,t_adress *adress, warninp_t wi)
{
int nadress_refs,i;
const char *tmp;
char *ptr1[MAXPTR];
int ninp;
t_inpfile *inp;
ninp = *ninp_p;
inp = *inp_p;
EETYPE("adress_type", adress->type, eAdresstype_names);
RTYPE ("adress_const_wf", adress->const_wf, 1);
RTYPE ("adress_ex_width", adress->ex_width, 0);
RTYPE ("adress_hy_width", adress->hy_width, 0);
RTYPE ("adress_ex_forcecap", adress->ex_forcecap, 0);
EETYPE("adress_interface_correction",adress->icor, eAdressICtype_names);
EETYPE("adress_site", adress->site, eAdressSITEtype_names);
STYPE ("adress_reference_coords", adress_refs, NULL);
STYPE ("adress_tf_grp_names", adress_tf_grp_names, NULL);
STYPE ("adress_cg_grp_names", adress_cg_grp_names, NULL);
EETYPE("adress_do_hybridpairs", adress->do_hybridpairs, yesno_names);
nadress_refs = str_nelem(adress_refs,MAXPTR,ptr1);
for(i=0; (i<nadress_refs); i++) /*read vector components*/
adress->refs[i]=strtod(ptr1[i],NULL);
for( ;(i<DIM); i++) /*remaining undefined components of the vector set to zero*/
adress->refs[i]=0;
*ninp_p = ninp;
*inp_p = inp;
}
void get_params(char *mpin,char *mpout,t_psrec *psr)
{
static const char *bools[BOOL_NR+1] = { "no", "yes", NULL };
/* this must correspond to t_rgb *linecolors[] below */
static const char *colors[] = { "none", "black", "white", NULL };
t_inpfile *inp;
char *tmp;
int ninp=0;
if (mpin)
inp = read_inpfile(mpin,&ninp);
else
inp = NULL;
ETYPE("black&white", psr->bw, bools);
RTYPE("linewidth", psr->linewidth, 1.0);
STYPE("titlefont", psr->titfont, "Helvetica");
RTYPE("titlefontsize", psr->titfontsize, 20.0);
ETYPE("legend", psr->legend, bools);
STYPE("legendfont", psr->legfont, psr->titfont);
STYPE("legendlabel", psr->leglabel, "");
STYPE("legend2label", psr->leg2label, psr->leglabel);
RTYPE("legendfontsize", psr->legfontsize, 14.0);
RTYPE("xbox", psr->xboxsize, 0.0);
RTYPE("ybox", psr->yboxsize, 0.0);
RTYPE("matrixspacing", psr->boxspacing, 20.0);
RTYPE("xoffset", psr->xoffs, 0.0);
RTYPE("yoffset", psr->yoffs, psr->xoffs);
RTYPE("boxlinewidth", psr->boxlinewidth, psr->linewidth);
RTYPE("ticklinewidth", psr->ticklinewidth, psr->linewidth);
RTYPE("zerolinewidth", psr->zerolinewidth, psr->ticklinewidth);
ETYPE("x-lineat0value", psr->X.lineatzero, colors);
RTYPE("x-major", psr->X.major, NOTSET);
RTYPE("x-minor", psr->X.minor, NOTSET);
RTYPE("x-firstmajor", psr->X.offset, 0.0);
ETYPE("x-majorat0", psr->X.first, bools);
RTYPE("x-majorticklen", psr->X.majorticklen, 8.0);
RTYPE("x-minorticklen", psr->X.minorticklen, 4.0);
STYPE("x-label", psr->X.label, "");
RTYPE("x-fontsize", psr->X.fontsize, 16.0);
STYPE("x-font", psr->X.font, psr->titfont);
RTYPE("x-tickfontsize", psr->X.tickfontsize, 10.0);
STYPE("x-tickfont", psr->X.tickfont, psr->X.font);
ETYPE("y-lineat0value", psr->Y.lineatzero, colors);
RTYPE("y-major", psr->Y.major, psr->X.major);
RTYPE("y-minor", psr->Y.minor, psr->X.minor);
RTYPE("y-firstmajor", psr->Y.offset, psr->X.offset);
ETYPE("y-majorat0", psr->Y.first, bools);
RTYPE("y-majorticklen", psr->Y.majorticklen, psr->X.majorticklen);
RTYPE("y-minorticklen", psr->Y.minorticklen, psr->X.minorticklen);
STYPE("y-label", psr->Y.label, psr->X.label);
RTYPE("y-fontsize", psr->Y.fontsize, psr->X.fontsize);
STYPE("y-font", psr->Y.font, psr->X.font);
RTYPE("y-tickfontsize", psr->Y.tickfontsize, psr->X.tickfontsize);
STYPE("y-tickfont", psr->Y.tickfont, psr->Y.font);
if (mpout)
write_inpfile(mpout,ninp,inp,TRUE);
}
static void object_delete(sObject* obj)
{
switch(STYPE(obj)) {
case T_STRING:
string_delete_on_stack(obj);
break;
case T_VECTOR:
vector_delete_on_stack(obj);
break;
case T_LIST:
list_delete_on_stack(obj);
break;
case T_HASH:
hash_delete_on_stack(obj);
break;
case T_BLOCK:
block_delete_on_stack(obj);
break;
case T_COMPLETION:
break;
case T_FD:
fd_delete_on_stack(obj);
break;
case T_FD2:
break;
case T_FUN:
fun_delete_on_stack(obj);
break;
case T_CLASS:
class_delete_on_stack(obj);
break;
case T_UOBJECT:
uobject_delete_on_stack(obj);
break;
case T_EXTOBJ:
SEXTOBJ(obj).mFreeFun(SEXTOBJ(obj).mObject);
break;
case T_INT:
break;
default:
fprintf(stderr,"unexpected err in object_delete stack\n");
exit(1);
}
}
int ReadInput (char *fnMdp, gmx_bool *bPolar, gmx_bool *bAPolar, t_PolKey *PolKey, t_APolKey *APolKey) {
warninp_t wi;
gmx_bool bAllowWarnings=FALSE;
int maxwarning = 99;
t_inpfile *inp;
int ninp;
const char *tmp;
wi = init_warning(bAllowWarnings,maxwarning);
inp = read_inpfile(fnMdp, &ninp, wi);
char *ptr[MAXPTR];
int n;
//To check for polar solvation calculation
STYPE ("polar", polar, NULL);
n= str_nelem(polar,MAXPTR,ptr);
if ( (n>1) || ((strcmp(ptr[0],"yes")!=0) && (strcmp(ptr[0],"no")!=0)) )
gmx_fatal(FARGS, "Polar should be yes or no\n");
if(strcmp(ptr[0],"yes")==0)
*bPolar = TRUE;
//To check for APolar calculation
STYPE ("apolar", apolar, NULL);
n= str_nelem(apolar,MAXPTR,ptr);
if ( (n>1) || ((strcmp(ptr[0],"yes")!=0) && (strcmp(ptr[0],"no")!=0)) )
gmx_fatal(FARGS, "Polar should be yes or no\n");
if(strcmp(ptr[0],"yes")==0)
*bAPolar = TRUE;
if(*bPolar)
{
//Psize keywords
RTYPE ("cfac", PolKey->cfac, 2);
RTYPE ("gridspace", PolKey->gridspace, 0.5);
RTYPE ("gmemceil", PolKey->gmemceil, 400);
RTYPE ("fadd", PolKey->fadd, 20);
RTYPE ("ofrac", PolKey->ofrac, 0.1);
//Polar Keywords
EETYPE("mg-type", PolKey->mg_type, mg_words);
RTYPE ("pcharge", PolKey->pcharge, 0);
RTYPE ("ncharge", PolKey->ncharge, 0);
RTYPE ("prad", PolKey->prad, 0);
RTYPE ("nrad", PolKey->nrad, 0);
RTYPE ("pconc", PolKey->pconc, 0);
RTYPE ("nconc", PolKey->nconc, 0);
RTYPE ("pdie", PolKey->pdie, 4);
RTYPE ("sdie", PolKey->sdie, 78.4);
RTYPE ("vdie", PolKey->vdie, 1);
RTYPE ("srad", PolKey->srad, 1.4);
RTYPE ("swin", PolKey->swin, 0.30);
RTYPE ("sdens", PolKey->sdens, 10);
RTYPE ("temp", PolKey->temp, 300);
EETYPE("srfm", PolKey->srfm, srfm_words);
EETYPE("chgm", PolKey->chgm, chgm_words);
EETYPE("bcfl", PolKey->bcfl, bcfl_words);
EETYPE("PBsolver", PolKey->pbsolver, PBsolver);
}
if (*bAPolar)
{
//APolar Keywords
RTYPE ("gamma", APolKey->gamma, 0.030096);
RTYPE ("sasconst", APolKey->sasaconst, 0.0);
RTYPE ("sasrad", APolKey->sasrad, 1.4);
RTYPE ("press", APolKey->press, 0.0);
RTYPE ("savconst", APolKey->savconst, 0.0);
RTYPE ("savrad", APolKey->savrad, 1.4);
APolKey->bWCA = FALSE;
STYPE("WCA", wca, NULL);
n= str_nelem(wca,MAXPTR,ptr);
if ( (n>1) || ((strcmp(ptr[0],"yes")!=0) && (strcmp(ptr[0],"no")!=0)) )
gmx_fatal(FARGS, "Polar should be yes or no\n");
if(strcmp(ptr[0],"yes")==0)
APolKey->bWCA = TRUE;
RTYPE ("wcarad", APolKey->wcarad, 1.4);
RTYPE ("bconc", APolKey->bconc, 0.033428);
RTYPE ("dpos", APolKey->dpos, 0.05);
RTYPE ("APsdens", APolKey->sdens, 200);
STYPE ("grid", grid, NULL);
EETYPE("APsrfm", APolKey->srfm, APsrfm_words);
RTYPE ("APswin", APolKey->swin, 0.2);
RTYPE ("APtemp", APolKey->temp, 300);
n= str_nelem(grid,MAXPTR,ptr);
if ((n<3) || (n>3))
gmx_fatal(FARGS, "Number of grid point should be three\n");
APolKey->grid[0] = strtod(ptr[0],NULL);
APolKey->grid[1] = strtod(ptr[1],NULL);
APolKey->grid[2] = strtod(ptr[2],NULL);
}
return 0;
}
void read_pullparams(t_pull *pull, char *infile, char *outfile)
{
t_inpfile *inp;
int ninp,i;
char *tmp; /* for the input parsing macros */
char dummy[STRLEN]; /* idem */
char grp1buf[STRLEN], grp2buf[STRLEN], grp3buf[STRLEN], grp4buf[STRLEN],
grp5buf[STRLEN],
bf1[STRLEN], bf2[STRLEN], dir[STRLEN],
refdir1[STRLEN],refdir2[STRLEN];
int bReverse; int tmpref; int tmprun;
enum {erunSTART, erunAFM, erunConstraint, erunUmbrella, erunTest, erunNR};
static char *runtypes[erunNR+1] = {
"start", "afm", "constraint", "umbrella", "test", NULL
};
enum {erefCom, erefComT0, erefDyn, erefDynT0, erefNR};
static char *reftypes[erefNR+1] = {
"com", "com_t0", "dynamic", "dynamic_t0", NULL
};
enum {ereverseTO_REF, ereverseFROM_REF, ereverseNR};
static char *reversetypes[ereverseNR+1] = {
"from_reference", "to_reference", NULL
};
enum {everboseYES, everboseNO, everboseNR};
static char *verbosetypes[erefNR+1] = {
"no", "yes", NULL
};
int nerror = 0;
/* read input parameter file */
fprintf(stderr,"Reading parameter file %s\n",infile);
inp=read_inpfile(infile,&ninp);
/* general options */
CTYPE("GENERAL");
EETYPE("verbose", pull->bVerbose, verbosetypes, &nerror, TRUE);
CTYPE("Runtype: start, afm, constraint, umbrella, test");
EETYPE("runtype", tmprun, runtypes, &nerror, TRUE);
CTYPE("Groups to be pulled");
STYPE("group_1", grp1buf, "");
STYPE("group_2", grp2buf, "");
STYPE("group_3", grp3buf, "");
STYPE("group_4", grp4buf, "");
CTYPE("The group for the reaction force.");
STYPE("reference_group", grp5buf, "");
CTYPE("Ref. type: com, com_t0, dynamic, dynamic_t0");
EETYPE("reftype", tmpref, reftypes, &nerror, TRUE);
CTYPE("Use running average for reflag steps for com calculation");
ITYPE("reflag", pull->reflag, 1);
CTYPE("Select components for constraint vector. default: z-only");
STYPE("direction", dir, "0.0 0.0 1.0");
CTYPE("Direction for start/afm: to_reference, from_reference");
EETYPE("reverse", pull->bReverse, reversetypes, &nerror, TRUE);
/* options for dynamic reference groups */
CTYPE("DYNAMIC REFERENCE GROUP OPTIONS");
CTYPE("Cylinder radius for dynamic reaction force groups (nm)");
RTYPE("r", pull->r, 0.0);
CTYPE("Switch from r to rc in case of dynamic reaction force");
RTYPE("rc", pull->rc, 0.0);
CTYPE("Update frequency for dynamic reference groups (steps)");
ITYPE("update", pull->update, 1);
/* constraint run options */
CCTYPE("CONSTRAINT RUN OPTIONS");
CTYPE("Tolerance of constraints, in nm");
RTYPE("constraint_tolerance", pull->constr_tol, 1E-6);
/* options for AFM type pulling simulations */
CCTYPE("AFM OPTIONS");
CTYPE("pull rate in nm/timestep");
RTYPE("pullrate", pull->rate, 0.0);
CTYPE("forceconstant in kJ/(mol*nm^2)");
RTYPE("forceconstant", pull->k, 0.0);
/* umbrella sampling options */
CCTYPE("UMBRELLA SAMPLING OPTIONS");
CTYPE("Width of umbrella sampling potential in kJ/(mol*nm^2)");
RTYPE("width", pull->um_width, 0.0);
/* options for making starting structures */
CCTYPE("STARTING STRUCTURE OPTIONS");
CTYPE("Start coord. for making starting struct, rel. to ref. grp.: x y z");
STYPE("r0_group1", bf1, "");
STYPE("r0_group2", bf2, "");
/* CTYPE("Constrain rotations around principle axes? Needs work");
ITYPE("rotation_x", pull->bRot[0], 0);
ITYPE("rotation_y", pull->bRot[1], 0);
ITYPE("rotation_z", pull->bRot[2], 0);
CTYPE("Rate of rotation (degrees/step)");
RTYPE("rotation_rate", pull->rot_rate, 0.0);
*/
RTYPE("tolerance", pull->tolerance, 0.05);
CTYPE("Rate of translation in all directions (nm/step)");
RTYPE("translation_rate", pull->xlt_rate, 0.0);
CTYPE("Write out structure every ndegr degrees, transstep nm");
ITYPE("ndegr", pull->rot_incr, 0);
RTYPE("transstep", pull->xlt_incr, 0.001);
write_inpfile(outfile,ninp,inp);
for (i=0; (i<ninp); i++) {
sfree(inp[i].name);
sfree(inp[i].value);
}
sfree(inp);
pull->runtype = (t_runtype)tmprun;
pull->reftype = (t_reftype)tmpref;
/* sort out the groups */
fprintf(stderr,"Groups: %s %s %s %s %s\n",
grp1buf,grp2buf,grp3buf,grp4buf,grp4buf);
if (!strcmp(grp1buf,"") || !strcmp(grp5buf,""))
fatal_error(0,"Need to specify at least group_1 and reference_group");
pull->pull.n = 1;
if (strcmp(grp2buf,""))
pull->pull.n += 1;
if (strcmp(grp3buf,""))
pull->pull.n += 1;
if (strcmp(grp4buf,""))
pull->pull.n += 1;
fprintf(stderr,"Using %d pull groups\n",pull->pull.n);
/* initialize the names of the groups */
snew(pull->pull.grps,pull->pull.n);
snew(pull->ref.grps,1);
pull->pull.grps[0] = (char *)strdup(grp1buf);
pull->pull.grps[1] = (char *)strdup(grp2buf);
pull->pull.grps[2] = (char *)strdup(grp3buf);
pull->pull.grps[3] = (char *)strdup(grp4buf);
pull->ref.grps[0] = (char *)strdup(grp5buf);
if (pull->runtype == eStart) {
snew(pull->pull.xtarget,pull->pull.n);
string2rvec(bf1,pull->pull.xtarget[0]);
if (pull->pull.n == 2)
string2rvec(bf2,pull->pull.xtarget[1]);
}
string2rvec(dir,pull->dims);
fprintf(stderr,"Using distance components %2.1f %2.1f %2.1f\n",
pull->dims[0],pull->dims[1],pull->dims[2]);
if (pull->r > 0.001)
pull->bCyl = TRUE;
else
pull->bCyl = FALSE;
}
/* The Main shaping function, and the only one to be used
* by the outside world.
*
* line: buffer to apply shaping to. this must be passed by doBidi() first
* to: output buffer for the shaped data
* from: start bidi at this index
* count: number of characters in line
*/
int doShape(BLOCKTYPE line, CHARTYPE* to, int from, int count)
{
int i, j, ligFlag;
unsigned char prevTemp, nextTemp;
CHARTYPE tempChar;
ligFlag = 0;
prevTemp = SU;
nextTemp = SU;
for(i=from; i<count; i++)
{
/* Get Previous and next Characters type */
j=i;
while(--j >= 0)
{
if(GetType(GETCHAR(line, j)) != NSM)
{
prevTemp = STYPE(GETCHAR(line, j));
break;
}
}
j=i;
while(++j < count)
{
if(GetType(GETCHAR(line, j)) != NSM)
{
nextTemp = STYPE(GETCHAR(line, j));
break;
}else if(j == count-1)
{
nextTemp = SU;
break;
}
}
switch(STYPE(GETCHAR(line, i)))
{
case SC:
case SU:
to[i] = GETCHAR(line, i);
break;
case SR:
if(prevTemp == SD || prevTemp == SC)
to[i] = SFINAL(SISOLATED(GETCHAR(line, i)));
else
to[i] = SISOLATED(GETCHAR(line, i));
break;
case SD:
/* Make Ligatures */
if(GETCHAR(line, i) == 0x644)
{
j=i;
while(j++<count)
{
if(GetType(GETCHAR(line, j)) != NSM)
{
tempChar = GETCHAR(line, j);
break;
}
}
switch(tempChar)
{
case 0x622:
ligFlag = 1;
if(prevTemp == SD || prevTemp == SC)
to[i] = 0xFEF6;
else
to[i] = 0xFEF5;
break;
case 0x623:
ligFlag = 1;
if(prevTemp == SD || prevTemp == SC)
to[i] = 0xFEF8;
else
to[i] = 0xFEF7;
break;
case 0x625:
ligFlag = 1;
if(prevTemp == SD || prevTemp == SC)
to[i] = 0xFEFA;
else
to[i] = 0xFEF9;
break;
case 0x627:
ligFlag = 1;
if(prevTemp == SD || prevTemp == SC)
to[i] = 0xFEFC;
else
to[i] = 0xFEFB;
break;
}
if(ligFlag)
{
to[j] = 0x20;
i = j;
ligFlag = 0;
break;
}
}
if((prevTemp == SD) || (prevTemp == SC))
{
if(nextTemp == SR || nextTemp == SD || nextTemp == SC)
to[i] = SMEDIAL(SISOLATED(GETCHAR(line, i)));
else
to[i] = SFINAL(SISOLATED(GETCHAR(line, i)));
break;
}else
{
if(nextTemp == SR || nextTemp == SD || nextTemp == SC)
to[i] = SINITIAL(SISOLATED(GETCHAR(line, i)));
else
to[i] = SISOLATED(GETCHAR(line, i));
break;
}
}
nextTemp = SU;
}
return 1;
}
void ValueBuilder::_add(const std::string& name, ScalarType stype, const void *V)
{
const children_t::iterator it(children.find(name));
if(it!=children.end()) {
if(it->second->type!=scalar && it->second->type!=scalarArray)
THROW_EXCEPTION2(std::logic_error, "Not allowed to replace field. wrong type");
}
epics::auto_ptr<child> store;
switch(stype) {
#define STYPE(stype) case stype: store.reset(new child_scalar<ScalarTypeTraits<stype>::type>(V)); break
STYPE(pvBoolean);
STYPE(pvByte);
STYPE(pvShort);
STYPE(pvInt);
STYPE(pvLong);
STYPE(pvUByte);
STYPE(pvUShort);
STYPE(pvUInt);
STYPE(pvULong);
STYPE(pvFloat);
STYPE(pvDouble);
STYPE(pvString);
#undef STYPE
}
if(!store.get())
THROW_EXCEPTION2(std::logic_error, "Unhandled ScalarType");
if(it!=children.end()) {
delete it->second;
children.erase(it);
}
children[name] = store.get();
store.release();
}
