atominfo.cc

大型并行量子化学软件；支持密度泛函（DFT）。可以进行各种量子化学计算。支持CHARMM并行计算。非常具有应用价值。

          keyval = new ParsedKeyVal(filename);
          delete[] filename;
        }
      else {
          struct stat sb;
          const char *ainfo = SCDATADIR "/atominfo.kv";
#ifdef SRC_SCLIBDIR
          if (stat(ainfo, &sb) != 0) {
              ainfo = SRC_SCLIBDIR "/atominfo.kv";
            }
#endif
          ExEnv::out0() << indent << "Reading file " << ainfo << "." << endl;
          keyval = new ParsedKeyVal(ainfo);
        }
      Ref<KeyVal> pkeyval = new PrefixKeyVal(keyval, "atominfo");
      load_values(pkeyval,0);
    }
  grp->bcast(mass_,MaxZ);
  grp->bcast(atomic_radius_,MaxZ);
  grp->bcast(vdw_radius_,MaxZ);
  grp->bcast(bragg_radius_,MaxZ);
  grp->bcast(maxprob_radius_,MaxZ);
  grp->bcast(atomic_radius_scale_);
  grp->bcast(vdw_radius_scale_);
  grp->bcast(bragg_radius_scale_);
  grp->bcast(maxprob_radius_scale_);
  for (int i=0; i<MaxZ; i++) grp->bcast(rgb_[i],3);
  grp->bcast(ip_,MaxZ);
}

void
AtomInfo::override_library_values(const Ref<KeyVal> &keyval)
{
  load_values(keyval, 1);
}

void
AtomInfo::load_values(const Ref<KeyVal>& keyval, int override)
{
  Ref<Units> amu = new Units("amu");
  Ref<Units> bohr = new Units("bohr");
  Ref<Units> hartree = new Units("hartree");

  load_values(mass_, 0, "mass", keyval, override, amu);
  load_values(atomic_radius_, &atomic_radius_scale_, "atomic_radius",
              keyval, override, bohr);
  load_values(vdw_radius_, &vdw_radius_scale_, "vdw_radius",
              keyval, override, bohr);
  load_values(bragg_radius_, &bragg_radius_scale_,
              "bragg_radius", keyval, override, bohr);
  load_values(maxprob_radius_, &maxprob_radius_scale_,
              "maxprob_radius", keyval, override, bohr);
  load_values(rgb_, "rgb", keyval, override);
  load_values(ip_, 0, "ip", keyval, override, hartree);
}

void
AtomInfo::load_values(double *array, double *scale, const char *keyword,
                      const Ref<KeyVal> &keyval, int override,
                      const Ref<Units> &units)
{
  Ref<KeyVal> pkeyval = new PrefixKeyVal(keyval,keyword);
  Ref<Units> fileunits = new Units(pkeyval->pcharvalue("unit"), Units::Steal);
  double f = 1.0;
  if (fileunits.nonnull() && units.nonnull()) {
      f = fileunits->to(units);
    }
  double def = 0.0;
  if (!override) {
      def = pkeyval->doublevalue("default");
      array[0] = def;
    }
  int have_overridden = 0;
  int i;
  for (i=1; i<MaxZ; i++) {
      double val = f * pkeyval->doublevalue(names_[i].symbol);
      if (pkeyval->error() != KeyVal::OK) {
          if (!override) array[i] = def;
        }
      else {
          array[i] = val;
          if (override) {
              const char *prefix = " ";
              if (!have_overridden) {
                  add_overridden_value(keyword);
                  add_overridden_value(":(");
                  if (fileunits.nonnull() && fileunits->string_rep()) {
                      char ustring[256];
                      sprintf(ustring,"unit=\"%s\"",fileunits->string_rep());
                      add_overridden_value(ustring);
                    }
                  else {
                      prefix = "";
                    }
                  have_overridden = 1;
                }
              char *strval = pkeyval->pcharvalue(names_[i].symbol);
              char assignment[256];
              sprintf(assignment,"%s%s=%s", prefix, names_[i].symbol, strval);
              delete[] strval;
              add_overridden_value(assignment);
            }
        }
    }
  if (scale) {
      KeyValValuedouble kvvscale(1.0);
      *scale = pkeyval->doublevalue("scale_factor", kvvscale);
      if (pkeyval->error() == KeyVal::OK) {
          if (override) {
              const char *prefix = " ";
              if (!have_overridden) {
                  add_overridden_value(keyword);
                  add_overridden_value(":(");
                  have_overridden = 1;
                  prefix = "";
                }
              char *strval = pkeyval->pcharvalue("scale_factor");
              char assignment[256];
              sprintf(assignment,"%sscale_factor=%s", prefix, strval);
              delete[] strval;
              add_overridden_value(assignment);
            }
        }
    }
  if (have_overridden) {
      add_overridden_value(")");
    }
}

