static int lbnode_parse_set(Tcl_Interp *interp, int argc, char **argv, int *ind) {
unsigned int index;
double f[3];
size_t size_of_extforces;
int change = 0;
if ( ind[0] >= lbpar_gpu.dim_x || ind[1] >= lbpar_gpu.dim_y || ind[2] >= lbpar_gpu.dim_z ) {
Tcl_AppendResult(interp, "position is not in the LB lattice", (char *)NULL);
return TCL_ERROR;
}
index = ind[0] + ind[1]*lbpar_gpu.dim_x + ind[2]*lbpar_gpu.dim_x*lbpar_gpu.dim_y;
while (argc > 0) {
if (change==1) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "Error in lbnode_extforce force. You can only change one field at the same time.", (char *)NULL);
return TCL_ERROR;
}
if(ARG0_IS_S("force")){
if (ARG1_IS_D(f[0])) {
argc--;
argv++;
} else return TCL_ERROR;
if (ARG1_IS_D(f[1])) {
argc--;
argv++;
} else return TCL_ERROR;
if (ARG1_IS_D(f[2])) {
argc--;
argv++;
} else return TCL_ERROR;
change=1;
}
size_of_extforces = (n_extern_nodeforces+1)*sizeof(LB_extern_nodeforce_gpu);
host_extern_nodeforces = realloc(host_extern_nodeforces, size_of_extforces);
host_extern_nodeforces[n_extern_nodeforces].force[0] = (float)f[0];
host_extern_nodeforces[n_extern_nodeforces].force[1] = (float)f[1];
host_extern_nodeforces[n_extern_nodeforces].force[2] = (float)f[2];
host_extern_nodeforces[n_extern_nodeforces].index = index;
n_extern_nodeforces++;
if(lbpar_gpu.external_force == 0)lbpar_gpu.external_force = 1;
--argc; ++argv;
lb_init_extern_nodeforces_GPU(n_extern_nodeforces, host_extern_nodeforces, &lbpar_gpu);
}
return TCL_OK;
}
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_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_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_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);
}
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);
}
/** Parses the ICCP3M command.
*/
int tclcommand_iccp3m(ClientData data, Tcl_Interp *interp, int argc, char **argv) {
char buffer[TCL_DOUBLE_SPACE];
if(iccp3m_initialized==0){
iccp3m_init();
iccp3m_initialized=1;
}
if(argc < 2 ) {
Tcl_AppendResult(interp, "Usage of ICCP3M: RTFM", (char *)NULL);
return (TCL_ERROR);
}
if (argc == 2 ){
if(ARG_IS_S(1,"iterate")) {
if (iccp3m_cfg.set_flag==0) {
Tcl_AppendResult(interp, "iccp3m parameters not set!", (char *)NULL);
return (TCL_ERROR);
} else {
Tcl_PrintDouble(interp,mpi_iccp3m_iteration(0),buffer);
Tcl_AppendResult(interp, buffer, (char *) NULL);
return TCL_OK;
}
} else if(ARG_IS_S(1,"no_iterations")) {
Tcl_PrintDouble(interp,iccp3m_cfg.citeration,buffer);
Tcl_AppendResult(interp, buffer, (char *) NULL);
return TCL_OK;
}
}
else {
if(ARG_IS_I(1, iccp3m_cfg.n_ic)) {
argc-=2;
argv+=2;
} else {
Tcl_AppendResult(interp, "ICCP3M: First argument has to be the number of induced charges", (char *)NULL);
return (TCL_ERROR);
}
while (argc > 0) {
if (ARG0_IS_S("convergence")) {
if (argc>1 && ARG1_IS_D(iccp3m_cfg.convergence)) {
argc-=2;
argv+=2;
} else {
Tcl_AppendResult(interp, "ICCP3M Usage: convergence <convergence>", (char *)NULL);
return (TCL_ERROR);
}
} else if (ARG0_IS_S("relaxation")) {
if (argc>1 && ARG1_IS_D(iccp3m_cfg.relax)) {
argc-=2;
argv+=2;
} else {
Tcl_AppendResult(interp, "ICCP3M Usage: convergence <convergence>", (char *)NULL);
return (TCL_ERROR);
}
} else if (ARG0_IS_S("eps_out")) {
if (argc>1 && ARG1_IS_D(iccp3m_cfg.eout)) {
argc-=2;
argv+=2;
} else {
Tcl_AppendResult(interp, "ICCP3M Usage: eps_out <eps_out>", (char *)NULL);
return (TCL_ERROR);
}
} else if (ARG0_IS_S("ext_field")) {
if (argc>1 && ARG1_IS_D(iccp3m_cfg.extx) && ARG_IS_D(2,iccp3m_cfg.exty) && ARG_IS_D(3,iccp3m_cfg.extz)) {
argc-=4;
argv+=4;
} else {
Tcl_AppendResult(interp, "ICCP3M Usage: eps_out <eps_out>", (char *)NULL);
return (TCL_ERROR);
}
} else if (ARG0_IS_S("max_iterations")) {
if (argc>1 && ARG1_IS_I(iccp3m_cfg.num_iteration)) {
argc-=2;
argv+=2;
} else {
Tcl_AppendResult(interp, "ICCP3M Usage: max_iterations <max_iterations>", (char *)NULL);
return (TCL_ERROR);
}
} else if (ARG0_IS_S("first_id")) {
if (argc>1 && ARG1_IS_I(iccp3m_cfg.first_id)) {
argc-=2;
argv+=2;
} else {
Tcl_AppendResult(interp, "ICCP3M Usage: first_id <first_id>", (char *)NULL);
return (TCL_ERROR);
}
} else if (ARG0_IS_S("normals")) {
if (argc>1) {
if (tclcommand_iccp3m_parse_normals(interp, iccp3m_cfg.n_ic, argv[1]) != TCL_OK) {
return TCL_ERROR;
}
argc-=2;
argv+=2;
} else {
Tcl_AppendResult(interp, "ICCP3M Usage: normals <List of normal vectors>", (char *)NULL);
return (TCL_ERROR);
}
} else if (ARG0_IS_S("areas")) {
if (argc>1) {
if (tclcommand_iccp3m_parse_double_list(interp, iccp3m_cfg.n_ic, argv[1], ICCP3M_AREA)!=TCL_OK) {
return TCL_ERROR;
}
argc-=2;
argv+=2;
} else {
Tcl_AppendResult(interp, "ICCP3M Usage: areas <list of areas>", (char *)NULL);
return (TCL_ERROR);
}
} else if (ARG0_IS_S("sigmas")) {
if (argc>1) {
if (tclcommand_iccp3m_parse_double_list(interp, iccp3m_cfg.n_ic, argv[1], ICCP3M_SIGMA)!=TCL_OK) {
return TCL_ERROR;
}
argc-=2;
argv+=2;
} else {
Tcl_AppendResult(interp, "ICCP3M Usage: sigmas <list of sigmas>", (char *)NULL);
return (TCL_ERROR);
}
} else if (ARG0_IS_S("epsilons")) {
if (argc>1) {
if (tclcommand_iccp3m_parse_double_list(interp, iccp3m_cfg.n_ic, argv[1], ICCP3M_EPSILON) != TCL_OK) {
return TCL_ERROR;
}
argc-=2;
argv+=2;
} else {
Tcl_AppendResult(interp, "ICCP3M Usage: epsilons <list of epsilons>", (char *)NULL);
return (TCL_ERROR);
}
} else {
Tcl_AppendResult(interp, "Unknown Argument to ICCP3M ", argv[0], (char *)NULL);
return (TCL_ERROR);
}
}
}
iccp3m_initialized=1;
iccp3m_cfg.set_flag = 1;
if (!iccp3m_cfg.areas || !iccp3m_cfg.ein || !iccp3m_cfg.nvectorx)
return TCL_ERROR;
if (!iccp3m_cfg.sigma) {
iccp3m_cfg.sigma = (double*) Utils::malloc(iccp3m_cfg.n_ic*sizeof(double));
memset(iccp3m_cfg.sigma, 0, iccp3m_cfg.n_ic*sizeof(double));
}
mpi_iccp3m_init(0);
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_adress_parse_set(Tcl_Interp *interp,int argc, char **argv){
int topo=-1,i,wf=0,set_center=0;
double width[2],center[3];
char buffer[3*TCL_DOUBLE_SPACE];
argv+=2;argc-=2;
for(i=0;i<3;i++) center[i]=box_l[i]/2;
if (argc < 2) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "Wrong # of args! adress set needs at least 2 arguments\n", (char *)NULL);
Tcl_AppendResult(interp, "Usage: adress set topo [0|1|2|3] width X.X Y.Y (center X.X Y.Y Z.Z) (wf [0|1])\n", (char *)NULL);
Tcl_AppendResult(interp, "topo: 0 - switched off (no more values needed)\n", (char *)NULL);
Tcl_AppendResult(interp, " 1 - constant (weight will be first value of width)\n", (char *)NULL);
Tcl_AppendResult(interp, " 2 - divided in one direction (default x, or give a negative center coordinate\n", (char *)NULL);
Tcl_AppendResult(interp, " 3 - spherical topology\n", (char *)NULL);
Tcl_AppendResult(interp, "width: X.X - half of size of ex zone(r0/2 in the papers)\n", (char *)NULL);
Tcl_AppendResult(interp, " Y.Y - size of hybrid zone (d in the papers)\n", (char *)NULL);
Tcl_AppendResult(interp, " Note: Only one value need for topo 1 \n", (char *)NULL);
Tcl_AppendResult(interp, "center: center of the ex zone (default middle of the box) \n", (char *)NULL);
Tcl_AppendResult(interp, " Note: x|y|x X.X for topo 2 \n", (char *)NULL);
Tcl_AppendResult(interp, " Note: X.X Y.Y Z.Z for topo 3 \n", (char *)NULL);
Tcl_AppendResult(interp, "wf: 0 - cos weighting function (default)\n", (char *)NULL);
Tcl_AppendResult(interp, " 1 - polynom weighting function\n", (char *)NULL);
Tcl_AppendResult(interp, "ALWAYS set box_l first !!!", (char *)NULL);
return (TCL_ERROR);
}
//parse topo
if ( (argc<2) || (!ARG0_IS_S("topo")) || (!ARG1_IS_I(topo)) || (topo < 0) || (topo > 3) ) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "expected \'topo 0|1|2|3\'\n", (char *)NULL);
return (TCL_ERROR);
}
argv+=2;argc-=2;
//stop if topo is 0
if (topo==0) {
adress_vars[0]=0.0;
mpi_bcast_parameter(FIELD_ADRESS);
return TCL_OK;
}
//parse width
if ( (argc>1) && (ARG0_IS_S("width")) ) {
if (topo==1) {
if ( (!ARG1_IS_D(width[0])) || (width[0]<0) ){
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "expected \'width X.X (X.X non-negative)\'", (char *)NULL);
return (TCL_ERROR);
}
if ((width[0]> 1.0) || (width[0]< 0.0)) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "for constant topo, first width must be between 0 and 1", (char *)NULL);
return (TCL_ERROR);
}
//stop if topo is 1
adress_vars[0]=1;
adress_vars[1]=width[0];
mpi_bcast_parameter(FIELD_ADRESS);
return TCL_OK;
}
else {//topo 2 and 3 are left over
if ( (argc<3) || (!ARG1_IS_D(width[0])) || (width[0]<0) ||(!ARG_IS_D(2,width[1])) || (width[1]<0) ){
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "expected \'width X.X Y.Y (both non-negative)\'", (char *)NULL);
return (TCL_ERROR);
}
argv+=3;argc-=3;
}
}
else{
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "expected \'width\'", (char *)NULL);
return (TCL_ERROR);
}
while (argc!=0){
if (ARG0_IS_S("wf")){
if ( (argc<2) || (!ARG1_IS_I(wf)) || (wf < 0) || (wf > 1) ){
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "expected \'wf 0|1\'", (char *)NULL);
return (TCL_ERROR);
}
else{
argv+=2;argc-=2;
}
}
else if (ARG0_IS_S("center")){
if (topo == 2) {
if ( (argc<3) || ( (!ARG1_IS_S("x"))&&(!ARG1_IS_S("y"))&&(!ARG1_IS_S("z")) ) || (!ARG_IS_D(2,center[1])) ){
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "expected \'center x|y|z X.X\'", (char *)NULL);
return (TCL_ERROR);
}
if (ARG1_IS_S("x")) center[0]=0;
else if (ARG1_IS_S("y")) center[0]=1;
else center[0]=2;
if ( (center[1]<0) || (center[1]>box_l[(int)center[0]]) ) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "The center component is outside the box", (char *)NULL);
return (TCL_ERROR);
}
set_center=1;
argv+=3;argc-=3;
}
else { //topo 3
if ( (argc<4) || (!ARG_IS_D(1,center[0])) || (!ARG_IS_D(2,center[1])) || (!ARG_IS_D(3,center[2])) ){
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "expected \'center X.X Y.Y Z.Z\'", (char *)NULL);
return (TCL_ERROR);
}
argv+=4;argc-=4;
//check components of center
for (i=0;i<3;i++){
if ( (center[i]<0)||(center[i]>box_l[i]) ){
Tcl_ResetResult(interp);
sprintf(buffer,"%i",i);
Tcl_AppendResult(interp, "The ",buffer," th component of center is outside the box\n", (char *)NULL);
return (TCL_ERROR);
}
}
}
}
else{
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "The unknown operation \"", argv[0],"\".", (char *)NULL);
return (TCL_ERROR);
}
}
//set standard center value for topo 2
if ((topo==2) && (set_center==0) ) center[0]=0;
//width check
if (topo==2){
if (width[0]+width[1]>box_l[(int)center[0]]/2){
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "The width of ex+hy must smaller than box_l/2\n", (char *)NULL);
return (TCL_ERROR);
}
}
else if (topo==3){
for (i=0;i<3;i++){
if (width[0]+width[1]>box_l[i]/2){
Tcl_ResetResult(interp);
sprintf(buffer,"%i",i);
Tcl_AppendResult(interp, "The width of ex+hy must smaller than box_l/2 in dim " ,buffer,"\n", (char *)NULL);
return (TCL_ERROR);
}
}
}
adress_vars[0]=topo;
adress_vars[1]=width[0];
adress_vars[2]=width[1];
adress_vars[3]=center[0];
adress_vars[4]=center[1];
adress_vars[5]=center[2];
adress_vars[6]=wf;
mpi_bcast_parameter(FIELD_ADRESS);
return TCL_OK;
}
int tclcommand_inter_coulomb_parse_ewaldgpu_tune(Tcl_Interp * interp, int argc, char ** argv, int adaptive)
{
double r_cut;
double alpha;
int num_kx;
int num_ky;
int num_kz;
int K_max = 30;
int time_calc_steps = 0;
double accuracy = 0.0001;
double precision = 0.000001;
while(argc > 0)
{
if(ARG0_IS_S("accuracy"))
{
if(! (argc > 1 && ARG1_IS_D(accuracy) && accuracy > 0))
{
Tcl_AppendResult(interp, "accuracy expects a positive double ",(char *) NULL);
return TCL_ERROR;
}
}
else if(ARG0_IS_S("precision"))
{
if(! (argc > 1 && ARG1_IS_D(precision) && precision > 0))
{
Tcl_AppendResult(interp, "precision expects a positive double ",(char *) NULL);
return TCL_ERROR;
}
}
else if(ARG0_IS_S("K_max"))
{
if(! (argc > 1 && ARG1_IS_I(K_max) && K_max > 0))
{
Tcl_AppendResult(interp, "K_max expects a positive integer ",(char *) NULL);
return TCL_ERROR;
}
}
else if(ARG0_IS_S("time_calc_steps"))
{
if(! (argc > 1 && ARG1_IS_I(time_calc_steps) && time_calc_steps > 0))
{
Tcl_AppendResult(interp, "time_calc_steps expects a positive integer ",(char *) NULL);
return TCL_ERROR;
}
}
/* unknown parameter. Probably one of the optionals */
else break;
argc -= 2;
argv += 2;
}
ewaldgpu_set_params_tune(accuracy, precision, K_max, time_calc_steps);
/* Create object */
EwaldgpuForce *A=new EwaldgpuForce(r_cut, num_kx, num_ky, num_kz, alpha);
FI.addMethod(A);
rebuild_verletlist = 1;
/* do the tuning */
char *log = NULL;
if (ewaldgpu_adaptive_tune(&log) == ES_ERROR)
{
Tcl_AppendResult(interp, log, "\nfailed to tune ewaldgpu parameters to required accuracy ", (char *) NULL);
if (log) free(log);
return TCL_ERROR;
}
/* Tell the user about the tuning outcome */
Tcl_AppendResult(interp, log, (char *) NULL);
if (log) free(log);
rebuild_verletlist = 1;
mpi_bcast_coulomb_params();
mpi_bcast_event(INVALIDATE_SYSTEM);
return TCL_OK;
}
int tclcommand_inter_coulomb_parse_ewaldgpu_tune(Tcl_Interp * interp, int argc, char ** argv, int adaptive)
{
double r_cut=-1;
double alpha=-1;
int num_kx=-1;
int num_ky=-1;
int num_kz=-1;
int K_max = 30;
int time_calc_steps = 100;
double accuracy = 0.0001;
double precision = 0.000001;
//PARSE EWALD COMMAND LINE
while(argc > 0)
{
if(ARG0_IS_S("accuracy"))
{
if(! (argc > 1 && ARG1_IS_D(accuracy) && accuracy > 0))
{
Tcl_AppendResult(interp, "\n<accuracy> expects a positive double ",(char *) NULL);
return TCL_ERROR;
}
}
else if(ARG0_IS_S("precision"))
{
if(! (argc > 1 && ARG1_IS_D(precision) && precision > 0))
{
Tcl_AppendResult(interp, "\n<precision> expects a positive double ",(char *) NULL);
return TCL_ERROR;
}
}
else if(ARG0_IS_S("K_max"))
{
if(! (argc > 1 && ARG1_IS_I(K_max) && K_max > 0))
{
Tcl_AppendResult(interp, "\n<K_max> expects a positive integer ",(char *) NULL);
return TCL_ERROR;
}
}
else if(ARG0_IS_S("time_calc_steps"))
{
if(! (argc > 1 && ARG1_IS_I(time_calc_steps) && time_calc_steps > 0))
{
Tcl_AppendResult(interp, "\n<time_calc_steps> expects a positive integer ",(char *) NULL);
return TCL_ERROR;
}
}
else break;
argc -= 2;
argv += 2;
}
//Turn on ewaldgpu
ewaldgpuForce->set_params_tune(accuracy, precision, K_max, time_calc_steps);
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;
rebuild_verletlist = 1;
mpi_bcast_coulomb_params();
//Tuning
char *log = NULL;
if (ewaldgpuForce->adaptive_tune(&log,espressoSystemInterface) == ES_ERROR)
{
Tcl_AppendResult(interp, "\nAccuracy could not been reached. Choose higher K_max or lower accuracy", (char *) NULL);
return TCL_ERROR;
}
//Tell the user about the tuning outcome
Tcl_AppendResult(interp, log, (char *) NULL);
if (log) free(log);
return TCL_OK;
}
int tclcommand_inter_coulomb_parse_p3m_tune(Tcl_Interp * interp, int argc, char ** argv, int adaptive)
{
int cao = -1, n_interpol = -1;
double r_cut = -1, accuracy = -1;
int mesh[3];
IntList il;
init_intlist(&il);
mesh[0] = -1;
mesh[1] = -1;
mesh[2] = -1;
while(argc > 0) {
if(ARG0_IS_S("r_cut")) {
if (! (argc > 1 && ARG1_IS_D(r_cut) && r_cut >= -1)) {
Tcl_AppendResult(interp, "r_cut expects a positive double",
(char *) NULL);
return TCL_ERROR;
}
} else if(ARG0_IS_S("mesh")) {
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 if(! (argc > 1 && mesh[0] >= -1)) {
Tcl_AppendResult(interp, "mesh expects an integer >= -1",
(char *) NULL);
return TCL_ERROR;
}
} else if(ARG0_IS_S("cao")) {
if(! (argc > 1 && ARG1_IS_I(cao) && cao >= -1 && cao <= 7)) {
Tcl_AppendResult(interp, "cao expects an integer between -1 and 7",
(char *) NULL);
return TCL_ERROR;
}
} else if(ARG0_IS_S("accuracy")) {
if(! (argc > 1 && ARG1_IS_D(accuracy) && accuracy > 0)) {
Tcl_AppendResult(interp, "accuracy expects a positive double",
(char *) NULL);
return TCL_ERROR;
}
} else if (ARG0_IS_S("n_interpol")) {
if (! (argc > 1 && ARG1_IS_I(n_interpol) && n_interpol >= 0)) {
Tcl_AppendResult(interp, "n_interpol expects an nonnegative integer", (char *) NULL);
return TCL_ERROR;
}
}
/* unknown parameter. Probably one of the optionals */
else break;
argc -= 2;
argv += 2;
}
if ( (mesh[0]%2 != 0 && mesh[0] != -1) || (mesh[1]%2 != 0 && mesh[1] != -1) || (mesh[2]%2 != 0 && mesh[2] != -1) ) {
printf ("y cond me %d %d %d\n", mesh[1], mesh[1]%2 != 0, mesh[1] != -1);
// if ( ( mesh[0]%2 != 0) && (mesh[0] != -1) ) {
Tcl_AppendResult(interp, "P3M requires an even number of mesh points in all directions", (char *) NULL);
return TCL_ERROR;
}
p3m_set_tune_params(r_cut, mesh, cao, -1.0, accuracy, n_interpol);
/* check for optional parameters */
if (argc > 0) {
if (tclcommand_inter_coulomb_parse_p3m_opt_params(interp, argc, argv) == TCL_ERROR)
return TCL_ERROR;
}
/* do the tuning */
char *log = NULL;
if (p3m_adaptive_tune(&log) == ES_ERROR) {
Tcl_AppendResult(interp, log, "\nfailed to tune P3M parameters to required accuracy", (char *) NULL);
if (log)
free(log);
return TCL_ERROR;
}
/* Tell the user about the tuning outcome */
Tcl_AppendResult(interp, log, (char *) NULL);
if (log)
free(log);
return TCL_OK;
}
int tclcommand_inter_coulomb_parse_p3m_opt_params(Tcl_Interp * interp, int argc, char ** argv)
{
int i; double d1, d2, d3;
Tcl_ResetResult(interp);
while (argc > 0) {
/* p3m parameter: inter */
if (ARG0_IS_S("n_interpol")) {
if(argc < 2) {
Tcl_AppendResult(interp, argv[0], " needs 1 parameter",
(char *) NULL);
return TCL_ERROR;
}
if (! ARG1_IS_I(i)) {
Tcl_AppendResult(interp, argv[0], " needs 1 INTEGER parameter",
(char *) NULL);
return TCL_ERROR;
}
if (p3m_set_ninterpol(i) == TCL_ERROR) {
Tcl_AppendResult(interp, argv[0], " argument must be positive",
(char *) NULL);
return TCL_ERROR;
}
argc -= 2;
argv += 2;
}
/* p3m parameter: mesh_off */
else if (ARG0_IS_S("mesh_off")) {
if(argc < 4) {
Tcl_AppendResult(interp, argv[0], " needs 3 parameters",
(char *) NULL);
return TCL_ERROR;
}
if ((! ARG_IS_D(1, d1)) ||
(! ARG_IS_D(2, d2)) ||
(! ARG_IS_D(3, d3)))
{
Tcl_AppendResult(interp, argv[0], " needs 3 DOUBLE parameters",
(char *) NULL);
return TCL_ERROR;
}
if (p3m_set_mesh_offset(d1, d2 ,d3) == TCL_ERROR)
{
Tcl_AppendResult(interp, argv[0], " parameters have to be between 0.0 an 1.0",
(char *) NULL);
return TCL_ERROR;
}
argc -= 4;
argv += 4;
}
/* p3m parameter: epsilon */
else if(ARG0_IS_S( "epsilon")) {
if(argc < 2) {
Tcl_AppendResult(interp, argv[0], " needs 1 parameter",
(char *) NULL);
return TCL_ERROR;
}
if (ARG1_IS_S("metallic")) {
d1 = P3M_EPSILON_METALLIC;
}
else if (! ARG1_IS_D(d1)) {
Tcl_AppendResult(interp, argv[0], " needs 1 DOUBLE parameter or \"metallic\"",
(char *) NULL);
return TCL_ERROR;
}
if (p3m_set_eps(d1) == TCL_ERROR) {
Tcl_AppendResult(interp, argv[0], " There is no error msg yet!",
(char *) NULL);
return TCL_ERROR;
}
argc -= 2;
argv += 2;
}
else {
Tcl_AppendResult(interp, "Unknown coulomb p3m parameter: \"",argv[0],"\"",(char *) NULL);
return TCL_ERROR;
}
}
return TCL_OK;
}
int tclcommand_parse_profile(Tcl_Interp* interp, int argc, char** argv, int* change, int* dim_A, profile_data** pdata_) {
int temp;
*change=0;
profile_data* pdata=(profile_data*)malloc(sizeof(profile_data));
*pdata_ = pdata;
pdata->id_list=0;
pdata->minx=0;
pdata->maxx=box_l[0];
pdata->xbins=1;
pdata->miny=0;
pdata->maxy=box_l[1];
pdata->ybins=1;
pdata->minz=0;
pdata->maxz=box_l[2];
pdata->zbins=1;
while (argc>0) {
if (ARG0_IS_S("ids") || ARG0_IS_S("types") || ARG0_IS_S("all")) {
if (!parse_id_list(interp, argc, argv, &temp, &pdata->id_list )==TCL_OK) {
Tcl_AppendResult(interp, "Error reading profile: Error parsing particle id information\n" , (char *)NULL);
return TCL_ERROR;
} else {
*change+=temp;
argc-=temp;
argv+=temp;
}
} else if ( ARG0_IS_S("minx")){
if (argc>1 && ARG1_IS_D(pdata->minx)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in profile: could not read minz\n" , (char *)NULL);
return TCL_ERROR;
}
} else if ( ARG0_IS_S("maxx") ) {
if (argc>1 && ARG1_IS_D(pdata->maxx)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in profile: could not read maxz\n" , (char *)NULL);
return TCL_ERROR;
}
} else if (ARG0_IS_S("xbins")) {
if (argc>1 && ARG1_IS_I(pdata->xbins)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in profile: could not read nbins\n" , (char *)NULL);
return TCL_ERROR;
}
} else if ( ARG0_IS_S("miny")){
if (argc>1 && ARG1_IS_D(pdata->miny)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in profile: could not read minz\n" , (char *)NULL);
return TCL_ERROR;
}
} else if ( ARG0_IS_S("maxy") ) {
if (argc>1 && ARG1_IS_D(pdata->maxy)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in profile: could not read maxz\n" , (char *)NULL);
return TCL_ERROR;
}
} else if (ARG0_IS_S("ybins")) {
if (argc>1 && ARG1_IS_I(pdata->ybins)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in profile: could not read nbins\n" , (char *)NULL);
return TCL_ERROR;
}
} else if ( ARG0_IS_S("minz")){
if (argc>1 && ARG1_IS_D(pdata->minz)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in profile: could not read minz\n" , (char *)NULL);
return TCL_ERROR;
}
} else if ( ARG0_IS_S("maxz") ) {
if (argc>1 && ARG1_IS_D(pdata->maxz)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in profile: could not read maxz\n" , (char *)NULL);
return TCL_ERROR;
}
} else if (ARG0_IS_S("zbins")) {
if (argc>1 && ARG1_IS_I(pdata->zbins)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in profile: could not read nbins\n" , (char *)NULL);
return TCL_ERROR;
}
} else {
Tcl_AppendResult(interp, "Error in radial_profile: understand argument ", argv[0], "\n" , (char *)NULL);
return TCL_ERROR;
}
}
temp=0;
if (pdata->xbins <= 0 || pdata->ybins <=0 || pdata->zbins <= 0) {
Tcl_AppendResult(interp, "Error in profile: the bin number in each direction must be >=1\n" , (char *)NULL);
temp=1;
}
if (temp)
return TCL_ERROR;
else
return TCL_OK;
}
int tclcommand_parse_radial_profile(Tcl_Interp* interp, int argc, char** argv, int* change, int* dim_A, radial_profile_data** pdata_) {
int temp;
*change=0;
radial_profile_data* pdata=(radial_profile_data*)malloc(sizeof(radial_profile_data));
*pdata_ = pdata;
pdata->id_list=0;
if (box_l[0]<box_l[1])
pdata->maxr = box_l[0];
else
pdata->maxr = box_l[1];
pdata->minr=0;
pdata->maxphi=PI;
pdata->minphi=-PI;
pdata->minz=-box_l[2]/2.;
pdata->maxz=+box_l[2]/2.;
pdata->center[0]=box_l[0]/2.;pdata->center[1]=box_l[1]/2.;pdata->center[2]=box_l[2]/2.;
pdata->rbins=1;
pdata->zbins=1;
pdata->phibins=1;
pdata->axis[0]=0.;
pdata->axis[1]=0.;
pdata->axis[2]=1.;
if (argc < 1) {
Tcl_AppendResult(interp, "Usage radial_profile id $ids center $x $y $z maxr $r_max nbins $n\n" , (char *)NULL);
return TCL_ERROR;
}
while (argc>0) {
if (ARG0_IS_S("ids") || ARG0_IS_S("types") || ARG0_IS_S("all")) {
if (!parse_id_list(interp, argc, argv, &temp, &pdata->id_list )==TCL_OK) {
Tcl_AppendResult(interp, "Error reading profile: Error parsing particle id information\n" , (char *)NULL);
return TCL_ERROR;
} else {
*change+=temp;
argc-=temp;
argv+=temp;
}
} else if ( ARG0_IS_S("center")){
if (argc>3 && ARG1_IS_D(pdata->center[0]) && ARG_IS_D(2,pdata->center[1]) && ARG_IS_D(3,pdata->center[2])) {
argc-=4;
argv+=4;
*change+=4;
} else {
Tcl_AppendResult(interp, "Error in radial_profile: could not read center\n" , (char *)NULL);
return TCL_ERROR;
}
} else if ( ARG0_IS_S("axis")){
Tcl_AppendResult(interp, "Using arbitrary axes does not work yet!\n" , (char *)NULL);
return TCL_ERROR;
if (argc>3 && ARG1_IS_D(pdata->axis[0]) && ARG_IS_D(2,pdata->axis[1]) && ARG_IS_D(3,pdata->axis[2])) {
argc-=4;
argv+=4;
*change+=4;
} else {
Tcl_AppendResult(interp, "Error in radial_profile: could not read center\n" , (char *)NULL);
return TCL_ERROR;
}
} else if ( ARG0_IS_S("maxr") ) {
if (argc>1 && ARG1_IS_D(pdata->maxr)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in radial_profile: could not read maxr\n" , (char *)NULL);
return TCL_ERROR;
}
} else if ( ARG0_IS_S("minr") ) {
if (argc>1 && ARG1_IS_D(pdata->maxr)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in radial_profile: could not read maxr\n" , (char *)NULL);
return TCL_ERROR;
}
} else if ( ARG0_IS_S("minz")){
if (argc>1 && ARG1_IS_D(pdata->minz)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in profile: could not read minz\n" , (char *)NULL);
return TCL_ERROR;
}
} else if ( ARG0_IS_S("maxz") ) {
if (argc>1 && ARG1_IS_D(pdata->maxz)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in profile: could not read maxz\n" , (char *)NULL);
return TCL_ERROR;
}
} else if ( ARG0_IS_S("minphi")){
if (argc>1 && ARG1_IS_D(pdata->minphi)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in profile: could not read minz\n" , (char *)NULL);
return TCL_ERROR;
}
} else if ( ARG0_IS_S("maxphi") ) {
if (argc>1 && ARG1_IS_D(pdata->maxphi)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in profile: could not read maxz\n" , (char *)NULL);
return TCL_ERROR;
}
} else if (ARG0_IS_S("rbins")) {
if (argc>1 && ARG1_IS_I(pdata->rbins)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in radial_profile: could not read rbins\n" , (char *)NULL);
return TCL_ERROR;
}
} else if (ARG0_IS_S("zbins")) {
if (argc>1 && ARG1_IS_I(pdata->zbins)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in radial_profile: could not read rbins\n" , (char *)NULL);
return TCL_ERROR;
}
} else if (ARG0_IS_S("phibins")) {
if (argc>1 && ARG1_IS_I(pdata->phibins)) {
argc-=2;
argv+=2;
*change+=2;
} else {
Tcl_AppendResult(interp, "Error in radial_profile: could not read rbins\n" , (char *)NULL);
return TCL_ERROR;
}
} else {
Tcl_AppendResult(interp, "Error in radial_profile: understand argument ", argv[0], "\n" , (char *)NULL);
return TCL_ERROR;
}
}
temp=0;
// if (pdata->center[0]>1e90) {
// Tcl_AppendResult(interp, "Error in radial_profile: center not specified\n" , (char *)NULL);
// temp=1;
// }
// if (pdata->maxr>1e90) {
// Tcl_AppendResult(interp, "Error in radial_profile: maxr not specified\n" , (char *)NULL);
// temp=1;
// }
// if (pdata->rbins<1) {
// Tcl_AppendResult(interp, "Error in radial_profile: rbins not specified\n" , (char *)NULL);
// temp=1;
// }
if (temp)
return TCL_ERROR;
else
return TCL_OK;
}
int tclcommand_lbfluid(ClientData data, Tcl_Interp *interp, int argc, char **argv) {
#if defined (LB) || defined (LB_GPU)
argc--; argv++;
/**if we have LB the LB cpu is set by default */
#ifdef LB
if(!(lattice_switch & LATTICE_LB_GPU)) lattice_switch = lattice_switch | LATTICE_LB;
#else
lattice_switch = lattice_switch | LATTICE_LB_GPU;
#endif
int err = TCL_OK;
double floatarg;
#ifdef EXTERNAL_FORCES
double vectarg[3];
#endif
if (argc < 1) {
lbfluid_tcl_print_usage(interp);
return TCL_ERROR;
}
else if (ARG0_IS_S("off")) {
lbfluid_tcl_print_usage(interp);
return TCL_ERROR;
}
else if (ARG0_IS_S("init")) {
lbfluid_tcl_print_usage(interp);
return TCL_ERROR;
}
else
while (argc > 0) {
if (ARG0_IS_S("gpu") || ARG0_IS_S("GPU")) {
#ifdef LB_GPU
lattice_switch = (lattice_switch &~ LATTICE_LB) | LATTICE_LB_GPU;
argc--; argv++;
#else
Tcl_AppendResult(interp, "LB_GPU is not compiled in!", NULL);
return TCL_ERROR;
#endif
}
else if (ARG0_IS_S("cpu") || ARG0_IS_S("CPU")) {
#ifdef LB
lattice_switch = (lattice_switch & ~LATTICE_LB_GPU) | LATTICE_LB;
argc--; argv++;
#else
Tcl_AppendResult(interp, "LB is not compiled in!", NULL);
return TCL_ERROR;
#endif
}
else if (ARG0_IS_S("density") || ARG0_IS_S("dens")) {
if ( argc < 2 || !ARG1_IS_D(floatarg) ) {
Tcl_AppendResult(interp, "dens requires 1 argument", (char *)NULL);
return TCL_ERROR;
} else if (floatarg <= 0) {
Tcl_AppendResult(interp, "dens must be positive", (char *)NULL);
return TCL_ERROR;
} else {
if ( lb_lbfluid_set_density(floatarg) == 0 ) {
argc-=2; argv+=2;
} else {
Tcl_AppendResult(interp, "Unknown Error setting dens", (char *)NULL);
return TCL_ERROR;
}
}
}
else if (ARG0_IS_S("grid") || ARG0_IS_S("agrid")) {
if ( argc < 2 || !ARG1_IS_D(floatarg) ) {
Tcl_AppendResult(interp, "agrid requires 1 argument", (char *)NULL);
return TCL_ERROR;
} else if (floatarg <= 0) {
Tcl_AppendResult(interp, "agrid must be positive", (char *)NULL);
return TCL_ERROR;
} else if (0) {
// agrid is not compatible with box_l;
// Not necessary because this is caught on the mpi level!
} else {
if ( lb_lbfluid_set_agrid(floatarg) == 0 ) {
argc-=2; argv+=2;
} else {
Tcl_AppendResult(interp, "Unknown Error setting agrid", (char *)NULL);
return TCL_ERROR;
}
}
}
else if (ARG0_IS_S("tau")) {
if ( argc < 2 || !ARG1_IS_D(floatarg) ) {
Tcl_AppendResult(interp, "tau requires 1 argument", (char *)NULL);
return TCL_ERROR;
} else if (floatarg <= 0) {
Tcl_AppendResult(interp, "tau must be positive", (char *)NULL);
return TCL_ERROR;
} else if (floatarg < time_step ) {
Tcl_AppendResult(interp, "tau must larger than the MD time step", (char *)NULL);
return TCL_ERROR;
} else {
if ( lb_lbfluid_set_tau(floatarg) == 0 ) {
argc-=2; argv+=2;
} else {
Tcl_AppendResult(interp, "Unknown Error setting tau", (char *)NULL);
return TCL_ERROR;
}
}
}
else if (ARG0_IS_S("viscosity") || ARG0_IS_S("visc")) {
if ( argc < 2 || !ARG1_IS_D(floatarg) ) {
Tcl_AppendResult(interp, "visc requires 1 argument", (char *)NULL);
return TCL_ERROR;
} else if (floatarg <= 0) {
Tcl_AppendResult(interp, "visc must be positive", (char *)NULL);
return TCL_ERROR;
} else {
if ( lb_lbfluid_set_visc(floatarg) == 0 ) {
argc-=2; argv+=2;
} else {
Tcl_AppendResult(interp, "Unknown Error setting viscosity", (char *)NULL);
return TCL_ERROR;
}
}
}
else if (ARG0_IS_S("bulk_viscosity")) {
if ( argc < 2 || !ARG1_IS_D(floatarg) ) {
Tcl_AppendResult(interp, "bulk_visc requires 1 argument", (char *)NULL);
return TCL_ERROR;
} else if (floatarg <= 0) {
Tcl_AppendResult(interp, "bulk_visc must be positive", (char *)NULL);
return TCL_ERROR;
} else {
if ( lb_lbfluid_set_bulk_visc(floatarg) == 0 ) {
argc-=2; argv+=2;
} else {
Tcl_AppendResult(interp, "Unknown Error setting bulk_viscosity", (char *)NULL);
return TCL_ERROR;
}
}
}
else if (ARG0_IS_S("friction") || ARG0_IS_S("coupling")) {
if ( argc < 2 || !ARG1_IS_D(floatarg) ) {
Tcl_AppendResult(interp, "friction requires 1 argument", (char *)NULL);
return TCL_ERROR;
} else if (floatarg <= 0) {
Tcl_AppendResult(interp, "friction must be positive", (char *)NULL);
return TCL_ERROR;
} else {
if ( lb_lbfluid_set_friction(floatarg) == 0 ) {
argc-=2; argv+=2;
} else {
Tcl_AppendResult(interp, "Unknown Error setting friction", (char *)NULL);
return TCL_ERROR;
}
}
}
else if (ARG0_IS_S("ext_force")) {
#ifdef EXTERNAL_FORCES
if ( argc < 4 || !ARG_IS_D(1, vectarg[0]) || !ARG_IS_D(2, vectarg[1]) || !ARG_IS_D(3, vectarg[2]) ) {
Tcl_AppendResult(interp, "friction requires 1 argument", (char *)NULL);
return TCL_ERROR;
} else if (lb_lbfluid_set_ext_force(vectarg[0], vectarg[1], vectarg[2]) == 0) {
argc-=4; argv+=4;
} else {
Tcl_AppendResult(interp, "Unknown Error setting ext_force", (char *)NULL);
return TCL_ERROR;
}
#else
Tcl_AppendResult(interp, "External Forces not compiled in!", (char *)NULL);
return TCL_ERROR;
#endif
}
else if (ARG0_IS_S("gamma_odd")) {
if ( argc < 2 || !ARG1_IS_D(floatarg) ) {
Tcl_AppendResult(interp, "gamma_odd requires 1 argument", (char *)NULL);
return TCL_ERROR;
} else if (fabs(floatarg) >= 1) {
Tcl_AppendResult(interp, "gamma_odd must < 1", (char *)NULL);
return TCL_ERROR;
} else {
if ( lb_lbfluid_set_gamma_odd(floatarg) == 0 ) {
argc-=2; argv+=2;
} else {
Tcl_AppendResult(interp, "Unknown Error setting gamma_odd", (char *)NULL);
return TCL_ERROR;
}
}
}
else if (ARG0_IS_S("gamma_even")) {
if ( argc < 2 || !ARG1_IS_D(floatarg) ) {
Tcl_AppendResult(interp, "gamma_even requires 1 argument", (char *)NULL);
return TCL_ERROR;
} else if (fabs(floatarg) >= 1) {
Tcl_AppendResult(interp, "gamma_even must < 1", (char *)NULL);
return TCL_ERROR;
} else {
if ( lb_lbfluid_set_gamma_even(floatarg) == 0 ) {
argc-=2; argv+=2;
} else {
Tcl_AppendResult(interp, "Unknown Error setting gamma_even", (char *)NULL);
return TCL_ERROR;
}
}
}
else if (ARG0_IS_S("print")) {
if ( argc < 3 || (ARG1_IS_S("vtk") && argc < 4) ) {
Tcl_AppendResult(interp, "lbfluid print requires at least 2 arguments. Usage: lbfluid print [vtk] velocity|boundary filename", (char *)NULL);
return TCL_ERROR;
}
else {
argc--; argv++;
if (ARG0_IS_S("vtk")) {
if (ARG1_IS_S("boundary")) {
if ( lb_lbfluid_print_vtk_boundary(argv[2]) != 0 ) {
Tcl_AppendResult(interp, "Unknown Error at lbfluid print vtk boundary", (char *)NULL);
return TCL_ERROR;
}
}
else if (ARG1_IS_S("velocity")) {
if ( lb_lbfluid_print_vtk_velocity(argv[2]) != 0 ) {
Tcl_AppendResult(interp, "Unknown Error at lbfluid print vtk velocity", (char *)NULL);
return TCL_ERROR;
}
}
else {
return TCL_ERROR;
}
argc-=3; argv+=3;
}
else {
if (ARG0_IS_S("boundary")) {
if ( lb_lbfluid_print_boundary(argv[1]) != 0 ) {
Tcl_AppendResult(interp, "Unknown Error at lbfluid print boundary", (char *)NULL);
return TCL_ERROR;
}
}
else if (ARG0_IS_S("velocity")) {
if ( lb_lbfluid_print_velocity(argv[1]) != 0 ) {
Tcl_AppendResult(interp, "Unknown Error at lbfluid print velocity", (char *)NULL);
return TCL_ERROR;
}
}
else {
return TCL_ERROR;
}
argc-=2; argv+=2;
}
}
}
else if (ARG0_IS_S("save_ascii_checkpoint")) {
if (argc < 2) {
Tcl_AppendResult(interp, "usage: lbfluid save_ascii_checkpoint <filename>", (char *)NULL);
return TCL_ERROR;
} else {
return lb_lbfluid_save_checkpoint(argv[1], 0);
}
}
else if (ARG0_IS_S("save_binary_checkpoint")) {
if (argc < 2) {
Tcl_AppendResult(interp, "usage: lbfluid save_binary_checkpoint <filename>", (char *)NULL);
return TCL_ERROR;
} else {
return lb_lbfluid_save_checkpoint(argv[1], 1);
}
}
else if (ARG0_IS_S("load_ascii_checkpoint")) {
if (argc < 2) {
Tcl_AppendResult(interp, "usage: lbfluid load_ascii_checkpoint <filename>", (char *)NULL);
return TCL_ERROR;
} else {
return lb_lbfluid_load_checkpoint(argv[1], 0);
}
}
else if (ARG0_IS_S("load_binary_checkpoint")) {
if (argc < 2) {
Tcl_AppendResult(interp, "usage: lbfluid load_binary_checkpoint <filename>", (char *)NULL);
return TCL_ERROR;
} else {
return lb_lbfluid_load_checkpoint(argv[1], 1);
}
}
#ifdef LB
else if (ARG0_IS_S("print_interpolated_velocity")) { //this has to come after print
return tclcommand_lbfluid_print_interpolated_velocity(interp, argc-1, argv+1);
}
#endif
else {
Tcl_AppendResult(interp, "unknown feature \"", argv[0],"\" of lbfluid", (char *)NULL);
return TCL_ERROR ;
}
if ((err = gather_runtime_errors(interp, err)) != TCL_OK)
return TCL_ERROR;
}
mpi_bcast_parameter(FIELD_LATTICE_SWITCH);
/* thermo_switch is retained for backwards compatibility */
thermo_switch = (thermo_switch | THERMO_LB);
mpi_bcast_parameter(FIELD_THERMO_SWITCH);
return TCL_OK;
#else /* !defined LB */
Tcl_AppendResult(interp, "LB is not compiled in!", NULL);
return TCL_ERROR;
#endif
}
