自学教程：C++ ARG_IS_D函数代码示例

int tclcommand_inter_parse_harmonic_dumbbell(Tcl_Interp *interp, int bond_type, int argc, char **argv){  double k1, k2, r, r_cut;  if (argc < 4) {    Tcl_AppendResult(interp, "harmonic dumbbell needs at least 3 parameters: "		     "<k1> <k2> <r> [<r_cut>]", (char *) NULL);    return TCL_ERROR;  }  if ((! ARG_IS_D(1, k1)) || (! ARG_IS_D(2, k2)) || (! ARG_IS_D(3, r))) {    Tcl_AppendResult(interp, "harmonic dumbbell needs at least 3 DOUBLE parameters: "		     "<k1> <k2> <r> [<r_cut>]", (char *) NULL);    return TCL_ERROR;  }  if (argc < 5) {    r_cut = -1.0;  } else if (! ARG_IS_D(4, r_cut))  {    Tcl_AppendResult(interp, "<r_cut> should be DOUBLE", (char *) NULL);    return TCL_ERROR;  }  CHECK_VALUE(harmonic_dumbbell_set_params(bond_type, k1, k2, r, r_cut), "bond type must be nonnegative");}

int tclcommand_inter_parse_cos2(Tcl_Interp * interp,		       int part_type_a, int part_type_b,		       int argc, char ** argv){  /* parameters needed for cos2 */  double eps, offset, w;  int change;  /* get cos2 interaction type */  if (argc < 4) {    Tcl_AppendResult(interp, "cos2 needs 3 parameters: "		     "<cos2_eps> <cos2_offset> <cos2_w>",		     (char *) NULL);    return 0;  }  /* copy cos2 parameters */  if ((! ARG_IS_D(1, eps))    ||      (! ARG_IS_D(2, offset)) ||      (! ARG_IS_D(3, w))) {    Tcl_AppendResult(interp, "cos2 needs 3 DOUBLE parameters: "		     "<cos2_eps> <cos2_offset> <cos2_w>",		     (char *) NULL);    return 0;  }  change = 4;  if (cos2_set_params(part_type_a, part_type_b,			       eps, offset, w			       ) == ES_ERROR) {    Tcl_AppendResult(interp, "particle types must be non-negative", (char *) NULL);    return 0;  }  return change;}

int tclcommand_inter_parse_hat(Tcl_Interp * interp,				int part_type_a, int part_type_b,				int argc, char ** argv){  /* parameters needed for hat */  double Fmax, r;  int change;  /* get hat interaction type */  if (argc < 3) {    Tcl_AppendResult(interp, "hat potential needs 2 parameters: "		     "<hat_Fmax> <hat_r>",		     (char *) NULL);    return 0;  }  /* copy soft-sphere parameters */  if ((! ARG_IS_D(1, Fmax))     ||      (! ARG_IS_D(2, r))  ) {    Tcl_AppendResult(interp, "hat potential needs 2 parameters: "		     "<hat_Fmax> <hat_r>",		     (char *) NULL);    return 0;  }  change = 3;	    Tcl_ResetResult(interp);  if (hat_set_params(part_type_a, part_type_b, Fmax, r) == ES_ERROR) {    Tcl_AppendResult(interp, "particle types must be non-negative", (char *) NULL);    return 0;  }  return change;}

int tclcommand_inter_parse_gaussian(Tcl_Interp * interp,                                    int part_type_a, int part_type_b,                                    int argc, char ** argv){    /* parameters needed for Gaussian */    double eps, sig, cut;    /* copy parameters */    if ((argc < 4) ||            (! ARG_IS_D(1, eps)) ||            (! ARG_IS_D(2, sig)) ||            (! ARG_IS_D(3, cut))) {        Tcl_AppendResult(interp, "Gaussian potential needs 3 parameters: "                         "<epsilon> <sigma> <cut>", (char *) NULL);        return 0;    }    Tcl_ResetResult(interp);    if (gaussian_set_params(part_type_a, part_type_b,                            eps, sig, cut) == ES_ERROR) {        Tcl_AppendResult(interp, "particle types must be non-negative", (char *) NULL);        return 0;    }    /* return number of used parameters */    return 4;}

int tclcommand_thermostat_parse_npt_isotropic(Tcl_Interp *interp, int argc, char **argv) {  double temp, gamma0, gammav;  /* check number of arguments */  if (argc < 5) {    Tcl_AppendResult(interp, "wrong # args:  should be /n/"",		     argv[0]," set ",argv[1]," <temp> <gamma0> <gammav>/"", (char *)NULL);    return (TCL_ERROR);  }  /* check argument types */  if ( !ARG_IS_D(2, temp) || !ARG_IS_D(3, gamma0) || !ARG_IS_D(4, gammav) ) {    Tcl_AppendResult(interp, argv[0]," ",argv[1]," needs four DOUBLES", (char *)NULL);    return (TCL_ERROR);  }  /* broadcast parameters */  temperature = temp;  nptiso_gamma0 = gamma0;  nptiso_gammav = gammav;  thermo_switch = ( thermo_switch | THERMO_NPT_ISO );  mpi_bcast_parameter(FIELD_THERMO_SWITCH);  mpi_bcast_parameter(FIELD_TEMPERATURE);  mpi_bcast_parameter(FIELD_NPTISO_G0);  mpi_bcast_parameter(FIELD_NPTISO_GV);  return (TCL_OK);}

/// parse parameters for the angle potentialint tclcommand_inter_parse_angle(Tcl_Interp *interp, int bond_type, int argc, char **argv){  double bend, phi0;  /* the optional parameter phi0 is due to backwards compatibility and is set to PI if not given */  if (argc != 2 && argc != 3) {    Tcl_AppendResult(interp, "angle needs 1 or 2 parameters: "		     "<bend> [<phi0>]", (char *) NULL);    return (TCL_ERROR);  }  if (! ARG_IS_D(1, bend)) {    Tcl_AppendResult(interp, "angle needs a DOUBLE parameter: "		     "<bend> ", (char *) NULL);    return TCL_ERROR;  }  /* special treatment of the optional parameter phi0 */  if (argc == 3) {    if (! ARG_IS_D(2, phi0)) {      Tcl_AppendResult(interp, "angle needs a DOUBLE parameter: "		       "<phi0> ", (char *) NULL);      return TCL_ERROR;    }  } else {    phi0 = PI;  }  CHECK_VALUE(angle_set_params(bond_type, bend, phi0), "bond type must be nonnegative");}

static int lbnode_parse_set(Tcl_Interp *interp, int argc, char **argv, int *ind) {  double f[3];    while (argc > 0) {    if(ARG0_IS_S("force")){      if (argc < 4 || 	  !ARG_IS_D(1, f[0]) || 	  !ARG_IS_D(2, f[1]) || 	  !ARG_IS_D(3, f[2])	  ) {	Tcl_AppendResult(interp, "force expects three doubles as argument", (char *)NULL);	return TCL_ERROR;      }      argc -= 4;      argv += 4;      if (argc > 0) {	Tcl_ResetResult(interp);	Tcl_AppendResult(interp, "Error in lbnode_extforce force. You can only change one field at the same time.", (char *)NULL);	return ES_ERROR;      }    }    else {      Tcl_AppendResult(interp, "unknown parameter /"", argv[0], "/" to set", (char *)NULL);      return TCL_ERROR;    }  }  if (lb_lbnode_set_extforce_GPU(ind, f) == ES_ERROR) {    Tcl_AppendResult(interp, "position is not in the LB lattice", (char *)NULL);    return TCL_ERROR;  }  return ES_OK;}

/* ############### */int tclcommand_rotate_system(ClientData data, Tcl_Interp * interp, int argc, char ** argv) {    double alpha,theta,phi;    if (argc != 4) {        fprintf(stderr,"needs 3 angles/n");        return ES_ERROR;    }    if (! (ARG_IS_D(1,phi)))    {        fprintf(stderr,"Expects 3 floats/n");        return ES_ERROR;    }    if (!(ARG_IS_D(2,theta)))    {        fprintf(stderr,"Expects 3 floats/n");        return ES_ERROR;    }    if (! (ARG_IS_D(3,alpha)))    {        fprintf(stderr,"Expects 3 floats/n");        return ES_ERROR;    }    rotate_system(phi,theta,alpha);    return ES_OK;}