void
AtomInfo::load_values(double array[][3], const char *keyword,
                      const Ref<KeyVal> &keyval, int override)
{
  int i,j;
  Ref<KeyVal> pkeyval = new PrefixKeyVal(keyval,keyword);
  double def[3];
  if (!override) {
      for (i=0; i<3; i++) {
          def[i] = pkeyval->doublevalue("default",i);
          array[0][i] = def[i];
        }
    }
  int have_overridden = 0;
  for (i=1; i<MaxZ; i++) {
      double val;
      for (j=0; j<3; j++) {
          val = pkeyval->doublevalue(names_[i].symbol,j);
          if (pkeyval->error() != KeyVal::OK) {
              if (!override) array[i][j] = def[j];
            }
          else {
              array[i][j] = val;
              if (override) {
                  const char *prefix = " ";
                  if (!have_overridden) {
                      add_overridden_value(keyword);
                      add_overridden_value(":(");
                      prefix = "";
                      have_overridden = 1;
                    }
                  char *strval = pkeyval->pcharvalue(names_[i].symbol,j);
                  char assignment[256];
                  sprintf(assignment,"%s%s:%d=%s",
                          prefix, names_[i].symbol, j, strval);
                  delete[] strval;
                  add_overridden_value(assignment);
                }
            }
        }
    }
  if (have_overridden) {
      add_overridden_value(")");
    }
}

void
AtomInfo::add_overridden_value(const char *assignment)
{
  int length = strlen(assignment)+1;
  if (overridden_values_) length += strlen(overridden_values_);
  char *new_overridden_values = new char[length];
  new_overridden_values[0] = '\0';
  if (overridden_values_) strcat(new_overridden_values, overridden_values_);
  strcat(new_overridden_values, assignment);
  delete[] overridden_values_;
  overridden_values_ = new_overridden_values;
}

int
AtomInfo::string_to_Z(const char *name, int allow_exceptions)
{
  unsigned int i,j;
  int Z;

  // see if the name is a atomic number
  Z = atoi(name);

  // name is not an atomic number--must be a symbol or atom name
  if (!Z) {

      // convert the name to lower case
      char* tmpname = strdup(name);
      for (j=0; j<strlen(tmpname); j++) {
	  if (isupper(tmpname[j])) tmpname[j] = tolower(tmpname[j]);
	}

      // loop thru the elements, looking for a match
      for (i=0; i<MaxZ; i++) {

          // see if an atom name matches
          // if we find a match we are done looping
	  if (!strcmp(names_[i].name,tmpname)) {
	      Z = i;
	      break;
	    }

          // see if an atomic symbol (converted to lower case) matches
          char* tmpsymbol = strdup(names_[i].symbol);
          for (j=0; j<strlen(tmpsymbol); j++) {
	      if (isupper(tmpsymbol[j])) tmpsymbol[j] = tolower(tmpsymbol[j]);
            }
          // if we find a match we are done looping
	  if (!strcmp(tmpsymbol,tmpname)) {
	      Z = i;
              free(tmpsymbol);
	      break;
	    }
          free(tmpsymbol);
	}

      // free the lowercase version of the name
      free(tmpname);
    }  

  // check to see if z value is OK, if not then the name must have been
  // invalid
  if (Z < 1 || Z > MaxZ) {
      if (allow_exceptions) {
          ExEnv::err0()
                       << sprintf("AtomInfo: invalid name: %s\n",name);
          abort();
        }
      else return 0;
    }

  return Z;
}

/////////////////////////////////////////////////////////////////////////////

// Local Variables:
// mode: c++
// c-file-style: "CLJ"
// End: