int tclcommand_inter_magnetic_parse_mdlc_params(Tcl_Interp * interp, int argc, char ** argv)
{
double pwerror;
double gap_size;
double far_cut = -1;
MDLC_TRACE(fprintf(stderr, "%d: tclcommand_inter_magnetic_parse_mdlc_params().\n", this_node));
if (argc < 2) {
Tcl_AppendResult(interp, "either nothing or mdlc <pwerror> <minimal layer distance> {<cutoff>} expected, not \"", argv[0], "\"", (char *)NULL);
return TCL_ERROR;
}
if (!ARG0_IS_D(pwerror))
return TCL_ERROR;
if (!ARG1_IS_D(gap_size))
return TCL_ERROR;
argc -= 2; argv += 2;
if (argc > 0) {
// if there, parse away manual cutoff
if(ARG0_IS_D(far_cut)) {
argc--; argv++;
}
else
Tcl_ResetResult(interp);
if(argc > 0) {
Tcl_AppendResult(interp, "either nothing or mdlc <pwerror> <minimal layer distance=size of the gap without particles> {<cutoff>} expected, not \"", argv[0], "\"", (char *)NULL);
return TCL_ERROR;
}
}
CHECK_VALUE(mdlc_set_params(pwerror,gap_size,far_cut),"choose a 3d electrostatics method prior to use mdlc");
coulomb.Dprefactor = (temperature > 0) ? temperature*coulomb.Dbjerrum : coulomb.Dbjerrum;
}
int tclcommand_inter_coulomb_parse_elc_params(Tcl_Interp * interp, int argc, char ** argv)
{
double pwerror;
double gap_size;
double far_cut = -1;
double top = 1, mid = 1, bot = 1;
int neutralize = 1;
if (argc < 2) {
Tcl_AppendResult(interp, "either nothing or elc <pwerror> <minimal layer distance> {<cutoff>} {dielectric <di_top> <di_mid> <di_bottom>} {noneutralization} expected, not \"",
argv[0], "\"", (char *)NULL);
return TCL_ERROR;
}
if (!ARG0_IS_D(pwerror))
return TCL_ERROR;
if (!ARG1_IS_D(gap_size))
return TCL_ERROR;
argc -= 2; argv += 2;
if (argc > 0) {
// if there, parse away manual cutoff
if(ARG0_IS_D(far_cut)) {
argc--; argv++;
}
else
Tcl_ResetResult(interp);
while (argc > 0) {
if (ARG0_IS_S("noneutralization") || ARG0_IS_S("-noneutralization")) {
neutralize = 0;
argc--; argv++;
}
else if (argc >= 4 && ARG0_IS_S("dielectric")) {
// just a dummy, not used, as it is only printed for information
// purposes. We need to calculate it
double space_layer_dummy;
if (!ARG_IS_D(1,top) || !ARG_IS_D(2,mid) || !ARG_IS_D(3,bot))
return TCL_ERROR;
argc -= 4; argv += 4;
if (argc > 0 && ARG_IS_D(4, space_layer_dummy)) {
argc--; argv++;
}
}
else {
Tcl_AppendResult(interp, "either nothing or elc <pwerror> <minimal layer distance> {<cutoff>} {dielectric <di_top> <di_mid> <di_bottom>} {noneutralization} expected, not \"",
argv[0], "\"", (char *)NULL);
return TCL_ERROR;
}
}
}
CHECK_VALUE(ELC_set_params(pwerror, gap_size, far_cut, neutralize, top, mid, bot),
"choose a 3d electrostatics method prior to ELC");
}
int tclcommand_inter_coulomb_parse_mmm2d(Tcl_Interp * interp, int argc, char ** argv)
{
int err;
double maxPWerror;
double far_cut = -1;
double top = 1, mid = 1, bot = 1;
double delta_top = 0, delta_bot = 0;
if (argc < 1) {
Tcl_AppendResult(interp, "wrong # arguments: inter coulomb mmm2d <maximal pairwise error> "
"{<fixed far cutoff>} {dielectric <e1> <e2> <e3>} | {dielectric-contrasts <d1> <d2>}", (char *) NULL);
return TCL_ERROR;
}
if (! ARG0_IS_D(maxPWerror))
return TCL_ERROR;
--argc; ++argv;
if (argc >= 1) {
if (ARG0_IS_D(far_cut)){
--argc; ++argv;
} else {
Tcl_ResetResult(interp);
}
}
if (argc != 0) {
if (argc == 4 && ARG0_IS_S("dielectric")) {
if (!ARG_IS_D(1,top) || !ARG_IS_D(2,mid) || !ARG_IS_D(3,bot))
return TCL_ERROR;
delta_top = (mid - top)/(mid + top);
delta_bot = (mid - bot)/(mid + bot);
}
else if (argc == 3 && ARG0_IS_S("dielectric-contrasts")) {
if (!ARG_IS_D(1,delta_top) || !ARG_IS_D(2,delta_bot))
return TCL_ERROR;
} else {
Tcl_AppendResult(interp, "wrong # arguments: inter coulomb mmm2d <maximal pairwise error> "
"{<fixed far cutoff>} {dielectric <e1> <e2> <e3>} | {dielectric-contrasts <d1> <d2>}", (char *) NULL);
return TCL_ERROR;
}
}
if (cell_structure.type != CELL_STRUCTURE_NSQUARE &&
cell_structure.type != CELL_STRUCTURE_LAYERED) {
Tcl_AppendResult(interp, "MMM2D requires layered of nsquare cell structure", (char *)NULL);
return TCL_ERROR;
}
if ((err = MMM2D_set_params(maxPWerror, far_cut, delta_top, delta_bot)) > 0) {
Tcl_AppendResult(interp, mmm2d_errors[err], (char *)NULL);
return TCL_ERROR;
}
return TCL_OK;
}
/// parser for the forcecap
int tclcommand_inter_parse_morseforcecap(Tcl_Interp * interp, int argc, char ** argv)
{
char buffer[TCL_DOUBLE_SPACE];
if (argc == 0) {
if (morse_force_cap == -1.0)
Tcl_AppendResult(interp, "morseforcecap individual", (char *) NULL);
else {
Tcl_PrintDouble(interp, morse_force_cap, buffer);
Tcl_AppendResult(interp, "morseforcecap ", buffer, (char *) NULL);
}
return TCL_OK;
}
if (argc > 1) {
Tcl_AppendResult(interp, "inter morseforcecap takes at most 1 parameter",
(char *) NULL);
return TCL_ERROR;
}
if (ARG0_IS_S("individual"))
morse_force_cap = -1.0;
else if (! ARG0_IS_D(morse_force_cap) || morse_force_cap < 0) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "force cap must be a nonnegative double value or \"individual\"",
(char *) NULL);
return TCL_ERROR;
}
CHECK_VALUE(morseforcecap_set_params(morse_force_cap),
"If you can read this, you should change it. (Use the source Luke!)");
}
static int lbfluid_parse_tau(Tcl_Interp *interp, int argc, char *argv[], int *change) {
double tau;
if (argc < 1) {
Tcl_AppendResult(interp, "tau requires 1 argument", NULL);
return TCL_ERROR;
}
if (!ARG0_IS_D(tau)) {
Tcl_AppendResult(interp, "wrong argument for tau", (char *)NULL);
return TCL_ERROR;
}
if (tau < 0.0) {
Tcl_AppendResult(interp, "tau must be positive", (char *)NULL);
return TCL_ERROR;
}
else if ((time_step >= 0.0) && (tau < time_step)) {
fprintf(stderr,"tau %f \n", lbpar_gpu.tau);
fprintf(stderr,"time_step %f \n", time_step);
Tcl_AppendResult(interp, "tau must be larger than MD time_step", (char *)NULL);
return TCL_ERROR;
}
*change = 1;
lbpar_gpu.tau = (float)tau;
return TCL_OK;
}
int tclcommand_inter_coulomb_parse_dh(Tcl_Interp * interp, int argc, char ** argv)
{
double kappa, r_cut;
int i;
if(argc < 2) {
Tcl_AppendResult(interp, "Not enough parameters: inter coulomb dh <kappa> <r_cut>", (char *) NULL);
return TCL_ERROR;
}
coulomb.method = COULOMB_DH;
if(! ARG0_IS_D(kappa))
return TCL_ERROR;
if(! ARG1_IS_D(r_cut))
return TCL_ERROR;
if ( (i = dh_set_params(kappa, r_cut)) < 0) {
switch (i) {
case -1:
Tcl_AppendResult(interp, "dh kappa must be positiv.",(char *) NULL);
break;
case -2:
Tcl_AppendResult(interp, "dh r_cut must be positiv.",(char *) NULL);
break;
default:
Tcl_AppendResult(interp, "unspecified error",(char *) NULL);
}
return TCL_ERROR;
}
return TCL_OK;
}
int tclcommand_inter_coulomb_parse_ewald(Tcl_Interp * interp, int argc, char ** argv)
{
double r_cut, alpha;
int i, kmax;
coulomb.method = COULOMB_EWALD;
#ifdef PARTIAL_PERIODIC
if(PERIODIC(0) == 0 ||
PERIODIC(1) == 0 ||
PERIODIC(2) == 0)
{
Tcl_AppendResult(interp, "Need periodicity (1,1,1) with Coulomb EWALD",
(char *) NULL);
return TCL_ERROR;
}
#endif
if (argc < 2) {
Tcl_AppendResult(interp, "expected: inter coulomb <bjerrum> ewald <r_cut> <alpha> <kmax>",
(char *) NULL);
return TCL_ERROR;
}
if(! ARG0_IS_D(r_cut))
return TCL_ERROR;
if(argc != 3) {
Tcl_AppendResult(interp, "wrong # arguments: inter coulomb <bjerrum> ewald <r_cut> <alpha> <kmax>",
(char *) NULL);
return TCL_ERROR;
}
if(! ARG_IS_D(1, alpha))
return TCL_ERROR;
if(! ARG_IS_I(2, kmax))
return TCL_ERROR;
if ((i = ewald_set_params(r_cut, alpha, kmax)) < 0) {
switch (i) {
case -1:
Tcl_AppendResult(interp, "r_cut must be positive", (char *) NULL);
break;
case -4:
Tcl_AppendResult(interp, "alpha must be positive", (char *) NULL);
break;
case -5:
Tcl_AppendResult(interp, "kmax must be greater than zero", (char *) NULL);
default:;
Tcl_AppendResult(interp, "unspecified error", (char *) NULL);
}
return TCL_ERROR;
}
return TCL_OK;
}
int tclcommand_analyze_parse_rdfchain(Tcl_Interp *interp, int argc, char **argv)
{
/* 'analyze { rdfchain } <r_min> <r_max> <r_bins> [<chain_start> <n_chains> <chain_length>]' */
/***********************************************************************************************************/
char buffer[4*TCL_DOUBLE_SPACE+7];
int i, r_bins;
double r_min, r_max, *f1, *f2, *f3;
double bin_width, r;
if (argc < 3) {
Tcl_AppendResult(interp, "Wrong # of args! Usage: analyze rdfchain <r_min> <r_max> <r_bins> [<chain_start> <n_chains> <chain_length>]",
(char *)NULL);
return (TCL_ERROR);
} else {
if (!ARG0_IS_D(r_min))
return (TCL_ERROR);
if (!ARG1_IS_D(r_max))
return (TCL_ERROR);
if (!ARG_IS_I(2, r_bins))
return (TCL_ERROR);
argc-=3; argv+=3;
}
if (tclcommand_analyze_set_parse_chain_topology_check(interp, argc, argv) == TCL_ERROR) return TCL_ERROR;
if ((chain_n_chains == 0) || (chain_length == 0)) {
Tcl_AppendResult(interp, "The chain topology has not been set",(char *)NULL); return TCL_ERROR;
}
if (r_bins <=0) {
Tcl_AppendResult(interp, "Nothing to be done - choose <r_bins> greater zero!",(char *)NULL); return TCL_ERROR;
}
if (r_min <= 0.) {
Tcl_AppendResult(interp, "<r_min> has to be positive", (char *)NULL);
return TCL_ERROR;
}
if (r_max <= r_min) {
Tcl_AppendResult(interp, "<r_max> has to be larger than <r_min>", (char *)NULL);
return TCL_ERROR;
}
updatePartCfg(WITHOUT_BONDS);
analyze_rdfchain(r_min, r_max, r_bins, &f1, &f2, &f3);
bin_width = (r_max - r_min) / (double)r_bins;
r = r_min + bin_width/2.0;
for(i=0; i<r_bins; i++) {
sprintf(buffer,"{%f %f %f %f} ",r,f1[i],f2[i],f3[i]);
Tcl_AppendResult(interp, buffer, (char *)NULL);
r+= bin_width;
}
free(f1); free(f2); free(f3);
return (TCL_OK);
}
int tclcommand_analyze_parse_formfactor(Tcl_Interp *interp, int average, int argc, char **argv)
{
/* 'analyze { formfactor | <formfactor> } <qmin> <qmax> <qbins> [<chain_start> <n_chains> <chain_length>]' */
/***********************************************************************************************************/
char buffer[2*TCL_DOUBLE_SPACE+5];
int i;
double qmin,qmax, q,qfak, *ff; int qbins;
if (argc < 3) {
Tcl_AppendResult(interp, "Wrong # of args! Usage: analyze formfactor <qmin> <qmax> <qbins> [<chain_start> <n_chains> <chain_length>]",
(char *)NULL);
return (TCL_ERROR);
} else {
if (!ARG0_IS_D(qmin))
return (TCL_ERROR);
if (!ARG1_IS_D(qmax))
return (TCL_ERROR);
if (!ARG_IS_I(2, qbins))
return (TCL_ERROR);
argc-=3; argv+=3;
}
if (tclcommand_analyze_set_parse_chain_topology_check(interp, argc, argv) == TCL_ERROR) return TCL_ERROR;
if ((chain_n_chains == 0) || (chain_length == 0)) {
Tcl_AppendResult(interp, "The chain topology has not been set",(char *)NULL); return TCL_ERROR;
}
if (qbins <=0) {
Tcl_AppendResult(interp, "Nothing to be done - choose <qbins> greater zero to get S(q)!",(char *)NULL); return TCL_ERROR;
}
if (qmin <= 0.) {
Tcl_AppendResult(interp, "formfactor S(q) requires qmin > 0", (char *)NULL);
return TCL_ERROR;
}
if (qmax <= qmin) {
Tcl_AppendResult(interp, "formfactor S(q) requires qmin < qmax", (char *)NULL);
return TCL_ERROR;
}
if (!average) analyze_formfactor(qmin, qmax, qbins, &ff);
else if (n_configs == 0) {
Tcl_AppendResult(interp, "no configurations found! ", (char *)NULL);
Tcl_AppendResult(interp, "Use 'analyze append' to save some, or 'analyze formfactor ...' to only look at current state!",
(char *)NULL);
return TCL_ERROR; }
else analyze_formfactor_av(qmin, qmax, qbins, &ff);
q = qmin; qfak = pow((qmax/qmin),(1.0/qbins));
for(i=0; i<=qbins; i++) { sprintf(buffer,"{%f %f} ",q,ff[i]); q*=qfak; Tcl_AppendResult(interp, buffer, (char *)NULL); }
free(ff);
return (TCL_OK);
}
static int lbfluid_parse_agrid(Tcl_Interp *interp, int argc, char *argv[], int *change) {
double agrid;
if (argc < 1) {
Tcl_AppendResult(interp, "agrid requires 1 argument", (char *)NULL);
return TCL_ERROR;
}
if (!ARG0_IS_D(agrid)) {
Tcl_AppendResult(interp, "wrong argument for agrid", (char *)NULL);
return TCL_ERROR;
}
if (agrid <= 0.0) {
Tcl_AppendResult(interp, "agrid must be positive", (char *)NULL);
return TCL_ERROR;
}
*change = 1;
lbpar_gpu.agrid = (float)agrid;
lbpar_gpu.dim_x = (unsigned int)floor(box_l[0]/agrid);
lbpar_gpu.dim_y = (unsigned int)floor(box_l[1]/agrid);
lbpar_gpu.dim_z = (unsigned int)floor(box_l[2]/agrid);
unsigned int tmp[3];
tmp[0] = lbpar_gpu.dim_x;
tmp[1] = lbpar_gpu.dim_y;
tmp[2] = lbpar_gpu.dim_z;
/* sanity checks */
int dir;
for (dir=0;dir<3;dir++) {
/* check if box_l is compatible with lattice spacing */
if (fabs(box_l[dir]-tmp[dir]*agrid) > ROUND_ERROR_PREC) {
char *errtxt = runtime_error(128);
ERROR_SPRINTF(errtxt, "{097 Lattice spacing agrid=%f is incompatible with box_l[%i]=%f} ",agrid,dir,box_l[dir]);
}
}
lbpar_gpu.number_of_nodes = lbpar_gpu.dim_x * lbpar_gpu.dim_y * lbpar_gpu.dim_z;
LB_TRACE (printf("#nodes \t %u \n", lbpar_gpu.number_of_nodes));
return TCL_OK;
}
static int lbfluid_parse_friction(Tcl_Interp *interp, int argc, char *argv[], int *change) {
double friction;
if (argc < 1) {
Tcl_AppendResult(interp, "friction requires 1 argument", (char *)NULL);
return TCL_ERROR;
}
if (!ARG0_IS_D(friction)) {
Tcl_AppendResult(interp, "wrong argument for friction", (char *)NULL);
return TCL_ERROR;
}
if (friction <= 0.0) {
Tcl_AppendResult(interp, "friction must be positive", (char *)NULL);
return TCL_ERROR;
}
*change = 1;
lbpar_gpu.friction = (float)friction;
return TCL_OK;
}
static int lbfluid_parse_viscosity(Tcl_Interp *interp, int argc, char *argv[], int *change) {
double viscosity;
if (argc < 1) {
Tcl_AppendResult(interp, "viscosity requires 1 argument", (char *)NULL);
return TCL_ERROR;
}
if (!ARG0_IS_D(viscosity)) {
Tcl_AppendResult(interp, "wrong argument for viscosity", (char *)NULL);
return TCL_ERROR;
}
if (viscosity <= 0.0) {
Tcl_AppendResult(interp, "viscosity must be positive", (char *)NULL);
return TCL_ERROR;
}
*change = 1;
lbpar_gpu.viscosity = (float)viscosity;
return TCL_OK;
}
static int lbfluid_parse_bulk_visc(Tcl_Interp *interp, int argc, char *argv[], int *change) {
double bulk_visc;
if (argc < 1) {
Tcl_AppendResult(interp, "bulk_viscosity requires 1 argument", (char *)NULL);
return TCL_ERROR;
}
if (!ARG0_IS_D(bulk_visc)) {
Tcl_AppendResult(interp, "wrong argument for bulk_viscosity", (char *)NULL);
return TCL_ERROR;
}
if (bulk_visc < 0.0) {
Tcl_AppendResult(interp, "bulk_viscosity must be positive", (char *)NULL);
return TCL_ERROR;
}
*change =1;
lbpar_gpu.bulk_viscosity = (float)bulk_visc;
return TCL_OK;
}
static int lbfluid_parse_gamma_even(Tcl_Interp *interp, int argc, char *argv[], int *change) {
double g;
if (argc < 1) {
Tcl_AppendResult(interp, "gamma_even requires 1 argument", (char *)NULL);
return TCL_ERROR;
}
if (!ARG0_IS_D(g)) {
Tcl_AppendResult(interp, "wrong argument for gamma_even", (char *)NULL);
return TCL_ERROR;
}
if (fabs( g > 1.0)) {
Tcl_AppendResult(interp, "fabs(gamma_even) must be > 1.", (char *)NULL);
return TCL_ERROR;
}
*change = 1;
lbpar_gpu.gamma_even = (float)g;
return TCL_OK;
}
int tclcommand_inter_parse_coulomb(Tcl_Interp * interp, int argc, char ** argv)
{
double d1;
Tcl_ResetResult(interp);
if(argc == 0) {
tclprint_to_result_CoulombIA(interp);
return TCL_OK;
}
if (! ARG0_IS_D(d1)) {
#ifdef P3M
Tcl_ResetResult(interp);
if (ARG0_IS_S("elc") && ((coulomb.method == COULOMB_P3M) || (coulomb.method == COULOMB_ELC_P3M)))
return tclcommand_inter_coulomb_parse_elc_params(interp, argc - 1, argv + 1);
if (coulomb.method == COULOMB_P3M)
return tclcommand_inter_coulomb_parse_p3m_opt_params(interp, argc, argv);
else {
Tcl_AppendResult(interp, "expect: inter coulomb <bjerrum>",
(char *) NULL);
return TCL_ERROR;
}
#else
return TCL_ERROR;
#endif
}
if (coulomb_set_bjerrum(d1) == TCL_ERROR) {
Tcl_AppendResult(interp, argv[0], "bjerrum length must be positive",
(char *) NULL);
return TCL_ERROR;
}
argc -= 1;
argv += 1;
if (d1 == 0.0 && argc == 0) {
mpi_bcast_coulomb_params();
return TCL_OK;
}
if(argc < 1) {
Tcl_AppendResult(interp, "wrong # args for inter coulomb.",
(char *) NULL);
mpi_bcast_coulomb_params();
return TCL_ERROR;
}
/* check method */
#define REGISTER_COULOMB(name, parser) \
if(ARG0_IS_S(name)) \
return parser(interp, argc-1, argv+1);
#ifdef P3M
REGISTER_COULOMB("p3m", tclcommand_inter_coulomb_parse_p3m);
#endif
REGISTER_COULOMB("dh", tclcommand_inter_coulomb_parse_dh);
if(ARG0_IS_S("rf")) return tclcommand_inter_coulomb_parse_rf(interp, argc-1, argv+1,COULOMB_RF);
if(ARG0_IS_S("inter_rf")) return tclcommand_inter_coulomb_parse_rf(interp, argc-1, argv+1,COULOMB_INTER_RF);
REGISTER_COULOMB("mmm1d", tclcommand_inter_coulomb_parse_mmm1d);
REGISTER_COULOMB("mmm2d", tclcommand_inter_coulomb_parse_mmm2d);
REGISTER_COULOMB("maggs", tclcommand_inter_coulomb_parse_maggs);
REGISTER_COULOMB("memd", tclcommand_inter_coulomb_parse_maggs);
/* fallback */
coulomb.method = COULOMB_NONE;
coulomb.bjerrum = 0.0;
mpi_bcast_coulomb_params();
Tcl_AppendResult(interp, "do not know coulomb method \"",argv[0],
"\": coulomb switched off", (char *) NULL);
return TCL_ERROR;
}
int tclcommand_inter_parse_magnetic(Tcl_Interp * interp, int argc, char ** argv)
{
double d1;
Tcl_ResetResult(interp);
if(argc == 0) {
tclprint_to_result_DipolarIA(interp);
return TCL_OK;
}
if (! ARG0_IS_D(d1)) {
Tcl_ResetResult(interp);
if (ARG0_IS_S("mdlc") && ((coulomb.Dmethod == DIPOLAR_DS) || (coulomb.Dmethod == DIPOLAR_MDLC_DS)))
return tclcommand_inter_magnetic_parse_mdlc_params(interp, argc - 1, argv + 1);
#ifdef DP3M
if (ARG0_IS_S("mdlc") && ((coulomb.Dmethod == DIPOLAR_P3M) || (coulomb.Dmethod == DIPOLAR_MDLC_P3M)))
return tclcommand_inter_magnetic_parse_mdlc_params(interp, argc - 1, argv + 1);
if (coulomb.Dmethod == DIPOLAR_P3M)
return tclcommand_inter_magnetic_parse_dp3m_opt_params(interp, argc, argv);
else {
Tcl_AppendResult(interp, "expect: inter magnetic <Dbjerrum>",
(char *) NULL);
return TCL_ERROR;
}
#else
return TCL_ERROR;
#endif
}
if (dipolar_set_Dbjerrum(d1) == TCL_ERROR) {
Tcl_AppendResult(interp, argv[0], "Dbjerrum length must be positive",
(char *) NULL);
return TCL_ERROR;
}
argc -= 1;
argv += 1;
if (d1 == 0.0 && argc == 0) {
mpi_bcast_coulomb_params();
return TCL_OK;
}
if(argc < 1) {
Tcl_AppendResult(interp, "wrong # args for inter magnetic.",
(char *) NULL);
mpi_bcast_coulomb_params();
return TCL_ERROR;
}
/* check method */
#define REGISTER_DIPOLAR(name, parser) \
if(ARG0_IS_S(name)) \
return parser(interp, argc-1, argv+1);
#ifdef DP3M
REGISTER_DIPOLAR("p3m", tclcommand_inter_magnetic_parse_dp3m);
#endif
REGISTER_DIPOLAR("dawaanr", tclcommand_inter_magnetic_parse_dawaanr);
REGISTER_DIPOLAR("mdds", tclcommand_inter_magnetic_parse_mdds);
/* fallback */
coulomb.Dmethod = DIPOLAR_NONE;
coulomb.Dbjerrum = 0.0;
mpi_bcast_coulomb_params();
Tcl_AppendResult(interp, "do not know magnetic method \"",argv[0],
"\": magnetic switched off", (char *) NULL);
return TCL_ERROR;
}
int tclcommand_inter_coulomb_parse_ewaldgpu(Tcl_Interp * interp, int argc, char ** argv)
{
double r_cut;
int num_kx;
int num_ky;
int num_kz;
double accuracy;
double alpha=-1;
IntList il;
init_intlist(&il);
if (argc < 1)
{
Tcl_AppendResult(interp, "expected: inter coulomb <bjerrum> ewaldgpu <r_cut> (<K_cut> | {<K_cut,x> <K_cut,y><K_cut,z>}) <alpha> \nexpected: inter coulomb <bjerrum> ewaldgpu tune <accuracy> [<precision>] \nexpected: inter coulomb <bjerrum> ewaldgpu tunealpha <r_cut> <K_cut> [<precision>]",(char *) NULL);
return TCL_ERROR;
}
if (ARG0_IS_S("tune"))
{
int status = tclcommand_inter_coulomb_parse_ewaldgpu_tune(interp, argc-1, argv+1, 0);
if(status==TCL_OK) return TCL_OK;
if(status==TCL_ERROR)
{
Tcl_AppendResult(interp, "Accuracy could not been reached. Choose higher K_max or lower accuracy",(char *) NULL);
return TCL_ERROR;
}
}
if (ARG0_IS_S("tunealpha"))
return tclcommand_inter_coulomb_parse_ewaldgpu_tunealpha(interp, argc-1, argv+1);
if(! ARG0_IS_D(r_cut))
return TCL_ERROR;
if(argc < 3 || argc > 5) {
Tcl_AppendResult(interp, "expected: inter coulomb <bjerrum> ewaldgpu <r_cut> (<K_cut> | {<K_cut,x> <K_cut,y><K_cut,z>}) <alpha> \nexpected: inter coulomb <bjerrum> ewaldgpu tune <accuracy> [<precision>] \nexpected: inter coulomb <bjerrum> ewaldgpu tunealpha <r_cut> <K_cut> [<precision>]",(char *) NULL);
return TCL_ERROR;
}
if(! ARG_IS_I(1, num_kx))
{
if( ! ARG_IS_INTLIST(1, il) || !(il.n == 3) )
{
Tcl_AppendResult(interp, "integer or interger list of length 3 expected", (char *) NULL);
return TCL_ERROR;
}
else
{
num_kx = il.e[0];
num_ky = il.e[1];
num_kz = il.e[2];
}
}
else
{
num_kz = num_ky = num_kx;
}
if(argc > 2)
{
if(! ARG_IS_D(2, alpha))
return TCL_ERROR;
}
else
{
Tcl_AppendResult(interp, "Automatic ewaldgpu tuning not implemented.",
(char *) NULL);
return TCL_ERROR;
}
if(argc > 3)
{
if(! ARG_IS_D(3, accuracy))
{
Tcl_AppendResult(interp, "accuracy double expected", (char *) NULL);
return TCL_ERROR;
}
}
// Create object
EwaldgpuForce *A=new EwaldgpuForce(r_cut, num_kx, num_ky, num_kz, alpha);
FI.addMethod(A);
rebuild_verletlist = 1;
ewaldgpu_params.ewaldgpu_is_running = true;
ewaldgpu_params.isTuned = true;
mpi_bcast_coulomb_params();
mpi_bcast_event(INVALIDATE_SYSTEM);
return TCL_OK;
}
int tclcommand_analyze_set_parse_trapmol(Tcl_Interp *interp, int argc, char **argv)
{
#ifdef MOLFORCES
#ifdef EXTERNAL_FORCES
int trap_flag = 0;
int noforce_flag =0;
int i;
#endif
#endif
int mol_num;
double spring_constant;
double drag_constant;
int isrelative;
DoubleList trap_center;
IntList trap_coords;
IntList noforce_coords;
char usage[] = "trapmol usage: <mol_id> { <xpos> <ypos> <zpos> } <isrelative> <spring_constant> <drag_constant> coords { <trapped_coord> <trapped_coord> <trapped_coord> } noforce_coords {<noforce_coord> <noforce_coord> <noforce_coord>}";
init_doublelist(&trap_center);
init_intlist(&trap_coords);
alloc_intlist(&trap_coords,3);
init_intlist(&noforce_coords);
alloc_intlist(&noforce_coords,3);
/* Unless coords are specified the default is just to trap it completely */
trap_coords.e[0] = 1;
trap_coords.e[1] = 1;
trap_coords.e[2] = 1;
Tcl_ResetResult(interp);
/* The first argument should be a molecule number */
if (!ARG0_IS_I(mol_num)) {
Tcl_AppendResult(interp, "first argument should be a molecule id", (char *)NULL);
Tcl_AppendResult(interp, usage, (char *)NULL);
return TCL_ERROR;
} else {
/* Sanity checks */
if (mol_num > n_molecules) {
Tcl_AppendResult(interp, "trapmol: cannot trap mol %d because it does not exist",mol_num , (char *)NULL);
return TCL_ERROR;
}
argc--;
argv++;
}
/* The next argument should be a double list specifying the trap center */
if (!ARG0_IS_DOUBLELIST(trap_center)) {
Tcl_AppendResult(interp, "second argument should be a double list", (char *)NULL);
Tcl_AppendResult(interp, usage , (char *)NULL);
return TCL_ERROR;
} else {
argc -= 1;
argv += 1;
}
/* The next argument should be an integer specifying whether the trap is relative (fraction of box_l) or absolute */
if (!ARG0_IS_I(isrelative)) {
Tcl_AppendResult(interp, "third argument should be an integer", (char *)NULL);
Tcl_AppendResult(interp, usage, (char *)NULL);
return TCL_ERROR;
} else {
argc -= 1;
argv += 1;
}
/* The next argument should be the spring constant for the trap */
if (!ARG0_IS_D(spring_constant)) {
Tcl_AppendResult(interp, "fourth argument should be a double", (char *)NULL);
Tcl_AppendResult(interp, usage, (char *)NULL);
return TCL_ERROR;
} else {
argc -= 1;
argv += 1;
}
/* The next argument should be the drag constant for the trap */
if (!ARG0_IS_D(drag_constant)) {
Tcl_AppendResult(interp, "fifth argument should be a double", (char *)NULL);
Tcl_AppendResult(interp, usage, (char *)NULL);
return TCL_ERROR;
} else {
argc -= 1;
argv += 1;
}
/* Process optional arguments */
while ( argc > 0 ) {
if ( ARG0_IS_S("coords") ) {
if ( !ARG_IS_INTLIST(1,trap_coords) ) {
Tcl_AppendResult(interp, "an intlist is required to specify coords", (char *)NULL);
Tcl_AppendResult(interp, usage, (char *)NULL);
return TCL_ERROR;
}
argc -= 2;
argv += 2;
} else if ( ARG0_IS_S("noforce_coords")) {
if ( !ARG_IS_INTLIST(1,noforce_coords) ) {
Tcl_AppendResult(interp, "an intlist is required to specify coords", (char *)NULL);
Tcl_AppendResult(interp, usage, (char *)NULL);
return TCL_ERROR;
}
argc -= 2;
argv += 2;
} else {
Tcl_AppendResult(interp, "an option is not recognised", (char *)NULL);
Tcl_AppendResult(interp, usage, (char *)NULL);
return TCL_ERROR;
}
}
#ifdef MOLFORCES
#ifdef EXTERNAL_FORCES
for (i = 0; i < 3; i++) {
if (trap_coords.e[i])
trap_flag |= COORD_FIXED(i);
if (noforce_coords.e[i])
noforce_flag |= COORD_FIXED(i);
}
if (set_molecule_trap(mol_num, trap_flag,&trap_center,spring_constant, drag_constant, noforce_flag, isrelative) == TCL_ERROR) {
Tcl_AppendResult(interp, "set topology first", (char *)NULL);
return TCL_ERROR;
}
#else
Tcl_AppendResult(interp, "Error: EXTERNAL_FORCES not defined ", (char *)NULL);
return TCL_ERROR;
#endif
#endif
realloc_doublelist(&trap_center,0);
realloc_intlist(&trap_coords,0);
realloc_intlist(&noforce_coords,0);
return tclcommand_analyze_set_parse_topo_part_sync(interp);
}
int tclcommand_inter_coulomb_parse_p3m(Tcl_Interp * interp, int argc, char ** argv)
{
double r_cut, alpha, accuracy = -1.0;
int mesh[3], cao, i;
IntList il;
init_intlist(&il);
if (argc < 1) {
Tcl_AppendResult(interp, "expected: inter coulomb <bjerrum> p3m tune | [gpu] <r_cut> { <mesh> | \\{ <mesh_x> <mesh_y> <mesh_z> \\} } <cao> [<alpha> [<accuracy>]]",
(char *) NULL);
return TCL_ERROR;
}
if (ARG0_IS_S("gpu")) {
coulomb.method = COULOMB_P3M_GPU;
argc--;
argv++;
}
if (ARG0_IS_S("tune"))
return tclcommand_inter_coulomb_parse_p3m_tune(interp, argc-1, argv+1, 0);
if (ARG0_IS_S("tunev2"))
return tclcommand_inter_coulomb_parse_p3m_tune(interp, argc-1, argv+1, 1);
if(! ARG0_IS_D(r_cut))
return TCL_ERROR;
if(argc < 3 || argc > 5) {
Tcl_AppendResult(interp, "wrong # arguments: inter coulomb <bjerrum> p3m [gpu] <r_cut> { <mesh> | \\{ <mesh_x> <mesh_y> <mesh_z> \\} } <cao> [<alpha> [<accuracy>]]",
(char *) NULL);
return TCL_ERROR;
}
if(! ARG_IS_I(1, mesh[0])) {
Tcl_ResetResult(interp);
if( ! ARG_IS_INTLIST(1, il) || !(il.n == 3) ) {
Tcl_AppendResult(interp, "integer or integer list of length 3 expected", (char *) NULL);
return TCL_ERROR;
} else {
mesh[0] = il.e[0];
mesh[1] = il.e[1];
mesh[2] = il.e[2];
}
} else {
mesh[1] = mesh[2] = mesh[0];
}
if ( mesh[0]%2 != 0 || mesh[1]%2 != 0 || mesh[2]%2 != 0 ) {
Tcl_AppendResult(interp, "P3M requires an even number of mesh points in all directions", (char *) NULL);
return TCL_ERROR;
}
if(! ARG_IS_I(2, cao)) {
Tcl_AppendResult(interp, "integer expected", (char *) NULL);
return TCL_ERROR;
}
if(argc > 3) {
if(! ARG_IS_D(3, alpha))
return TCL_ERROR;
}
else {
Tcl_AppendResult(interp, "Automatic p3m tuning not implemented.",
(char *) NULL);
return TCL_ERROR;
}
if(argc > 4) {
if(! ARG_IS_D(4, accuracy)) {
Tcl_AppendResult(interp, "double expected", (char *) NULL);
return TCL_ERROR;
}
}
if ((i = p3m_set_params(r_cut, mesh, cao, alpha, accuracy)) < 0) {
switch (i) {
case -1:
Tcl_AppendResult(interp, "r_cut must be positive", (char *) NULL);
break;
case -2:
Tcl_AppendResult(interp, "mesh must be positive", (char *) NULL);
break;
case -3:
Tcl_AppendResult(interp, "cao must be between 1 and 7 and less than mesh",
(char *) NULL);
break;
case -4:
Tcl_AppendResult(interp, "alpha must be positive", (char *) NULL);
break;
case -5:
Tcl_AppendResult(interp, "accuracy must be positive", (char *) NULL);
break;
default:;
Tcl_AppendResult(interp, "unspecified error", (char *) NULL);
}
return TCL_ERROR;
}
return TCL_OK;
}
/** Parser for the \ref tclcommand_lbnode command. */
int tclcommand_lbnode(ClientData data, Tcl_Interp *interp, int argc, char **argv) {
#if defined (LB) || defined (LB_GPU)
int coord[3];
int counter;
int integer_return = 0;
double double_return[19];
char double_buffer[TCL_DOUBLE_SPACE];
char integer_buffer[TCL_INTEGER_SPACE];
for (counter = 0; counter < 19; counter++)
double_return[counter]=0;
--argc; ++argv;
if (lattice_switch & LATTICE_LB_GPU) {
} else {
#ifdef LB
if (lbfluid[0][0]==0) {
Tcl_AppendResult(interp, "lbnode: lbfluid not correctly initialized", (char *)NULL);
return TCL_ERROR;
}
#endif
}
if (argc < 3) {
lbnode_tcl_print_usage(interp);
return TCL_ERROR;
}
if (!ARG_IS_I(0,coord[0]) || !ARG_IS_I(1,coord[1]) || !ARG_IS_I(2,coord[2])) {
Tcl_AppendResult(interp, "Coordinates are not integer.", (char *)NULL);
return TCL_ERROR;
}
if (lattice_switch & LATTICE_LB_GPU) {
#ifdef LB_GPU
if (coord[0]<0 || coord[0]>(box_l[0])/lbpar_gpu.agrid-1 || coord[1]<0 || coord[1]>(box_l[1])/lbpar_gpu.agrid-1 || coord[2]<0 || coord[2]>(box_l[2])/lbpar_gpu.agrid-1) {
Tcl_AppendResult(interp, "Coordinates do not correspond to a valid LB node index", (char *)NULL);
return TCL_ERROR;
}
#endif
}
else {
#ifdef LB
if (coord[0]<0 || coord[0]>(box_l[0])/lbpar.agrid-1 || coord[1]<0 || coord[1]>(box_l[1])/lbpar.agrid-1 || coord[2]<0 || coord[2]>(box_l[2])/lbpar.agrid-1) {
Tcl_AppendResult(interp, "Coordinates do not correspond to a valid LB node index", (char *)NULL);
return TCL_ERROR;
}
#endif
}
argc-=3; argv+=3;
if (ARG0_IS_S("print")) {
argc--; argv++;
while (argc > 0) {
if (ARG0_IS_S("rho") || ARG0_IS_S("density")) {
lb_lbnode_get_rho(coord, double_return);
for (counter = 0; counter < 1; counter++) {
Tcl_PrintDouble(interp, double_return[counter], double_buffer);
Tcl_AppendResult(interp, double_buffer, " ", (char *)NULL);
}
argc--; argv++;
}
else if (ARG0_IS_S("u") || ARG0_IS_S("v") || ARG0_IS_S("velocity")) {
lb_lbnode_get_u(coord, double_return);
for (counter = 0; counter < 3; counter++) {
Tcl_PrintDouble(interp, double_return[counter], double_buffer);
Tcl_AppendResult(interp, double_buffer, " ", (char *)NULL);
}
argc--; argv++;
}
else if (ARG0_IS_S("pi") || ARG0_IS_S("pressure")) {
lb_lbnode_get_pi(coord, double_return);
for (counter = 0; counter < 6; counter++) {
Tcl_PrintDouble(interp, double_return[counter], double_buffer);
Tcl_AppendResult(interp, double_buffer, " ", (char *)NULL);
}
argc--; argv++;
}
else if (ARG0_IS_S("pi_neq")) { /* this has to come after pi */
lb_lbnode_get_pi_neq(coord, double_return);
for (counter = 0; counter < 6; counter++) {
Tcl_PrintDouble(interp, double_return[counter], double_buffer);
Tcl_AppendResult(interp, double_buffer, " ", (char *)NULL);
}
argc--; argv++;
}
else if (ARG0_IS_S("boundary")) {
lb_lbnode_get_boundary(coord, &integer_return);
sprintf(integer_buffer, "%d", integer_return);
Tcl_AppendResult(interp, integer_buffer, " ", (char *)NULL);
argc--; argv++;
}
else if (ARG0_IS_S("populations") || ARG0_IS_S("pop")) {
lb_lbnode_get_pop(coord, double_return);
for (counter = 0; counter < 19; counter++) {
Tcl_PrintDouble(interp, double_return[counter], double_buffer);
Tcl_AppendResult(interp, double_buffer, " ", (char *)NULL);
}
argc--; argv++;
}
else {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "unknown fluid data \"", argv[0], "\" requested", (char *)NULL);
return TCL_ERROR;
}
}
}
else if (ARG0_IS_S("set")) {
argc--; argv++;
if (ARG0_IS_S("rho") || ARG0_IS_S("density")) {
argc--; argv++;
for (counter = 0; counter < 1; counter++) {
if (!ARG0_IS_D(double_return[counter])) {
Tcl_AppendResult(interp, "recieved not a double but \"", argv[0], "\" requested", (char *)NULL);
return TCL_ERROR;
}
argc--; argv++;
}
if (lb_lbnode_set_rho(coord, double_return[0]) != 0) {
Tcl_AppendResult(interp, "General Error on lbnode set rho.", (char *)NULL);
return TCL_ERROR;
}
}
else if (ARG0_IS_S("u") || ARG0_IS_S("v") || ARG0_IS_S("velocity")) {
argc--; argv++;
for (counter = 0; counter < 3; counter++) {
if (!ARG0_IS_D(double_return[counter])) {
Tcl_AppendResult(interp, "received not a double but \"", argv[0], "\" requested", (char *)NULL);
return TCL_ERROR;
}
argc--; argv++;
}
if (lb_lbnode_set_u(coord, double_return) != 0) {
Tcl_AppendResult(interp, "General Error on lbnode set u.", (char *)NULL);
return TCL_ERROR;
}
}
else if (ARG0_IS_S("pop") || ARG0_IS_S("populations") ) {
argc--; argv++;
for (counter = 0; counter < 19; counter++) {
if (!ARG0_IS_D(double_return[counter])) {
Tcl_AppendResult(interp, "recieved not a double but \"", argv[0], "\" requested", (char *)NULL);
return TCL_ERROR;
}
argc--; argv++;
}
if (lb_lbnode_set_pop(coord, double_return) != 0) {
Tcl_AppendResult(interp, "General Error on lbnode set pop.", (char *)NULL);
return TCL_ERROR;
}
}
else {
Tcl_AppendResult(interp, "unknown feature \"", argv[0], "\" of lbnode x y z set", (char *)NULL);
return TCL_ERROR;
}
} else {
Tcl_AppendResult(interp, "unknown feature \"", argv[0], "\" of lbnode", (char *)NULL);
return TCL_ERROR;
}
return TCL_OK;
#else /* !defined LB */
Tcl_AppendResult(interp, "LB is not compiled in!", NULL);
return TCL_ERROR;
#endif
}
int tclcommand_inter_coulomb_parse_ewaldgpu_tunealpha(Tcl_Interp * interp, int argc, char ** argv)
{
double r_cut;
double alpha;
int num_kx;
int num_ky;
int num_kz;
double precision=0.000001;
IntList il;
init_intlist(&il);
//PARSE EWALD COMMAND LINE
if (argc < 3)
{
Tcl_AppendResult(interp, "\nWrong # arguments: <r_cut> (<K_cut> | {<K_cut,x> <K_cut,y><K_cut,z>}) <precision>", (char *) NULL);
return TCL_ERROR;
}
if (! ARG0_IS_D(r_cut))
{
Tcl_AppendResult(interp, "\n<r_cut> should be a double",(char *) NULL);
return TCL_ERROR;
}
if(! ARG_IS_I(1, num_kx))
{
if( ! ARG_IS_INTLIST(1, il) || !(il.n == 3) )
{
Tcl_AppendResult(interp, "\n(<K_cut> | {<K_cut,x> <K_cut,y><K_cut,z>}) integer or integer list of length 3 expected", (char *) NULL);
return TCL_ERROR;
}
else
{
num_kx = il.e[0];
num_ky = il.e[1];
num_kz = il.e[2];
}
}
else
{
num_kz = num_ky = num_kx;
}
if (! ARG_IS_D(2, precision))
{
Tcl_AppendResult(interp, "\n<precision> should be a double", (char *) NULL);
return TCL_ERROR;
}
//Compute alpha
Particle *particle;
particle = (Particle*)Utils::malloc(n_part*sizeof(Particle));
mpi_get_particles(particle, NULL);
double q_sqr = ewaldgpuForce->compute_q_sqare(particle);
alpha = ewaldgpuForce->compute_optimal_alpha(r_cut, num_kx, num_ky, num_kz, q_sqr, box_l, precision);
//Turn on ewaldgpu
if (!ewaldgpuForce) // inter coulomb ewaldgpu was never called before
{
ewaldgpuForce = new EwaldgpuForce(espressoSystemInterface, r_cut, num_kx, num_ky, num_kz, alpha);
forceActors.add(ewaldgpuForce);
energyActors.add(ewaldgpuForce);
}
//Broadcast parameters
coulomb.method = COULOMB_EWALD_GPU;
ewaldgpu_params.isTunedFlag = false;
ewaldgpu_params.isTuned = true;
rebuild_verletlist = 1;
mpi_bcast_coulomb_params();
return TCL_OK;
}
int tclcommand_thermostat_parse_dpd(Tcl_Interp *interp, int argc, char **argv)
{
extern double dpd_gamma,dpd_r_cut;
extern int dpd_wf;
#ifdef TRANS_DPD
extern double dpd_tgamma,dpd_tr_cut;
extern int dpd_twf;
#endif
double temp, gamma, r_cut;
int wf=0;
#ifdef TRANS_DPD
double tgamma=0.0,tr_cut;
int twf;
int set_tgamma=0;
#endif
#ifdef ROTATION
fprintf(stderr,"WARNING: Do not use DPD with ROTATION compiled in\n");
fprintf(stderr," You should first check if a combination of a DPD thermostat\n");
fprintf(stderr," for the translational degrees of freedom and a LANGEVIN thermostat\n");
fprintf(stderr," for the rotational ones yields correct physics!\n");
fprintf(stderr," After this you may remove these lines (thermostat.c::tclcommand_thermostat_parse_dpd)!\n");
#endif
/* check number of arguments */
if (argc < 5) {
Tcl_AppendResult(interp, "wrong # args: should be \n\"",
argv[0]," ",argv[1]," <temp> <gamma> <r_cut>", (char *)NULL);
#ifdef TRANS_DPD
Tcl_AppendResult(interp,"[<tgamma>] [<tR_cut>]", (char *)NULL);
#endif
Tcl_AppendResult(interp," [WF <wf>]", (char *)NULL);
#ifdef TRANS_DPD
Tcl_AppendResult(interp," [TWF <twf>]", (char *)NULL);
#endif
Tcl_AppendResult(interp,"\"", (char *)NULL);
return (TCL_ERROR);
}
/* check argument types */
if ( !ARG_IS_D(2, temp) || !ARG_IS_D(3, gamma) || !ARG_IS_D(4, r_cut)) {
Tcl_AppendResult(interp, argv[0]," ",argv[1]," needs at least three DOUBLES", (char *)NULL);
return (TCL_ERROR);
}
argc-=5;
argv+=5;
#ifdef TRANS_DPD
tgamma=0;
tr_cut=r_cut;
twf=wf;
if ( (argc>0) && (!ARG0_IS_S("WF")) ) {
if (!ARG0_IS_D(tgamma)) {
Tcl_AppendResult(interp," thermostat dpd: tgamma should be double",(char *)NULL);
return (TCL_ERROR);
}
else{
argc--;
argv++;
set_tgamma++;
}
}
#endif
//try for WF
if ( (argc>0) && (ARG0_IS_S("WF")) ){
if (!ARG1_IS_I(wf)){
Tcl_AppendResult(interp," thermostat dpd: wf should be int",(char *)NULL);
return (TCL_ERROR);
}
else{
argc-=2;argv+=2;
#ifdef TRANS_DPD
twf=wf;
#endif
}
}
#ifdef TRANS_DPD
if ( (set_tgamma==0) && (argc>0) && (!ARG0_IS_S("TWF")) ) {
if (!ARG0_IS_D(tgamma)) {
Tcl_AppendResult(interp," thermostat dpd: tgamma should be double",(char *)NULL);
return (TCL_ERROR);
}
else{
argc--;
argv++;
set_tgamma++;
}
}
if ( (argc>0) && (!ARG0_IS_S("TWF")) ) {
if (set_tgamma!=0) {
if (!ARG0_IS_D(tr_cut)) {
Tcl_AppendResult(interp," thermostat dpd: tr_cut should be double",(char *)NULL);
return (TCL_ERROR);
}
else{
argc--;
argv++;
}
}
else{
Tcl_AppendResult(interp," thermostat dpd: tgamma must be set before twf",(char *)NULL);
return (TCL_ERROR);
}
}
if ( (argc>0) && (ARG0_IS_S("TWF")) ) {
if (set_tgamma!=0) {
if (!ARG1_IS_I(wf)) {
Tcl_AppendResult(interp," thermostat dpd: twf should be int",(char *)NULL);
return (TCL_ERROR);
}
else{
argc-=2;argv+=2;
}
}
else{
Tcl_AppendResult(interp," thermostat dpd: tgamma must be set before twf",(char *)NULL);
return (TCL_ERROR);
}
}
#endif
if (argc > 0){
Tcl_AppendResult(interp," thermostat dpd: too many arguments - don't know how to parse them!!!",(char *)NULL);
return (TCL_ERROR);
}
/* broadcast parameters */
temperature = temp;
dpd_gamma = gamma;
dpd_r_cut = r_cut;
dpd_wf = wf;
#ifdef TRANS_DPD
dpd_tgamma = tgamma;
dpd_tr_cut= tr_cut;
dpd_twf=twf;
#endif
thermo_switch = ( thermo_switch | THERMO_DPD );
mpi_bcast_parameter(FIELD_THERMO_SWITCH);
mpi_bcast_parameter(FIELD_TEMPERATURE);
mpi_bcast_parameter(FIELD_DPD_GAMMA);
mpi_bcast_parameter(FIELD_DPD_RCUT);
mpi_bcast_parameter(FIELD_DPD_WF);
#ifdef TRANS_DPD
mpi_bcast_parameter(FIELD_DPD_TGAMMA);
mpi_bcast_parameter(FIELD_DPD_TRCUT);
mpi_bcast_parameter(FIELD_DPD_TWF);
#endif
return (TCL_OK);
}
int tclcommand_analyze_parse_local_stress_tensor(Tcl_Interp *interp, int argc, char **argv)
{
char buffer[TCL_DOUBLE_SPACE];
int periodic[3];
double range_start[3];
double range[3];
int bins[3];
int i,j,k,l;
DoubleList *TensorInBin;
PTENSOR_TRACE(fprintf(stderr,"%d: Running tclcommand_analyze_parse_local_stress_tensor\n",this_node));
/* 'analyze stress profile ' */
if (argc != 12) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "local_stress_tensor requires 12 inputs: x_periodic, y_periodic, z_periodic, x_range_start, y_range_start, z_range_start, x_range, y_range, z_range, x_bins, y_bins, z_bins", (char *)NULL);
return(TCL_ERROR);
}
const char *usage = "usage: analyse local_stress_tensor <x_periodic> <y_periodic> <z_periodic> <x_range_start> <y_range_start> <z_range_start> <x_range> <y_range> <z_range> <x_bins> <y_bins> <z_bins>";
for (i=0;i<3;i++) {
if ( !ARG0_IS_I(periodic[i]) ) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp,usage, (char *)NULL);
return (TCL_ERROR);
} else {
argc -= 1;
argv += 1;
}
}
for (i=0;i<3;i++) {
if ( !ARG0_IS_D(range_start[i]) ) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp,usage, (char *)NULL);
return (TCL_ERROR);
} else {
argc -= 1;
argv += 1;
}
}
for (i=0;i<3;i++) {
if ( !ARG0_IS_D(range[i]) ) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp,usage, (char *)NULL);
return (TCL_ERROR);
} else {
argc -= 1;
argv += 1;
}
}
for (i=0;i<3;i++) {
if ( !ARG0_IS_I(bins[i]) ) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp,usage, (char *)NULL);
return (TCL_ERROR);
} else {
argc -= 1;
argv += 1;
}
}
/* Allocate a doublelist of bins to keep track of stress profile */
TensorInBin = (DoubleList *)malloc(bins[0]*bins[1]*bins[2]*sizeof(DoubleList));
if ( TensorInBin ) {
/* Initialize the stress profile */
for ( i = 0 ; i < bins[0]*bins[1]*bins[2]; i++ ) {
init_doublelist(&TensorInBin[i]);
alloc_doublelist(&TensorInBin[i],9);
for ( j = 0 ; j < 9 ; j++ ) {
TensorInBin[i].e[j] = 0.0;
}
}
} else {
Tcl_AppendResult(interp,"could not allocate memory for local_stress_tensor", (char *)NULL);
return (TCL_ERROR);
}
mpi_local_stress_tensor(TensorInBin, bins, periodic,range_start, range);
PTENSOR_TRACE(fprintf(stderr,"%d: tclcommand_analyze_parse_local_stress_tensor: finished mpi_local_stress_tensor \n",this_node));
/* Write stress profile to Tcl export */
Tcl_AppendResult(interp, "{ LocalStressTensor } ", (char *)NULL);
for ( i = 0 ; i < bins[0] ; i++) {
for ( j = 0 ; j < bins[1] ; j++) {
for ( k = 0 ; k < bins[2] ; k++) {
Tcl_AppendResult(interp, " { ", (char *)NULL);
sprintf(buffer," { %d %d %d } ",i,j,k);
Tcl_AppendResult(interp,buffer, (char *)NULL);
Tcl_AppendResult(interp, " { ", (char *)NULL);
for ( l = 0 ; l < 9 ; l++) {
Tcl_PrintDouble(interp,TensorInBin[i*bins[1]*bins[2]+j*bins[2]+k].e[l],buffer);
Tcl_AppendResult(interp, buffer, (char *)NULL);
Tcl_AppendResult(interp, " ", (char *)NULL);
}
Tcl_AppendResult(interp, " } ", (char *)NULL);
Tcl_AppendResult(interp, " } ", (char *)NULL);
}
}
}
/* Free memory */
for ( i = 0 ; i < bins[0]*bins[1]*bins[2] ; i++ ) {
realloc_doublelist(&TensorInBin[i],0);
}
free(TensorInBin);
return TCL_OK;
}
int tclcommand_inter_coulomb_parse_elc_params(Tcl_Interp * interp, int argc, char ** argv)
{
double pwerror;
double gap_size;
double far_cut = -1;
double top = 1, mid = 1, bot = 1;
double delta_top = 0, delta_bot = 0;
int neutralize = 1;
double pot_diff = 0;
int const_pot_on = 0;
if (argc < 2) {
Tcl_AppendResult(interp, "either nothing or elc <pwerror> <minimal layer distance> {<cutoff>} <{dielectric <di_top> <di_mid> <di_bottom>} | {dielectric-contrasts <d1> <d2>} | {capacitor <dU>}> {noneutralization} expected, not \"",
argv[0], "\"", (char *)NULL);
return TCL_ERROR;
}
if (!ARG0_IS_D(pwerror))
return TCL_ERROR;
if (!ARG1_IS_D(gap_size))
return TCL_ERROR;
argc -= 2; argv += 2;
if (argc > 0) {
// if there, parse away manual cutoff
if(ARG0_IS_D(far_cut)) {
argc--; argv++;
}
else
Tcl_ResetResult(interp);
while (argc > 0) {
if (ARG0_IS_S("noneutralization") || ARG0_IS_S("-noneutralization")) {
neutralize = 0;
argc--; argv++;
}
else if (argc >= 4 && ARG0_IS_S("dielectric")) {
Tcl_AppendResult(interp, "There seems to be an error when using ELC with dielectric constrasts. If you are sure you want to use it, you have to deactivate this message manually. ", (char *)NULL);
return TCL_ERROR;
// just a dummy, not used, as it is only printed for information
// purposes. We need to calculate it
double space_layer_dummy;
if (!ARG_IS_D(1,top) || !ARG_IS_D(2,mid) || !ARG_IS_D(3,bot))
return TCL_ERROR;
delta_top = (mid - top)/(mid + top);
delta_bot = (mid - bot)/(mid + bot);
argc -= 4; argv += 4;
if (argc > 0 && ARG_IS_D(4, space_layer_dummy)) {
argc--; argv++;
}
}
else if (argc >= 3 && ARG0_IS_S("dielectric-contrasts")) {
Tcl_AppendResult(interp, "There seems to be an error when using ELC with dielectric constrasts. If you are sure you want to use it, you have to deactivate this message manually. ", (char *)NULL);
return TCL_ERROR;
if (!ARG_IS_D(1,delta_top) || !ARG_IS_D(2,delta_bot))
return TCL_ERROR;
argc -= 3; argv += 3;
}
else if (argc >= 1 && ARG0_IS_S("capacitor")) {
Tcl_AppendResult(interp, "There seems to be an error when using ELC with dielectric constrasts. If you are sure you want to use it, you have to deactivate this message manually. ", (char *)NULL);
return TCL_ERROR;
if (!ARG_IS_D(1,pot_diff))
return TCL_ERROR;
argc -= 2; argv += 2;
const_pot_on = 1;
delta_top = -1; delta_bot = -1;
}
else {
Tcl_AppendResult(interp, "either nothing or elc <pwerror> <minimal layer distance> {<cutoff>} <{dielectric <di_top> <di_mid> <di_bottom>} | {dielectric-contrasts <d1> <d2>} | {capacitor <dU>}> {noneutralization} expected, not \"", argv[0], "\"", (char *)NULL);
return TCL_ERROR;
}
}
}
CHECK_VALUE(ELC_set_params(pwerror, gap_size, far_cut, neutralize, delta_top, delta_bot, const_pot_on, pot_diff),
"choose a 3d electrostatics method prior to ELC");
}
int tclcommand_readpdb(ClientData data, Tcl_Interp *interp, int argc, char *argv[]) {
char *pdb_file = NULL;
char *itp_file = NULL;
int first_id = -1;
int first_type = 0;
int type = -1;
bool fit = false;
bool lj_internal = false;
double lj_rel_cutoff = 2.5;
bool lj_diagonal = false;
std::vector<PdbLJInteraction> ljinteractions;
argc--;
argv++;
while(argc > 0) {
if(ARG0_IS_S("pdb_file")) {
argc--;
argv++;
pdb_file = argv[0];
} else if (ARG0_IS_S("itp_file")) {
argc--;
argv++;
itp_file = argv[0];
} else if (ARG0_IS_S("type")) {
argc--;
argv++;
if(!ARG0_IS_I(type)) {
Tcl_AppendResult(interp, "type takes exactly one integer argument.\n", (char *)NULL);
return TCL_ERROR;
}
} else if (ARG0_IS_S("first_id")) {
argc--;
argv++;
if(!ARG0_IS_I(first_id)) {
Tcl_AppendResult(interp, "first_id takes exactly one integer argument.\n", (char *)NULL);
return TCL_ERROR;
}
} else if (ARG0_IS_S("first_type")) {
argc--;
argv++;
if(!ARG0_IS_I(first_type)) {
Tcl_AppendResult(interp, "first_type takes exactly one integer argument.\n", (char *)NULL);
return TCL_ERROR;
}
} else if (ARG0_IS_S("lj_rel_cutoff")) {
argc--;
argv++;
if(!ARG0_IS_D(lj_rel_cutoff)) {
return TCL_ERROR;
}
} else if (ARG0_IS_S("rescale_box")) {
fit = true;
} else if (ARG0_IS_S("lj_internal")) {
lj_internal = true;
lj_diagonal = false;
} else if (ARG0_IS_S("lj_diagonal")) {
lj_internal = true;
lj_diagonal = true;
} else if (ARG0_IS_S("lj_with")) {
argc--;
argv++;
if(argc < 3)
return TCL_ERROR;
struct PdbLJInteraction ljia;
if(!ARG0_IS_I(ljia.other_type)) {
return TCL_ERROR;
}
argc--;
argv++;
if(!ARG0_IS_D(ljia.epsilon)) {
return TCL_ERROR;
}
argc--;
argv++;
if(!ARG0_IS_D(ljia.sigma)) {
return TCL_ERROR;
}
ljinteractions.push_back(ljia);
}
else {
usage(interp);
return TCL_ERROR;
}
argc--;
argv++;
}
if((type < 0) || (first_id < 0) || (pdb_file == NULL)) {
usage(interp);
return TCL_ERROR;
}
const int n_part = pdb_add_particles_from_file(pdb_file, first_id, type, ljinteractions, lj_rel_cutoff, itp_file, first_type, fit, lj_internal, lj_diagonal);
if(!n_part) {
Tcl_AppendResult(interp, "Could not parse pdb file.", (char *)NULL);
return TCL_ERROR;
}
char buffer[32];
snprintf(buffer, sizeof(buffer), "%d", n_part);
Tcl_AppendResult(interp, buffer, (char *)NULL);
return TCL_OK;
}