int tclcommand_minimize_energy(ClientData data, Tcl_Interp *interp, int argc, char **argv) {  int  max_steps;  double f_max, gamma, max_displacement;    if (argc != 5) {    Tcl_AppendResult(interp, "wrong # args: /n/"", (char *) NULL);    return usage(interp);  }  else {    if(!ARG_IS_D(1,f_max)) {      return usage(interp);          }    if(!ARG_IS_I(2,max_steps)) {      return usage(interp);          }    if(!ARG_IS_D(3,gamma)) {      return usage(interp);          }    if(!ARG_IS_D(4,max_displacement)) {      return usage(interp);          }  }  minimize_energy_init(f_max, gamma, max_steps, max_displacement);  mpi_minimize_energy();  return TCL_OK;}

/** parse TCL command.    number of parameters is checked and maggs_set_parameters function is called.    @return zero if successful    @param interp  TCL interpreter handle    @param argc    number of arguments given    @param argv    array of arguments given*/int tclcommand_inter_coulomb_parse_maggs(Tcl_Interp * interp, int argc, char ** argv){    int mesh;    double f_mass;    double epsilon = 1.0;    int finite_epsilon_flag = 1;	    /* if the command is localeps, call function */    if ( (argc > 0) && (ARG_IS_S(0, "localeps")) )        return tclcommand_localeps(interp, argc, argv);        if(argc < 2) {        Tcl_AppendResult(interp, "Not enough parameters: inter coulomb <bjerrum> memd <f_mass> <mesh>", (char *) NULL);        return TCL_ERROR;    }	    if(! ARG_IS_D(0, f_mass))        return TCL_ERROR;	    if(! ARG_IS_I(1, mesh)) {        Tcl_AppendResult(interp, "integer expected", (char *) NULL);        return TCL_ERROR;    }	    if(argc > 4) {        Tcl_AppendResult(interp, "Too many parameters: inter coulomb memd <f_mass> <mesh> [epsilon <eps>]", (char *) NULL);        return TCL_ERROR;    }    if(argc == 3) {        Tcl_AppendResult(interp, "Usage: inter coulomb memd <f_mass> <mesh> [epsilon <eps>]", (char *) NULL);        return TCL_ERROR;    }    if(argc == 4) {        if (ARG_IS_S(2, "epsilon")) {            if(! (ARG_IS_D(3, epsilon) && epsilon > 0.0)) {                Tcl_AppendResult(interp, "epsilon expects a positive double",                             (char *) NULL);                return TCL_ERROR;            }        }    } else finite_epsilon_flag=1;  coulomb.method = COULOMB_MAGGS;	  int res = maggs_set_parameters(coulomb.bjerrum, f_mass, mesh,                                 finite_epsilon_flag, epsilon);  switch (res) {  case -1:    Tcl_AppendResult(interp, "mass of the field is negative", (char *)NULL);    return TCL_ERROR;  case -2:    Tcl_AppendResult(interp, "mesh must be positive", (char *) NULL);    return TCL_ERROR;  case ES_OK:    return TCL_OK;  }  Tcl_AppendResult(interp, "unknown error", (char *) NULL);  return TCL_ERROR;}

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;}

int tclcommand_thermostat_parse_inter_dpd(Tcl_Interp *interp, int argc, char ** argv){  double temp;  if (argc < 2) {    Tcl_AppendResult(interp, "thermostat needs 1 parameter: "		     "<temperature>",		     (char *) NULL);    return TCL_ERROR;  }  if (argc>2 && ARG_IS_S(2, "ignore_fixed_particles")) {    if (argc == 3)      dpd_ignore_fixed_particles=1;    else if (argc!= 4 || (!ARG_IS_I(3, dpd_ignore_fixed_particles)))       return TCL_ERROR;    mpi_bcast_parameter(FIELD_DPD_IGNORE_FIXED_PARTICLES);    return TCL_OK;  }  /* copy lattice-boltzmann parameters */  if (! ARG_IS_D(2, temp)) { return TCL_ERROR; }  if ( temp < 0.0 ) {    Tcl_AppendResult(interp, "temperature must be non-negative", (char *) NULL);    return TCL_ERROR;  }  temperature = temp;  thermo_switch = ( thermo_switch | THERMO_INTER_DPD );  mpi_bcast_parameter(FIELD_THERMO_SWITCH);  mpi_bcast_parameter(FIELD_TEMPERATURE);  return (TCL_OK);}

int tclcommand_thermostat_parse_lb(Tcl_Interp *interp, int argc, char ** argv){#if defined(LB) || defined(LB_GPU)  double temp;  /* get lb interaction type */  if (argc < 2) {    Tcl_AppendResult(interp, "lb needs 1 parameter: "		     "<temperature>",		     (char *) NULL);    return TCL_ERROR;  }  /* copy lattice-boltzmann parameters */  if (! ARG_IS_D(1, temp)) { return TCL_ERROR; }  if ( temp < 0.0 ) {    Tcl_AppendResult(interp, "temperature must be non-negative", (char *) NULL);    return TCL_ERROR;  }  temperature = temp;  thermo_switch = ( thermo_switch | THERMO_LB );  mpi_bcast_parameter(FIELD_THERMO_SWITCH);  mpi_bcast_parameter(FIELD_TEMPERATURE);  #endif  return TCL_OK;}

int tclcommand_thermostat_parse_bd(Tcl_Interp *interp, int argc, char **argv) {  double temp;  /* check number of arguments */  if (argc < 3) {    Tcl_AppendResult(interp, "wrong # args:  should be /n/"",		     argv[0]," ",argv[1]," <temp>/"", (char *)NULL);    return (TCL_ERROR);  }  /* check argument types */  if ( !ARG_IS_D(2, temp) ) {    Tcl_AppendResult(interp, argv[0]," ",argv[1]," needs a  DOUBLE", (char *)NULL);    return (TCL_ERROR);  }  if (temp < 0) {    Tcl_AppendResult(interp, "temperature must be positive", (char *)NULL);    return (TCL_ERROR);  }  /* broadcast parameters */  temperature = temp;  thermo_switch = ( thermo_switch | THERMO_BD );  mpi_bcast_parameter(FIELD_THERMO_SWITCH);  mpi_bcast_parameter(FIELD_TEMPERATURE);  return (TCL_OK);}

int tclcommand_metadynamics_parse_relative_z(Tcl_Interp *interp, int argc, char **argv){  int    pid1, pid2, dbins, numrelaxationsteps;  double dmin, dmax, bheight, bwidth, fbound;  /* check number of arguments */  if (argc < 11) {    Tcl_AppendResult(interp, "wrong # args:  should be /n/"",                     argv[0]," ",argv[1]," <pid1> <pid2> <z_min> <z_max> <b_height> <b_width> <f_bound> <z_bins> <num_relaxation_steps>/"", (char *)NULL);    return (TCL_ERROR);  }  /* check argument types */  if ( !ARG_IS_I(2, pid1) || !ARG_IS_I(3, pid2) || !ARG_IS_D(4, dmin) || !ARG_IS_D(5, dmax) ||       !ARG_IS_D(6, bheight) || !ARG_IS_D(7, bwidth) || !ARG_IS_D(8, fbound) || !ARG_IS_I(9, dbins) || !ARG_IS_I(10, numrelaxationsteps) ) {    Tcl_AppendResult(interp, argv[0]," ",argv[1]," needs two INTS, five DOUBLES, and two INTS in this order", (char *)NULL);    return (TCL_ERROR);  }  if (pid1 < 0 || pid1 > max_seen_particle || pid2 < 0 || pid2 > max_seen_particle) {    Tcl_AppendResult(interp, "pid1 and/or pid2 out of range", (char *)NULL);    return (TCL_ERROR);  }  if (dmax < dmin || bheight < 0 || bwidth < 0 || fbound < 0 || dbins < 0 || numrelaxationsteps <0) {    Tcl_AppendResult(interp, "check parameters: inconcistency somewhere", (char *)NULL);    return (TCL_ERROR);  }  free(meta_acc_force);  free(meta_acc_fprofile);  /* broadcast parameters */  meta_pid1         = pid1;  meta_pid2         = pid2;  meta_bias_height  = bheight;  meta_bias_width   = bwidth;  meta_xi_min       = dmin;  meta_xi_max       = dmax;  meta_f_bound      = fbound;  meta_xi_num_bins  = dbins;  meta_switch = META_REL_Z;  meta_num_relaxation_steps = numrelaxationsteps;  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;}

/// parse parameters for the bending_force potentialint tclcommand_inter_parse_bending_force(Tcl_Interp *interp, int bond_type, int argc, char **argv){  double phi0, kb;  if (argc != 3 ) {    Tcl_AppendResult(interp, "bending_force needs 2 parameters: "		     "<phi0> <kb>", (char *) NULL);    return (TCL_ERROR);  }  if (!ARG_IS_D(1, phi0) || !ARG_IS_D(2, kb) ) {    Tcl_AppendResult(interp, "bending_force needs 2 parameters of types DOUBLE: "		     "<phi0> <kb>", (char *) NULL);    return TCL_ERROR;  }    CHECK_VALUE(bending_force_set_params(bond_type, phi0, kb), "bond type must be nonnegative");}

int tclcommand_inter_coulomb_parse_mmm1d(Tcl_Interp *interp, int argc, char **argv){  double switch_rad, maxPWerror;  if (argc < 2) {    Tcl_AppendResult(interp, "wrong # arguments: inter coulomb mmm1d <switch radius> "		     "{<bessel cutoff>} <maximal error for near formula> | tune  <maximal pairwise error>", (char *) NULL);    return TCL_ERROR;  }  if (ARG0_IS_S("tune")) {    /* autodetermine bessel cutoff AND switching radius */    if (! ARG_IS_D(1, maxPWerror))      return TCL_ERROR;    switch_rad = -1;  }  else {    if (argc == 2) {      /* autodetermine bessel cutoff */      if ((! ARG_IS_D(0, switch_rad)) ||	  (! ARG_IS_D(1, maxPWerror))) 	return TCL_ERROR;    }    else {      Tcl_AppendResult(interp, "wrong # arguments: inter coulomb mmm1d <switch radius> "		       "<maximal error for near formula> | tune  <maximal pairwise error>", (char *) NULL);      return TCL_ERROR;    }        if (switch_rad <= 0 || switch_rad > box_l[2]) {      Tcl_AppendResult(interp, "switching radius is not between 0 and box_l[2]", (char *)NULL);      return TCL_ERROR;    }  }  MMM1D_set_params(switch_rad, maxPWerror);  char *log = NULL;  int result = mmm1d_tune(&log) == ES_OK ? TCL_OK : TCL_ERROR;  Tcl_AppendResult(interp, log, NULL);  if (log)    free(log);  return gather_runtime_errors(interp, result);}

int tclcommand_inter_parse_inter_dpd(Tcl_Interp * interp,		       int part_type_a, int part_type_b,		       int argc, char ** argv){  /* parameters needed for LJ */  extern double temperature;  double gamma,r_c,tgamma,tr_c;  int wf,twf;  int change;  /* get inter_dpd interaction type */  if (argc < 7) {    Tcl_AppendResult(interp, "inter_dpd needs 6 parameters: "		     "<gamma> <r_cut> <wf> <tgamma> <tr_cut> <twf>",		     (char *) NULL);    return 0;  }  if (temperature == -1) {    Tcl_AppendResult(interp, "Please set temperature first:  temperature inter_dpd temp",(char *) NULL);    return 0;  }  /* copy lennard-jones parameters */  if ((! ARG_IS_D(1, gamma))  ||      (! ARG_IS_D(2, r_c))    ||      (! ARG_IS_I(3, wf))     ||      (! ARG_IS_D(4, tgamma)) ||      (! ARG_IS_D(5, tr_c))    ||      (! ARG_IS_I(6, twf))    ) {    Tcl_AppendResult(interp, "inter_dpd needs 6 parameters: "		     "<gamma> <r_cut> <wf> <tgamma> <tr_cut> <twf> ",		     (char *) NULL);    return 0;  }  change = 7;	  if (inter_dpd_set_params(part_type_a, part_type_b,			       gamma,r_c,wf,tgamma,tr_c,twf) == ES_ERROR) {    Tcl_AppendResult(interp, "particle types must be non-negative", (char *) NULL);    return 0;  }  inter_dpd_init();  return change;}

/// parse parameters for the dihedral potentialint tclcommand_inter_parse_dihedral(Tcl_Interp *interp, int bond_type, int argc, char **argv){  int mult;  double bend, phase;  if (argc < 4 ) {    Tcl_AppendResult(interp, "dihedral needs 3 parameters: "		     "<mult> <bend> <phase>", (char *) NULL);    return (TCL_ERROR);  }  if ( !ARG_IS_I(1, mult) || !ARG_IS_D(2, bend) || !ARG_IS_D(3, phase) ) {    Tcl_AppendResult(interp, "dihedral needs 3 parameters of types INT DOUBLE DOUBLE: "		     "<mult> <bend> <phase> ", (char *) NULL);    return TCL_ERROR;  }    CHECK_VALUE(dihedral_set_params(bond_type, mult, bend, phase), "bond type must be nonnegative");}

int tclcommand_inter_parse_subt_lj(Tcl_Interp *interp, int bond_type,				   int argc, char **argv){  double k, r;  if (argc != 3) {    Tcl_AppendResult(interp, "subt_lj needs 2 dummy parameters: "		     "<k_subt_lj> <r_subt_lj>", (char *) NULL);    return TCL_ERROR;  }  if ((! ARG_IS_D(1, k)) || (! ARG_IS_D(2, r))) {    Tcl_AppendResult(interp, "subt_lj needs 2 dummy DOUBLE parameters: "		     "<k_subt_lj> <r_subt_lj>", (char *) NULL);    return TCL_ERROR;  }  CHECK_VALUE(subt_lj_set_params(bond_type, k, r), "bond type must be nonnegative");}

int tclcommand_inter_parse_angledist(Tcl_Interp *interp, int bond_type, int argc, char **argv){  double bend, phimin, distmin, phimax, distmax;  if (argc != 6) {    Tcl_AppendResult(interp, "angledist needs 5 parameters: "		     "<bend> <phimin> <distmin> <phimax> <distmax>", (char *) NULL);    printf ("argc=%d/n",argc);    return (TCL_ERROR);  }  if (! ARG_IS_D(1, bend)) {    Tcl_AppendResult(interp, "angledist needs a DOUBLE parameter: "		     "<bend> ", (char *) NULL);    return TCL_ERROR;  }  if (! ARG_IS_D(2, phimin)) {    Tcl_AppendResult(interp, "angledist needs a DOUBLE parameter: "                     "<phimin> ", (char *) NULL);    return TCL_ERROR;  }  if (! ARG_IS_D(3, distmin)) {    Tcl_AppendResult(interp, "angledist needs a DOUBLE parameter: "		     "<distmin> ", (char *) NULL);    return TCL_ERROR;  }  if (! ARG_IS_D(4, phimax)) {    Tcl_AppendResult(interp, "angledist needs a DOUBLE parameter: "                     "<phimax> ", (char *) NULL);    return TCL_ERROR;  }  if (! ARG_IS_D(5, distmax)) {    Tcl_AppendResult(interp, "angledist needs a DOUBLE parameter: "		     "<distmax> ", (char *) NULL);    return TCL_ERROR;  }  CHECK_VALUE(angledist_set_params(bond_type, bend, phimin, distmin, phimax, distmax), "bond type must be nonnegative");}

/// parse parameters for the volume_force potentialint tclcommand_inter_parse_volume_force(Tcl_Interp *interp, int bond_type, int argc, char **argv){  double V0, kv;//drvmax;  if (argc != 3) {    Tcl_AppendResult(interp, "volume_force needs 2 parameters: "		     "<V0> <kv>", (char *) NULL);    return (TCL_ERROR);  } if ((! ARG_IS_D(1, V0)) || (! ARG_IS_D(2, kv)))// || (! ARG_IS_D(3, drvmax)))    {      Tcl_AppendResult(interp, "volume needs 2 DOUBLE parameters: "		       "<V0> <kv>", (char *) NULL);      return TCL_ERROR;    }  CHECK_VALUE(volume_force_set_params(bond_type, V0, kv), "bond type must be nonnegative");}

int tclcommand_inter_parse_ljcos2(Tcl_Interp * interp,		       int part_type_a, int part_type_b,		       int argc, char ** argv){  /* parameters needed for lj-cos2 */  double eps, sig, offset, w, cap_radius;  int change;  /* get lj-cos2 interaction type */  if (argc < 5) {    Tcl_AppendResult(interp, "ljcos2 needs 4 parameters: "		     "<ljcos2_eps> <ljcos2_sig> <ljcos2_offset> <ljcos2_w>",		     (char *) NULL);    return 0;  }  /* copy lj-cos2 parameters */  if ((! ARG_IS_D(1, eps))    ||      (! ARG_IS_D(2, sig))    ||      (! ARG_IS_D(3, offset)) ||      (! ARG_IS_D(4, w))) {    Tcl_AppendResult(interp, "ljcos2 needs 4 DOUBLE parameters: "		     "<ljcos2_eps> <ljcos2_sig> <ljcos2_offset> <ljcos2_w>",		     (char *) NULL);    return TCL_ERROR;  }  change = 5;  cap_radius = -1;  /* check wether there is an additional double, cap radius, and parse in */  if (argc >= 6 && ARG_IS_D(5, cap_radius))    change++;  else    Tcl_ResetResult(interp);  if (ljcos2_set_params(part_type_a, part_type_b,			       eps, sig, offset, w			       ) == TCL_ERROR) {    Tcl_AppendResult(interp, "particle types must be non-negative", (char *) NULL);    return 0;  }  return change;}

/// parse parameters for the area_force_local potentialint tclcommand_inter_parse_area_force_local(Tcl_Interp *interp, int bond_type, int argc, char **argv){  double A0_l, ka_l;  if (argc != 3) {    Tcl_AppendResult(interp, "area_force_local needs 2 parameters: "		     "<A0> <ka>", (char *) NULL);    return (TCL_ERROR);  } if ((! ARG_IS_D(1, A0_l)) || (! ARG_IS_D(2, ka_l)))    {      Tcl_AppendResult(interp, "area_force_local needs 2 DOUBLE parameters: "		       "<A0_l> <ka_l>", (char *) NULL);      return TCL_ERROR;    }  CHECK_VALUE(area_force_local_set_params(bond_type, A0_l, ka_l), "bond type must be nonnegative");}

int tclcommand_localeps(Tcl_Interp* interp, int argc, char** argv){    int mesh = maggs_get_mesh_1D();    int node_x, node_y, node_z, direction;    double relative_epsilon;	    /* number of arguments has to be 8 */    if(argc != 9) {        Tcl_AppendResult(interp, "Wrong number of paramters. Usage: /n", (char *) NULL);        Tcl_AppendResult(interp, "inter coulomb <bjerrum> memd localeps node <x> <y> <z> dir <X/Y/Z> eps <epsilon>", (char *) NULL);        return TCL_ERROR;    }	    /* first argument should be "node" */    if(! ARG_IS_S(1, "node")) return TCL_ERROR;        /* arguments 2-4 should be integers */    if(! ARG_IS_I(2, node_x)) {        Tcl_AppendResult(interp, "integer expected", (char *) NULL);        return TCL_ERROR; }    if(! ARG_IS_I(3, node_y)) {        Tcl_AppendResult(interp, "integer expected", (char *) NULL);        return TCL_ERROR; }    if(! ARG_IS_I(4, node_z)) {        Tcl_AppendResult(interp, "integer expected", (char *) NULL);        return TCL_ERROR; }    /* check if mesh position is in range */    if ( (node_x < 0) || (node_y < 0) || (node_z < 0) || (node_x > mesh) || (node_y > mesh) || (node_z > mesh) ) {        char buffer[TCL_INTEGER_SPACE];        sprintf(buffer, "%d", mesh);        Tcl_AppendResult(interp, "epsilon position out of mesh range. Mesh in each dimension is ", buffer, ".", (char *) NULL);        return TCL_ERROR;    }        /* parse fifth and sixth argument (e.g. dir X) */    if(! ARG_IS_S(5, "dir")) return TCL_ERROR;    if ( (! ARG_IS_S(6, "X")) && (! ARG_IS_S(6, "Y")) && (! ARG_IS_S(6, "Z")) ) {        Tcl_AppendResult(interp, "Parameter dir should be 'X', 'Y' or 'Z'.", (char *) NULL);        return TCL_ERROR; }    if(ARG_IS_S(6, "X")) direction = 0;    if(ARG_IS_S(6, "Y")) direction = 1;    if(ARG_IS_S(6, "Z")) direction = 2;        /* parse seventh and eight argument (e.g. eps 0.5) */    if(! ARG_IS_S(7, "eps")) return TCL_ERROR;    if ( (! ARG_IS_D(8, relative_epsilon)) || (relative_epsilon < 0.0) ) {        Tcl_AppendResult(interp, "eps expects a positive double", (char *) NULL);        return TCL_ERROR; }        double eps_before = maggs_set_permittivity(node_x, node_y, node_z, direction, relative_epsilon);        if (eps_before == 1.0) return TCL_OK;    else return TCL_OK;}

int tclcommand_inter_parse_morse(Tcl_Interp * interp,                                 int part_type_a, int part_type_b,                                 int argc, char ** argv){    /* parameters needed for MORSE */    double eps, alpha, rmin, cut, cap_radius;    int change;    /* get morse interaction type */    if (argc < 5) {        Tcl_AppendResult(interp, "morse needs 4 parameters: "                         "<morse_eps> <morse_alpha> <morse_rmin> <morse_cut>",                         (char *) NULL);        return 0;    }    /* copy morse parameters */    if ((! ARG_IS_D(1, eps))   ||            (! ARG_IS_D(2, alpha))   ||            (! ARG_IS_D(3, rmin))   ||            (! ARG_IS_D(4, cut)   )) {        Tcl_AppendResult(interp, "morse needs 4 DOUBLE parameters: "                         "<morse_eps> <morse_alpha> <morse_rmin> <morse_cut>",                         (char *) NULL);        return 0;    }    change = 5;    cap_radius = -1.0;    /* check wether there is an additional double, cap radius, and parse in */    if (argc >= 6 && ARG_IS_D(5, cap_radius))        change++;    else        Tcl_ResetResult(interp);    if (morse_set_params(part_type_a, part_type_b,                         eps, alpha, rmin, cut, cap_radius) == ES_ERROR) {        Tcl_AppendResult(interp, "particle types must be non-negative", (char *) NULL);        return 0;    }    return change;}

int tclcommand_inter_parse_gb(Tcl_Interp * interp,			      int part_type_a, int part_type_b,			      int argc, char ** argv){  double tmp;  double eps, sig, cut;  double k1, k2, mu, nu;  int change;  /* there are 9 parameters for gay-berne, but you read in only 7 of them.     The rest is calculated in gay_berne_set_params.  */  if (argc < 8) {    Tcl_AppendResult(interp, "gay-berne needs 7 parameters: "		     "<gb_eps> <gb_sig> <gb_cut> <gb_k1> <gb_k2> <gb_mu> <gb_nu>",		     (char *) NULL);    return 0;  }  /* copy gay-berne parameters */  if ((! ARG_IS_D(1, eps))   ||      (! ARG_IS_D(2, sig))   ||      (! ARG_IS_D(3, cut))   ||      (! ARG_IS_D(4, k1 ))   ||      (! ARG_IS_D(5, k2 ))   ||      (! ARG_IS_D(6, mu ))   ||	      (! ARG_IS_D(7, nu )    )) {    Tcl_AppendResult(interp, "gay-berne needs 7 DOUBLE parameters: "		     "<gb_eps> <gb_sig> <gb_cut> <gb_k1> <gb_k2> <gb_mu> <gb_nu>",		     (char *) NULL);    return 0;  }  change = 8;  if (argc >= 10 && ARG_IS_D(8, tmp) && ARG_IS_D(9, tmp))    change += 2;  else    Tcl_ResetResult(interp);  if (gay_berne_set_params(part_type_a, part_type_b, eps, sig, cut, k1, k2, mu, nu) == ES_ERROR) {    Tcl_AppendResult(interp, "particle types must be non-negative", (char *) NULL);    return 0;  }  return change;}

int tclcommand_inter_coulomb_parse_rf(Tcl_Interp * interp,				      int argc, char ** argv,int method){  double kappa,epsilon1,epsilon2, r_cut;  int i;  if(argc < 4) {    Tcl_AppendResult(interp, "rf needs 4 parameters: "                               "<kappa> <epsilon1> <epsilon2> <r_cut>",(char *) NULL);    return TCL_ERROR;  }  coulomb.method = method;  if ((! ARG_IS_D(0, kappa))      ||      (! ARG_IS_D(1, epsilon1))   ||      (! ARG_IS_D(2, epsilon2))   ||      (! ARG_IS_D(3, r_cut)        )) {      Tcl_AppendResult(interp, "rf needs 4 parameters: "                               "<kappa> <epsilon1> <epsilon2> <r_cut>",(char *) NULL);       return TCL_ERROR;  }  if ( (i = rf_set_params(kappa,epsilon1,epsilon2,r_cut)) < 0) {    switch (i) {    case -1:      Tcl_AppendResult(interp, "rf eps must be positive.",(char *) NULL);      break;    case -2:      Tcl_AppendResult(interp, "rf r_cut must be positive.",(char *) NULL);      break;    default:      Tcl_AppendResult(interp, "unspecified error",(char *) NULL);    }        return TCL_ERROR;  }  return TCL_OK;}