Changes in / [311d688:e588312]


Ignore:
Location:
src
Files:
32 edited

Legend:

Unmodified
Added
Removed

  • src/Actions/AnalysisAction/PairCorrelationAction.cpp

    r311d688 re588312  
    7676  ofstream output;
    7777  ofstream binoutput;
    78   std::vector< element *> elements;
     78  std::vector<const element *> elements;
    7979  string type;
    8080  Vector Point;

  • src/Actions/AnalysisAction/PointCorrelationAction.cpp

    r311d688 re588312  
    7777  ofstream output;
    7878  ofstream binoutput;
    79   std::vector< element *> elements;
     79  std::vector<const element *> elements;
    8080  string type;
    8181  Vector Point;
    … …  
    9797  cout << "Point to correlate to is  " << Point << endl;
    9898  CorrelationToPointMap *correlationmap = NULL;
    99   for(std::vector< element *>::iterator iter = elements.begin(); iter != elements.end(); ++iter)
    100     cout << "element is " << (*iter)->symbol << endl;
     99  for(std::vector<const element *>::iterator iter = elements.begin(); iter != elements.end(); ++iter)
     100    cout << "element is " << (*iter)->getSymbol() << endl;
    101101  std::vector<molecule*> molecules = World::getInstance().getSelectedMolecules();
    102102  if (periodic)

  • src/Actions/AnalysisAction/SurfaceCorrelationAction.cpp

    r311d688 re588312  
    7878  ofstream output;
    7979  ofstream binoutput;
    80   std::vector< element *> elements;
     80  std::vector<const element *> elements;
    8181  string type;
    8282  Vector Point;

  • src/Actions/AtomAction/AddAction.cpp

    r311d688 re588312  
    5252
    5353Action::state_ptr AtomAddAction::performCall() {
    54   element * elemental = NULL;
     54  const element * elemental = NULL;
    5555  Vector position;
    5656
    … …  
    6363  first->type = elemental;
    6464  first->x = position;
    65   DoLog(1) && (Log() << Verbose(1) << "Adding new atom with element " << first->type->name << " at " << (first->x) << "." << endl);
     65  DoLog(1) && (Log() << Verbose(1) << "Adding new atom with element " << *first->type << " at " << (first->x) << "." << endl);
    6666  // TODO: remove when all of World's atoms are stored.
    6767  std::vector<molecule *> molecules = World::getInstance().getAllMolecules();

  • src/Actions/AtomAction/ChangeElementAction.cpp

    r311d688 re588312  
    5050Action::state_ptr AtomChangeElementAction::performCall() {
    5151  atom *first = NULL;
    52   element *elemental = NULL;
     52  const element *elemental = NULL;
    5353
    5454  ValueStorage::getInstance().queryCurrentValue(NAME, elemental);
    … …  
    5656  for (World::AtomSelectionIterator iter = World::getInstance().beginAtomSelection(); iter != World::getInstance().endAtomSelection(); ++iter) {
    5757    first = iter->second;
    58     DoLog(1) && (Log() << Verbose(1) << "Changing atom " << *first << " to element " << elemental->symbol << "." << endl);
     58    DoLog(1) && (Log() << Verbose(1) << "Changing atom " << *first << " to element " << *elemental << "." << endl);
    5959    first->type = elemental;
    6060  }

  • src/Actions/MapOfActions.cpp

    r311d688 re588312  
    292292
    293293  // value types for the actions
    294   TypeMap["add-atom"] = &typeid(element);
     294  TypeMap["add-atom"] = &typeid(const element);
    295295  TypeMap["bond-file"] = &typeid(std::string);
    296296  TypeMap["bond-table"] = &typeid(std::string);
    … …  
    298298  TypeMap["center-in-box"] = &typeid(BoxValue);
    299299  TypeMap["change-box"] = &typeid(BoxValue);
    300   TypeMap["change-element"] = &typeid(element);
     300  TypeMap["change-element"] = &typeid(const element);
    301301  TypeMap["change-molname"] = &typeid(std::string);
    302302  TypeMap["convex-envelope"] = &typeid(void);
    … …  
    342342  TypeMap["distances"] = &typeid(VectorValue);
    343343  TypeMap["DoRotate"] = &typeid(bool);
    344   TypeMap["element"] = &typeid(element);
    345   TypeMap["elements"] = &typeid(std::vector<element *>);
     344  TypeMap["element"] = &typeid(const element);
     345  TypeMap["elements"] = &typeid(std::vector<const element *>);
    346346  TypeMap["end-step"] = &typeid(int);
    347347  TypeMap["id-mapping"] = &typeid(bool);
    … …  
    380380  TypeEnumMap[&typeid(atom)] = Atom;
    381381  TypeEnumMap[&typeid(std::vector<atom *>)] = ListOfAtoms;
    382   TypeEnumMap[&typeid(element)] = Element;
    383   TypeEnumMap[&typeid(std::vector<element *>)] = ListOfElements;
     382  TypeEnumMap[&typeid(const element)] = Element;
     383  TypeEnumMap[&typeid(std::vector<const element *>)] = ListOfElements;
    384384
    385385  // default values for any action that needs one (always string!)
    … …  
    558558}
    559559
    560 void MapOfActions::queryCurrentValue(const char * name, class element * &_T)  {
     560void MapOfActions::queryCurrentValue(const char * name, const element * &_T)  {
    561561  int Z = -1;
    562   if (typeid( element ) == *TypeMap[name]) {
     562  if (typeid(const element ) == *TypeMap[name]) {
    563563    if (CurrentValue.find(name) == CurrentValue.end())
    564564      throw MissingValueException(__FILE__, __LINE__);
    … …  
    642642}
    643643
    644 void MapOfActions::queryCurrentValue(const char * name, std::vector<element *>&_T)
     644void MapOfActions::queryCurrentValue(const char * name, std::vector<const element *>&_T)
    645645{
    646646  int Z = -1;
    647   element *elemental = NULL;
    648   if (typeid( std::vector<element *> ) == *TypeMap[name]) {
     647  const element *elemental = NULL;
     648  if (typeid( std::vector<const element *> ) == *TypeMap[name]) {
    649649    if (CurrentValue.find(name) == CurrentValue.end())
    650650      throw MissingValueException(__FILE__, __LINE__);
    … …  
    694694}
    695695
    696 void MapOfActions::setCurrentValue(const char * name, class element * &_T)
    697 {
    698   if (typeid( element ) == *TypeMap[name]) {
     696void MapOfActions::setCurrentValue(const char * name, const element * &_T)
     697{
     698  if (typeid(const element ) == *TypeMap[name]) {
    699699    std::ostringstream stream;
    700700    stream << _T->Z;
    … …  
    754754}
    755755
    756 void MapOfActions::setCurrentValue(const char * name, std::vector<element *>&_T)
    757 {
    758   if (typeid( std::vector<element *> ) == *TypeMap[name]) {
     756void MapOfActions::setCurrentValue(const char * name, std::vector<const element *>&_T)
     757{
     758  if (typeid( std::vector<const element *> ) == *TypeMap[name]) {
    759759    std::ostringstream stream;
    760     for (std::vector<element *>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
     760    for (std::vector<const element *>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
    761761      stream << (*iter)->Z << " ";
    762762    }

  • src/Actions/MapOfActions.hpp

    r311d688 re588312  
    164164
    165165  void queryCurrentValue(const char * name, class atom * &_T);
    166   void queryCurrentValue(const char * name, class element * &_T);
     166  void queryCurrentValue(const char * name, const element * &_T);
    167167  void queryCurrentValue(const char * name, class molecule * &_T);
    168168  void queryCurrentValue(const char * name, class Box &_T);
    169169  void queryCurrentValue(const char * name, class Vector &_T);
    170170  void queryCurrentValue(const char * name, std::vector<atom *>&_T);
    171   void queryCurrentValue(const char * name, std::vector<element *>&_T);
     171  void queryCurrentValue(const char * name, std::vector<const element *>&_T);
    172172  void queryCurrentValue(const char * name, std::vector<molecule *>&_T);
    173173  template<typename T> void queryCurrentValue(const char * name, T &_T)
    … …  
    198198
    199199  void setCurrentValue(const char * name, class atom * &_T);
    200   void setCurrentValue(const char * name, class element * &_T);
     200  void setCurrentValue(const char * name, const element * &_T);
    201201  void setCurrentValue(const char * name, class molecule * &_T);
    202202  void setCurrentValue(const char * name, class Box &_T);
    203203  void setCurrentValue(const char * name, class Vector &_T);
    204204  void setCurrentValue(const char * name, std::vector<atom *>&_T);
    205   void setCurrentValue(const char * name, std::vector<element *>&_T);
     205  void setCurrentValue(const char * name, std::vector<const element *>&_T);
    206206  void setCurrentValue(const char * name, std::vector<molecule *>&_T);
    207207  template<class T> void setCurrentValue(const char * name, T &_T)

  • src/Formula.cpp

    r311d688 re588312  
    4747  for(const_iterator iter=end();iter!=begin();){
    4848    --iter;
    49     sstr << (*iter).first->symbol;
     49    sstr << (*iter).first->getSymbol();
    5050    if((*iter).second>1)
    5151      sstr << (*iter).second;
    … …  
    146146
    147147bool Formula::hasElement(const string &shorthand) const{
    148   element * element = World::getInstance().getPeriode()->FindElement(shorthand);
     148  const element * element = World::getInstance().getPeriode()->FindElement(shorthand);
    149149  return hasElement(element);
    150150}
    … …  
    167167
    168168void Formula::operator+=(const string &shorthand){
    169   element * element = World::getInstance().getPeriode()->FindElement(shorthand);
     169  const element * element = World::getInstance().getPeriode()->FindElement(shorthand);
    170170  operator+=(element);
    171171}
    … …  
    198198
    199199void Formula::operator-=(const string &shorthand){
    200   element * element = World::getInstance().getPeriode()->FindElement(shorthand);
     200  const element * element = World::getInstance().getPeriode()->FindElement(shorthand);
    201201  operator-=(element);
    202202}
    … …  
    220220
    221221void Formula::addElements(const string &shorthand,unsigned int count){
    222   element * element = World::getInstance().getPeriode()->FindElement(shorthand);
     222  const element * element = World::getInstance().getPeriode()->FindElement(shorthand);
    223223  addElements(element,count);
    224224}
    … …  
    252252
    253253const unsigned int Formula::operator[](string shorthand) const{
    254   element * element = World::getInstance().getPeriode()->FindElement(shorthand);
     254  const element * element = World::getInstance().getPeriode()->FindElement(shorthand);
    255255  return operator[](element);
    256256}
    … …  
    380380result_type
    381381Formula::_iterator<result_type>::operator*(){
    382   element *element = World::getInstance().getPeriode()->FindElement(pos+1);
     382  const element *element = World::getInstance().getPeriode()->FindElement(pos+1);
    383383  ASSERT(element,"Element with position of iterator not found");
    384384  return make_pair(element,(*set)[pos]);
    … …  
    390390  // no one can keep this value around, so a static is ok to avoid temporaries
    391391  static value_type value=make_pair(reinterpret_cast<element*>(0),0); // no default constructor for std::pair
    392   element *element = World::getInstance().getPeriode()->FindElement(pos+1);
     392  const element *element = World::getInstance().getPeriode()->FindElement(pos+1);
    393393  ASSERT(element,"Element with position of iterator not found");
    394394  value = make_pair(element,(*set)[pos]);

  • src/Parser/PcpParser.cpp

    r311d688 re588312  
    510510    const element * const elemental = World::getInstance().getPeriode()->FindElement(iter->first);
    511511    ZtoIndexMap.insert( pair<int,int> (iter->first, counter) );
    512     *file << "Ion_Type" << counter++ << "\t" << iter->second << "\t" << elemental->Z << "\t1.0\t3\t3\t" << fixed << setprecision(11) << showpoint << elemental->mass << "\t" << elemental->name << "\t" << elemental->symbol <<endl;
     512    *file << "Ion_Type" << counter++ << "\t" << iter->second << "\t" << elemental->Z << "\t1.0\t3\t3\t" << fixed << setprecision(11) << showpoint << elemental->mass << "\t" << elemental->getName() << "\t" << elemental->getSymbol() <<endl;
    513513  }
    514514}

  • src/Parser/XyzParser.cpp

    r311d688 re588312  
    7272  vector<atom*> atoms = World::getInstance().getAllAtoms();
    7373  for(vector<atom*>::iterator it = atoms.begin(); it != atoms.end(); it++) {
    74     *file << noshowpoint << (*it)->getType()->symbol << "\t" << (*it)->x[0] << "\t" << (*it)->x[1] << "\t" << (*it)->x[2] << endl;
     74    *file << noshowpoint << (*it)->getType()->getSymbol() << "\t" << (*it)->x[0] << "\t" << (*it)->x[1] << "\t" << (*it)->x[2] << endl;
    7575  }
    7676}

  • src/UIElements/Dialog.hpp

    r311d688 re588312  
    255255    virtual void setResult();
    256256  protected:
    257     element * tmp;
     257    const element * tmp;
    258258  };
    259259
    … …  
    265265    virtual void setResult();
    266266  protected:
    267     element *temp;
    268     std::vector<element *> tmp;
     267    const element *temp;
     268    std::vector<const element *> tmp;
    269269  };
    270270

  • src/UIElements/QT4/QTDialog.cpp

    r311d688 re588312  
    558558  {
    559559    stringstream sstr;
    560     sstr << (*iter).first << "\t" << (*iter).second->name;
     560    sstr << (*iter).first << "\t" << (*iter).second->getName();
    561561    inputBox->addItem(QString(sstr.str().c_str()),QVariant((*iter).first));
    562562  }
    … …  
    593593  {
    594594    stringstream sstr;
    595     sstr << (*iter).first << "\t" << (*iter).second->name;
     595    sstr << (*iter).first << "\t" << (*iter).second->getName();
    596596    inputBox->addItem(QString(sstr.str().c_str()),QVariant((*iter).first));
    597597  }
    … …  
    820820}
    821821
    822 ElementQTQueryPipe::ElementQTQueryPipe(element **_content, QTDialog *_dialog, QComboBox *_theBox) :
     822ElementQTQueryPipe::ElementQTQueryPipe(const element **_content, QTDialog *_dialog, QComboBox *_theBox) :
    823823  content(_content),
    824824  dialog(_dialog),
    … …  
    836836}
    837837
    838 ElementsQTQueryPipe::ElementsQTQueryPipe(std::vector<element *>*_content, QTDialog *_dialog, QComboBox *_theBox) :
     838ElementsQTQueryPipe::ElementsQTQueryPipe(std::vector<const element *>*_content, QTDialog *_dialog, QComboBox *_theBox) :
    839839  content(_content),
    840840  dialog(_dialog),
    … …  
    848848  QVariant data = theBox->itemData(newIndex);
    849849  int idx = data.toInt();
    850   element *elemental = World::getInstance().getPeriode()->FindElement(idx);
     850  const element *elemental = World::getInstance().getPeriode()->FindElement(idx);
    851851  if(elemental)
    852852    (*content).push_back(elemental);

  • src/UIElements/QT4/QTDialog.hpp

    r311d688 re588312  
    451451  Q_OBJECT
    452452public:
    453   ElementQTQueryPipe(element **_content, QTDialog *_dialog, QComboBox *_theBox);
     453  ElementQTQueryPipe(const element **_content, QTDialog *_dialog, QComboBox *_theBox);
    454454  virtual ~ElementQTQueryPipe();
    455455
    … …  
    458458
    459459private:
    460   element **content;
     460  const element **content;
    461461  QTDialog *dialog;
    462462  QComboBox *theBox;
    … …  
    466466  Q_OBJECT
    467467public:
    468   ElementsQTQueryPipe(std::vector<element *>*_content, QTDialog *_dialog, QComboBox *_theBox);
     468  ElementsQTQueryPipe(std::vector<const element *>*_content, QTDialog *_dialog, QComboBox *_theBox);
    469469  virtual ~ElementsQTQueryPipe();
    470470
    … …  
    473473
    474474private:
    475   std::vector<element *>*content;
     475  std::vector<const element *>*content;
    476476  QTDialog *dialog;
    477477  QComboBox *theBox;

  • src/UIElements/TextUI/TextDialog.cpp

    r311d688 re588312  
    568568  bool badInput=false;
    569569  bool aborted = false;
    570   element * temp = NULL;
     570  const element * temp = NULL;
    571571  do{
    572572    badInput = false;

  • src/analysis_bonds.cpp

    r311d688 re588312  
    215215          if (((OtherAtom->type == first) || (OtherAtom->type == second)) && (theAtom->nr < OtherAtom->nr)) {
    216216            count++;
    217             DoLog(1) && (Log() << Verbose(1) << first->name << "-" << second->name << " bond found between " << *Walker << " and " << *OtherAtom << "." << endl);
     217            DoLog(1) && (Log() << Verbose(1) << *first << "-" << *second << " bond found between " << *Walker << " and " << *OtherAtom << "." << endl);
    218218          }
    219219        }
    … …  
    262262        if (result) { // check results
    263263          count++;
    264           DoLog(1) && (Log() << Verbose(1) << first->name << "-" << second->name << "-" << third->name << " bond found at " << *Walker << "." << endl);
     264          DoLog(1) && (Log() << Verbose(1) << *first << "-" << *second << "-" << *third << " bond found at " << *Walker << "." << endl);
    265265        }
    266266      }

  • src/analysis_correlation.cpp

    r311d688 re588312  
    3232 * \return Map of doubles with values the pair of the two atoms.
    3333 */
    34 PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements)
     34PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<const element *> &elements)
    3535{
    3636  Info FunctionInfo(__func__);
    … …  
    4747
    4848  // create all possible pairs of elements
    49   set <pair<element *, element *> > PairsOfElements;
     49  set <pair<const element *,const element *> > PairsOfElements;
    5050  if (elements.size() >= 2) {
    51     for (vector<element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
    52       for (vector<element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
     51    for (vector<const element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
     52      for (vector<const element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
    5353        if (type1 != type2) {
    54           PairsOfElements.insert( pair<element *, element*>(*type1,*type2) );
    55           DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << (*type1)->symbol << " and " << (*type2)->symbol << "." << endl);
     54          PairsOfElements.insert( make_pair(*type1,*type2) );
     55          DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << *(*type1) << " and " << *(*type2) << "." << endl);
    5656        }
    5757  } else if (elements.size() == 1) { // one to all are valid
    58     element *elemental = *elements.begin();
    59     PairsOfElements.insert( pair<element *, element*>(elemental,(element *)NULL) );
    60     PairsOfElements.insert( pair<element *, element*>((element *)NULL,elemental) );
     58    const element *elemental = *elements.begin();
     59    PairsOfElements.insert( pair<const element *,const element*>(elemental,0) );
     60    PairsOfElements.insert( pair<const element *,const element*>(0,elemental) );
    6161  } else { // all elements valid
    6262    PairsOfElements.insert( pair<element *, element*>((element *)NULL, (element *)NULL) );
    … …  
    7373          DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
    7474          if ((*iter)->getId() < (*runner)->getId()){
    75             for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
     75            for (set <pair<const element *,const element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
    7676              if ((PairRunner->first == (**iter).type) && (PairRunner->second == (**runner).type)) {
    7777                distance = domain.periodicDistance(*(*iter)->node,*(*runner)->node);
    … …  
    9494 * \return Map of doubles with values the pair of the two atoms.
    9595 */
    96 PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const int ranges[NDIM] )
     96PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const int ranges[NDIM] )
    9797{
    9898  Info FunctionInfo(__func__);
    … …  
    114114
    115115  // create all possible pairs of elements
    116   set <pair<element *, element *> > PairsOfElements;
     116  set <pair<const element *,const element *> > PairsOfElements;
    117117  if (elements.size() >= 2) {
    118     for (vector<element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
    119       for (vector<element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
     118    for (vector<const element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
     119      for (vector<const element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
    120120        if (type1 != type2) {
    121           PairsOfElements.insert( pair<element *, element*>(*type1,*type2) );
    122           DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << (*type1)->symbol << " and " << (*type2)->symbol << "." << endl);
     121          PairsOfElements.insert( make_pair(*type1,*type2) );
     122          DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << *(*type1) << " and " << *(*type2) << "." << endl);
    123123        }
    124124  } else if (elements.size() == 1) { // one to all are valid
    125     element *elemental = *elements.begin();
    126     PairsOfElements.insert( pair<element *, element*>(elemental,(element *)NULL) );
    127     PairsOfElements.insert( pair<element *, element*>((element *)NULL,elemental) );
     125    const element *elemental = *elements.begin();
     126    PairsOfElements.insert( pair<const element *,const element*>(elemental,0) );
     127    PairsOfElements.insert( pair<const element *,const element*>(0,elemental) );
    128128  } else { // all elements valid
    129129    PairsOfElements.insert( pair<element *, element*>((element *)NULL, (element *)NULL) );
    … …  
    148148                  DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
    149149                  if ((*iter)->getId() < (*runner)->getId()){
    150                     for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
     150                    for (set <pair<const element *,const element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
    151151                      if ((PairRunner->first == (**iter).type) && (PairRunner->second == (**runner).type)) {
    152152                        periodicOtherX = FullInverseMatrix * (*(*runner)->node); // x now in [0,1)^3
    … …  
    177177 * \return Map of dobules with values as pairs of atom and the vector
    178178 */
    179 CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point )
     179CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Vector *point )
    180180{
    181181  Info FunctionInfo(__func__);
    … …  
    195195    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    196196      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
    197       for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
     197      for (vector<const element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
    198198        if ((*type == NULL) || ((*iter)->type == *type)) {
    199199          distance = domain.periodicDistance(*(*iter)->node,*point);
    … …  
    214214 * \return Map of dobules with values as pairs of atom and the vector
    215215 */
    216 CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] )
     216CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Vector *point, const int ranges[NDIM] )
    217217{
    218218  Info FunctionInfo(__func__);
    … …  
    236236    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    237237      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
    238       for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
     238      for (vector<const element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
    239239        if ((*type == NULL) || ((*iter)->type == *type)) {
    240240          periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3
    … …  
    262262 * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
    263263 */
    264 CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC )
     264CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Tesselation * const Surface, const LinkedCell *LC )
    265265{
    266266  Info FunctionInfo(__func__);
    … …  
    283283    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    284284      DoLog(3) && (Log() << Verbose(3) << "\tCurrent atom is " << *(*iter) << "." << endl);
    285       for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
     285      for (vector<const element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
    286286        if ((*type == NULL) || ((*iter)->type == *type)) {
    287287          TriangleIntersectionList Intersections((*iter)->node,Surface,LC);
    … …  
    308308 * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
    309309 */
    310 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
     310CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
    311311{
    312312  Info FunctionInfo(__func__);
    … …  
    334334    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    335335      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
    336       for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
     336      for (vector<const element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
    337337        if ((*type == NULL) || ((*iter)->type == *type)) {
    338338          periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3

  • src/analysis_correlation.hpp

    r311d688 re588312  
    4646/********************************************** declarations *******************************/
    4747
    48 PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements);
    49 CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point );
    50 CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC );
    51 PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const int ranges[NDIM] );
    52 CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] );
    53 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] );
     48PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<const element *> &elements);
     49CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Vector *point );
     50CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Tesselation * const Surface, const LinkedCell *LC );
     51PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const int ranges[NDIM] );
     52CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Vector *point, const int ranges[NDIM] );
     53CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] );
    5454int GetBin ( const double value, const double BinWidth, const double BinStart );
    5555void OutputCorrelation( ofstream * const file, const BinPairMap * const map );

  • src/atom.cpp

    r311d688 re588312  
    193193{
    194194  if (out != NULL) {
    195     *out << type->symbol << "\t" << x[0] << "\t" << x[1] << "\t" << x[2] << "\t" << endl;
     195    *out << type->getSymbol() << "\t" << x[0] << "\t" << x[1] << "\t" << x[2] << "\t" << endl;
    196196    return true;
    197197  } else
    … …  
    231231{
    232232  if (out != NULL) {
    233     *out << type->symbol << "\t";
     233    *out << type->getSymbol() << "\t";
    234234    *out << Trajectory.R.at(step)[0] << "\t";
    235235    *out << Trajectory.R.at(step)[1] << "\t";
    … …  
    247247void atom::OutputMPQCLine(ostream * const out, const Vector *center, int *AtomNo = NULL) const
    248248{
    249   *out << "\t\t" << type->symbol << " [ " << x[0]-center->at(0) << "\t" << x[1]-center->at(1) << "\t" << x[2]-center->at(2) << " ]" << endl;
     249  *out << "\t\t" << type->getSymbol() << " [ " << x[0]-center->at(0) << "\t" << x[1]-center->at(1) << "\t" << x[2]-center->at(2) << " ]" << endl;
    250250  if (AtomNo != NULL)
    251251    *AtomNo++;

  • src/config.cpp

    r311d688 re588312  
    12791279    AtomNo = 0;
    12801280    for (molecule::const_iterator iter = (*MolRunner)->begin(); iter != (*MolRunner)->end(); ++iter) {
    1281       sprintf(name, "%2s%2d",(*iter)->type->symbol, elementNo[(*iter)->type->Z]);
     1281      sprintf(name, "%2s%2d",(*iter)->type->getSymbol().c_str(), elementNo[(*iter)->type->Z]);
    12821282      elementNo[(*iter)->type->Z] = (elementNo[(*iter)->type->Z]+1) % 100;   // confine to two digits
    12831283      fprintf(f,
    … …  
    12941294             (double)(*iter)->type->NoValenceOrbitals,          /* temperature factor */
    12951295             "0",            /* segment identifier */
    1296              (*iter)->type->symbol,    /* element symbol */
     1296             (*iter)->type->getSymbol().c_str(),    /* element symbol */
    12971297             "0");           /* charge */
    12981298      AtomNo++;
    … …  
    13321332  AtomNo = 0;
    13331333  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    1334     sprintf(name, "%2s%2d",(*iter)->type->symbol, elementNo[(*iter)->type->Z]);
     1334    sprintf(name, "%2s%2d",(*iter)->type->getSymbol().c_str(), elementNo[(*iter)->type->Z]);
    13351335    elementNo[(*iter)->type->Z] = (elementNo[(*iter)->type->Z]+1) % 100;   // confine to two digits
    13361336    fprintf(f,
    … …  
    13471347           (double)(*iter)->type->NoValenceOrbitals,          /* temperature factor */
    13481348           "0",            /* segment identifier */
    1349            (*iter)->type->symbol,    /* element symbol */
     1349           (*iter)->type->getSymbol().c_str(),    /* element symbol */
    13501350           "0");           /* charge */
    13511351    AtomNo++;
    … …  
    13921392    *output << (*iter)->node->at(0) << "\t" << (*iter)->node->at(1) << "\t" << (*iter)->node->at(2) << "\t";
    13931393    *output << static_cast<double>((*iter)->type->Valence) << "\t";
    1394     *output << (*iter)->type->symbol << "\t";
     1394    *output << (*iter)->type->getSymbol() << "\t";
    13951395    for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
    13961396      *output << (*runner)->GetOtherAtom(*iter)->nr << "\t";
    … …  
    14641464        *output << (*iter)->node->at(0) << "\t" << (*iter)->node->at(1) << "\t" << (*iter)->node->at(2) << "\t";
    14651465        *output << (double)(*iter)->type->Valence << "\t";
    1466         *output << (*iter)->type->symbol << "\t";
     1466        *output << (*iter)->type->getSymbol() << "\t";
    14671467        for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
    14681468          *output << LocalNotoGlobalNoMap[ (*runner)->GetOtherAtom((*iter))->getId() ] << "\t";

  • src/element.cpp

    r311d688 re588312  
    2323  VanDerWaalsRadius(0),
    2424        Z(-1),
    25         previous(NULL),
    26         next(NULL),
    27         sort(NULL),
    2825        Valence(0),
    2926        NoValenceOrbitals(0)
    … …  
    3128};
    3229
     30element::element(const element &src) :
     31  mass(src.mass),
     32  CovalentRadius(src.CovalentRadius),
     33  VanDerWaalsRadius(src.VanDerWaalsRadius),
     34  Z(src.Z),
     35  Valence(src.Valence),
     36  NoValenceOrbitals(src.NoValenceOrbitals),
     37  name(src.name),
     38  symbol(src.symbol)
     39{
     40  strncpy(period,src.period,strfield_length+1);
     41  strncpy(group,src.group,strfield_length+1);
     42  strncpy(block,src.block,strfield_length+1);
     43}
     44
    3345/** Destructor of class element.
    3446 */
    3547element::~element() {};
     48
     49element &element::operator=(const element &src){
     50  if(this!=&src){
     51    mass=src.mass;
     52    CovalentRadius=src.CovalentRadius;
     53    VanDerWaalsRadius=src.VanDerWaalsRadius;
     54    Z=src.Z;
     55    Valence=src.Valence;
     56    NoValenceOrbitals=src.NoValenceOrbitals;
     57    name=src.name;
     58    symbol=src.symbol;
     59    strncpy(period,src.period,strfield_length+1);
     60    strncpy(group,src.group,strfield_length+1);
     61    strncpy(block,src.block,strfield_length+1);
     62  }
     63  return *this;
     64}
    3665
    3766/** Prints element data to \a *out.
    … …  
    6695}
    6796
    68 string element::getSymbol() const{
    69   return string(symbol);
     97string &element::getSymbol(){
     98  return symbol;
    7099}
    71100
    72 std::string element::getName() const{
    73   return string(name);
     101const string &element::getSymbol() const{
     102  return symbol;
     103}
     104
     105std::string &element::getName(){
     106  return name;
     107}
     108
     109const std::string &element::getName() const{
     110  return name;
    74111}
    75112

  • src/element.hpp

    r311d688 re588312  
    2828 */
    2929class element {
     30  enum {strfield_length=7};
    3031  public:
    3132    double mass;    //!< mass in g/mol
    … …  
    3334    double VanDerWaalsRadius;  //!< can-der-Waals radius
    3435    int Z;          //!< atomic number
    35     char name[64];  //!< atom name, i.e. "Hydrogren"
    36     char symbol[3]; //!< short form of the atom, i.e. "H"
    37     char period[8];    //!< period: n quantum number
    38     char group[8];    //!< group: l quantum number
    39     char block[8];    //!< block: l quantum number
    40     element *previous;  //!< previous item in list
    41     element *next;  //!< next element in list
    42     int *sort;      //!< sorc criteria
     36    char period[strfield_length+1];    //!< period: n quantum number
     37    char group[strfield_length+1];    //!< group: l quantum number
     38    char block[strfield_length+1];    //!< block: l quantum number
    4339    double Valence;   //!< number of valence electrons for this element
    4440    int NoValenceOrbitals;  //!< number of valence orbitals, used for determining bond degree in molecule::CreateConnectmatrix()
    … …  
    4642    double HBondAngle[NDIM];     //!< typical angle for one, two, three bonded hydrogen (in degrees)
    4743
    48   element();
    49   ~element();
     44    element();
     45    element(const element&);
     46    ~element();
    5047
    51   // accessor functions
    52   atomicNumber_t getNumber() const;
    53   std::string getSymbol() const;
    54   std::string getName() const;
     48    element &operator=(const element&);
    5549
    56   //> print element entries to screen
    57   bool Output(std::ostream * const out) const;
    58   bool Checkout(std::ostream * const out, const int No, const int NoOfAtoms) const;
     50    // accessor functions
     51    atomicNumber_t getNumber() const;
     52    std::string &getSymbol();
     53    const std::string &getSymbol() const;
     54    std::string &getName();
     55    const std::string &getName() const;
     56
     57    //> print element entries to screen
     58    bool Output(std::ostream * const out) const;
     59    bool Checkout(std::ostream * const out, const int No, const int NoOfAtoms) const;
    5960
    6061  private:
     62    std::string name;  //!< atom name, i.e. "Hydrogren"
     63    std::string symbol; //!< short form of the atom, i.e. "H"
    6164};
    6265

  • src/molecule.cpp

    r311d688 re588312  
    218218      if(pointer->getName() == "Unknown"){
    219219        stringstream sstr;
    220         sstr << pointer->type->symbol << pointer->nr+1;
     220        sstr << pointer->type->getSymbol() << pointer->nr+1;
    221221        pointer->setName(sstr.str());
    222222      }
    … …  
    975975      NoNonHydrogen++;
    976976    stringstream sstr;
    977     sstr << (*iter)->type->symbol << (*iter)->nr+1;
     977    sstr << (*iter)->type->getSymbol() << (*iter)->nr+1;
    978978    (*iter)->setName(sstr.str());
    979979    DoLog(3) && (Log() << Verbose(3) << "Naming atom nr. " << (*iter)->nr << " " << (*iter)->getName() << "." << endl);
    … …  
    981981  }
    982982  return res;
    983 };
    984 
    985 /** Determines whether two molecules actually contain the same atoms and coordination.
    986  * \param *out output stream for debugging
    987  * \param *OtherMolecule the molecule to compare this one to
    988  * \param threshold upper limit of difference when comparing the coordination.
    989  * \return NULL - not equal, otherwise an allocated (molecule::AtomCount) permutation map of the atom numbers (which corresponds to which)
    990  */
    991 int * molecule::IsEqualToWithinThreshold(molecule *OtherMolecule, double threshold)
    992 {
    993   int flag;
    994   double *Distances = NULL, *OtherDistances = NULL;
    995   Vector CenterOfGravity, OtherCenterOfGravity;
    996   size_t *PermMap = NULL, *OtherPermMap = NULL;
    997   int *PermutationMap = NULL;
    998   bool result = true; // status of comparison
    999 
    1000   DoLog(3) && (Log() << Verbose(3) << "Begin of IsEqualToWithinThreshold." << endl);
    1001   /// first count both their atoms and elements and update lists thereby ...
    1002   //Log() << Verbose(0) << "Counting atoms, updating list" << endl;
    1003 
    1004   /// ... and compare:
    1005   /// -# AtomCount
    1006   if (result) {
    1007     if (getAtomCount() != OtherMolecule->getAtomCount()) {
    1008       DoLog(4) && (Log() << Verbose(4) << "AtomCounts don't match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl);
    1009       result = false;
    1010     } else Log() << Verbose(4) << "AtomCounts match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl;
    1011   }
    1012   /// -# Formula
    1013   if (result) {
    1014     if (formula != OtherMolecule->formula) {
    1015       DoLog(4) && (Log() << Verbose(4) << "Formulas don't match: " << formula << " == " << OtherMolecule->formula << endl);
    1016       result = false;
    1017     } else Log() << Verbose(4) << "Formulas match: " << formula << " == " << OtherMolecule->formula << endl;
    1018   }
    1019   /// then determine and compare center of gravity for each molecule ...
    1020   if (result) {
    1021     DoLog(5) && (Log() << Verbose(5) << "Calculating Centers of Gravity" << endl);
    1022     DeterminePeriodicCenter(CenterOfGravity);
    1023     OtherMolecule->DeterminePeriodicCenter(OtherCenterOfGravity);
    1024     DoLog(5) && (Log() << Verbose(5) << "Center of Gravity: " << CenterOfGravity << endl);
    1025     DoLog(5) && (Log() << Verbose(5) << "Other Center of Gravity: " << OtherCenterOfGravity << endl);
    1026     if (CenterOfGravity.DistanceSquared(OtherCenterOfGravity) > threshold*threshold) {
    1027       DoLog(4) && (Log() << Verbose(4) << "Centers of gravity don't match." << endl);
    1028       result = false;
    1029     }
    1030   }
    1031 
    1032   /// ... then make a list with the euclidian distance to this center for each atom of both molecules
    1033   if (result) {
    1034     DoLog(5) && (Log() << Verbose(5) << "Calculating distances" << endl);
    1035     Distances = new double[getAtomCount()];
    1036     OtherDistances = new double[getAtomCount()];
    1037     SetIndexedArrayForEachAtomTo ( Distances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
    1038     SetIndexedArrayForEachAtomTo ( OtherDistances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
    1039     for(int i=0;i<getAtomCount();i++) {
    1040       Distances[i] = 0.;
    1041       OtherDistances[i] = 0.;
    1042     }
    1043 
    1044     /// ... sort each list (using heapsort (o(N log N)) from GSL)
    1045     DoLog(5) && (Log() << Verbose(5) << "Sorting distances" << endl);
    1046     PermMap = new size_t[getAtomCount()];
    1047     OtherPermMap = new size_t[getAtomCount()];
    1048     for(int i=0;i<getAtomCount();i++) {
    1049       PermMap[i] = 0;
    1050       OtherPermMap[i] = 0;
    1051     }
    1052     gsl_heapsort_index (PermMap, Distances, getAtomCount(), sizeof(double), CompareDoubles);
    1053     gsl_heapsort_index (OtherPermMap, OtherDistances, getAtomCount(), sizeof(double), CompareDoubles);
    1054     PermutationMap = new int[getAtomCount()];
    1055     for(int i=0;i<getAtomCount();i++)
    1056       PermutationMap[i] = 0;
    1057     DoLog(5) && (Log() << Verbose(5) << "Combining Permutation Maps" << endl);
    1058     for(int i=getAtomCount();i--;)
    1059       PermutationMap[PermMap[i]] = (int) OtherPermMap[i];
    1060 
    1061     /// ... and compare them step by step, whether the difference is individually(!) below \a threshold for all
    1062     DoLog(4) && (Log() << Verbose(4) << "Comparing distances" << endl);
    1063     flag = 0;
    1064     for (int i=0;i<getAtomCount();i++) {
    1065       DoLog(5) && (Log() << Verbose(5) << "Distances squared: |" << Distances[PermMap[i]] << " - " << OtherDistances[OtherPermMap[i]] << "| = " << fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) << " ?<? " <<  threshold << endl);
    1066       if (fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) > threshold*threshold)
    1067         flag = 1;
    1068     }
    1069 
    1070     // free memory
    1071     delete[](PermMap);
    1072     delete[](OtherPermMap);
    1073     delete[](Distances);
    1074     delete[](OtherDistances);
    1075     if (flag) { // if not equal
    1076       delete[](PermutationMap);
    1077       result = false;
    1078     }
    1079   }
    1080   /// return pointer to map if all distances were below \a threshold
    1081   DoLog(3) && (Log() << Verbose(3) << "End of IsEqualToWithinThreshold." << endl);
    1082   if (result) {
    1083     DoLog(3) && (Log() << Verbose(3) << "Result: Equal." << endl);
    1084     return PermutationMap;
    1085   } else {
    1086     DoLog(3) && (Log() << Verbose(3) << "Result: Not equal." << endl);
    1087     return NULL;
    1088   }
    1089983};
    1090984

  • src/molecule.hpp

    r311d688 re588312  
    337337
    338338  // Recognize doubly appearing molecules in a list of them
    339   int * IsEqualToWithinThreshold(molecule *OtherMolecule, double threshold);
    340339  int * GetFatherSonAtomicMap(molecule *OtherMolecule);
    341340

  • src/periodentafel.cpp

    r311d688 re588312  
    3434  {
    3535    stringstream input(elementsDB,ios_base::in);
    36     bool status = LoadElementsDatabase(&input);
     36    bool status = LoadElementsDatabase(input);
    3737    ASSERT(status,  "General element initialization failed");
    3838  }
    … …  
    7272 * \return iterator to added element
    7373 */
    74 periodentafel::iterator periodentafel::AddElement(element * const pointer)
     74periodentafel::iterator periodentafel::AddElement(element * pointer)
    7575{
    7676  atomicNumber_t Z = pointer->getNumber();
    7777  ASSERT(!elements.count(Z), "Element is already present.");
    78   pointer->sort = &pointer->Z;
    7978  if (pointer->getNumber() < 1 && pointer->getNumber() >= MAX_ELEMENTS)
    8079    DoeLog(0) && (eLog() << Verbose(0) << "Invalid Z number!\n");
    … …  
    8685 * \param *pointer element to be removed
    8786 */
    88 size_t periodentafel::RemoveElement(element * const pointer)
     87size_t periodentafel::RemoveElement(const element * pointer)
    8988{
    9089  return RemoveElement(pointer->getNumber());
    … …  
    114113 * \return pointer to element or NULL if not found
    115114 */
    116 element * const periodentafel::FindElement(atomicNumber_t Z) const
     115const element * periodentafel::FindElement(atomicNumber_t Z) const
    117116{
    118117  const_iterator res = elements.find(Z);
    … …  
    125124 * \return pointer to element
    126125 */
    127 element * const periodentafel::FindElement(const string &shorthand) const
     126const element * periodentafel::FindElement(const string &shorthand) const
    128127{
    129128  element *res = 0;
    … …  
    140139 * \return desired element or NULL
    141140 */
    142 element * const periodentafel::AskElement() const
    143 {
    144   element * walker = NULL;
     141const element * periodentafel::AskElement() const
     142{
     143  const element * walker = NULL;
    145144  int Z;
    146145  do {
    … …  
    155154 * \return pointer to either present or newly created element
    156155 */
    157 element * const periodentafel::EnterElement()
     156const element * periodentafel::EnterElement()
    158157{
    159158  atomicNumber_t Z = 0;
    160159  DoLog(0) && (Log() << Verbose(0) << "Atomic number: " << Z << endl);
    161160  cin >> Z;
    162   element * const res = FindElement(Z);
     161  const element *res = FindElement(Z);
    163162  if (!res) {
    164163    // TODO: make this using the constructor
    … …  
    169168    cin >> tmp->mass;
    170169    DoLog(0) && (Log() << Verbose(0) << "Name [max 64 chars]: " << endl);
    171     cin >> tmp->name;
     170    cin >> tmp->getName();
    172171    DoLog(0) && (Log() << Verbose(0) << "Short form [max 3 chars]: " << endl);
    173     cin >> tmp->symbol;
     172    cin >> tmp->getSymbol();
    174173    AddElement(tmp);
    175174    return tmp;
    … …  
    180179
    181180/******************** Access to iterators ****************************/
    182 periodentafel::const_iterator periodentafel::begin(){
     181periodentafel::const_iterator periodentafel::begin() const{
    183182  return elements.begin();
    184183}
    185184
    186 periodentafel::const_iterator periodentafel::end(){
     185periodentafel::const_iterator periodentafel::end() const{
    187186  return elements.end();
    188187}
    189188
    190 periodentafel::reverse_iterator periodentafel::rbegin(){
     189periodentafel::reverse_iterator periodentafel::rbegin() const{
    191190  return reverse_iterator(elements.end());
    192191}
    193192
    194 periodentafel::reverse_iterator periodentafel::rend(){
     193periodentafel::reverse_iterator periodentafel::rend() const{
    195194  return reverse_iterator(elements.begin());
    196195}
    … …  
    228227  if (!input.fail())
    229228    DoLog(0) && (Log() << Verbose(0) << "Using " << filename << " as elements database." << endl);
    230   status = status && LoadElementsDatabase(&input);
     229  status = status && LoadElementsDatabase(input);
    231230  input.close();
    232231  input.clear();
    … …  
    287286 * \return true - parsing successful, false - something went wrong
    288287 */
    289 bool periodentafel::LoadElementsDatabase(istream *input)
     288bool periodentafel::LoadElementsDatabase(istream &input)
    290289{
    291290  bool status = true;
    292   int counter = 0;
    293   pair< std::map<atomicNumber_t,element*>::iterator, bool > InserterTest;
    294   if (!(*input).fail()) {
    295     (*input).getline(header1, MAXSTRINGSIZE);
    296     (*input).getline(header2, MAXSTRINGSIZE); // skip first two header lines
     291  string header1tmp,header2tmp;
     292  // first parse into a map, so we can revert to old status in case something goes wront
     293  map<atomicNumber_t,element*> parsedElements;
     294  if (!input.fail()) {
     295    getline(input,header1tmp);
     296    getline(input,header2tmp); // skip first two header lines
     297    cout << "First header: " << header1tmp << endl;
     298    cout << "Second header: " << header2tmp << endl;
    297299    DoLog(0) && (Log() << Verbose(0) <<  "Parsed elements:");
    298     while (!(*input).eof()) {
     300    while (!input.eof()) {
    299301      element *neues = new element;
    300       (*input) >> neues->name;
    301       //(*input) >> ws;
    302       (*input) >> neues->symbol;
    303       //(*input) >> ws;
    304       (*input) >> neues->period;
    305       //(*input) >> ws;
    306       (*input) >> neues->group;
    307       //(*input) >> ws;
    308       (*input) >> neues->block;
    309       //(*input) >> ws;
    310       (*input) >> neues->Z;
    311       //(*input) >> ws;
    312       (*input) >> neues->mass;
    313       //(*input) >> ws;
    314       (*input) >> neues->CovalentRadius;
    315       //(*input) >> ws;
    316       (*input) >> neues->VanDerWaalsRadius;
    317       //(*input) >> ws;
    318       (*input) >> ws;
     302      input >> neues->getName();;
     303      //(*input) >> ws;
     304      input >> neues->getSymbol();
     305      //(*input) >> ws;
     306      input >> neues->period;
     307      //(*input) >> ws;
     308      input >> neues->group;
     309      //(*input) >> ws;
     310      input >> neues->block;
     311      //(*input) >> ws;
     312      input >> neues->Z;
     313      //(*input) >> ws;
     314      input >> neues->mass;
     315      //(*input) >> ws;
     316      input >> neues->CovalentRadius;
     317      //(*input) >> ws;
     318      input >> neues->VanDerWaalsRadius;
     319      //(*input) >> ws;
     320      input >> ws;
    319321      //neues->Output((ofstream *)&cout);
    320322      if ((neues->getNumber() > 0) && (neues->getNumber() < MAX_ELEMENTS)) {
    321         if (elements.count(neues->getNumber())) {// if element already present, remove and delete old one (i.e. replace it)
    322           //cout << neues->symbol << " is present already." << endl;
    323           element * const Elemental = FindElement(neues->getNumber());
    324           ASSERT(Elemental != NULL, "element should be present but is not??");
    325           *Elemental = *neues;
    326           delete(neues);
    327           neues = Elemental;
    328         } else {
    329           InserterTest = elements.insert(pair <atomicNumber_t,element*> (neues->getNumber(), neues));
    330           ASSERT(InserterTest.second, "Could not insert new element into periodentafel on LoadElementsDatabase().");
    331         }
    332         DoLog(0) && (Log() << Verbose(0) << " " << elements[neues->getNumber()]->symbol);
    333         counter++;
     323        parsedElements[neues->Z] = neues;
     324        DoLog(0) && (Log() << Verbose(0) << " " << *neues);
    334325      } else {
    335326        DoeLog(2) && (eLog() << Verbose(2) << "Detected empty line or invalid element in elements db, discarding." << endl);
    … …  
    337328        delete(neues);
    338329      }
     330      // when the input is in failed state, we most likely just read garbage
     331      if(input.fail()) {
     332        DoeLog(2) && (eLog() << Verbose(2) << "Error parsing elements db." << endl);
     333        status = false;
     334        break;
     335      }
    339336    }
    340337    DoLog(0) && (Log() << Verbose(0) << endl);
    … …  
    344341  }
    345342
    346   if (counter == 0)
     343  if (!parsedElements.size())
    347344    status = false;
     345
     346  if(status){
     347    for(map<atomicNumber_t,element*>::iterator iter=parsedElements.begin();
     348                                               iter!=parsedElements.end();
     349                                               ++iter){
     350      if (elements.count(iter->first)) {
     351        // if element already present, replace the old one
     352        // pointer to old element might still be in use, so we have to replace into the old element
     353        *(elements[iter->first])=*iter->second;
     354      }
     355      else {
     356        // no such element in periodentafel... we can just insert
     357        elements[iter->first] = iter->second;
     358      }
     359    }
     360    // all went well.. we now copy the header
     361    strncpy(header1,header1tmp.c_str(),MAXSTRINGSIZE);
     362    header1[MAXSTRINGSIZE-1]=0;
     363    strncpy(header2,header2tmp.c_str(),MAXSTRINGSIZE);
     364    header2[MAXSTRINGSIZE-1]=0;
     365  }
    348366
    349367  return status;

  • src/periodentafel.hpp

    r311d688 re588312  
    4343  ~periodentafel();
    4444
    45   iterator AddElement(element * const pointer);
    46   size_t RemoveElement(element * const pointer);
     45  iterator AddElement(element * pointer);
     46  size_t RemoveElement(const element * pointer);
    4747  size_t RemoveElement(atomicNumber_t);
    4848  void CleanupPeriodtable();
    49   element * const FindElement(atomicNumber_t) const;
    50   element * const FindElement(const std::string &shorthand) const;
    51   element * const AskElement() const;
    52   element * const EnterElement();
     49  const element * FindElement(atomicNumber_t) const;
     50  const element * FindElement(const std::string &shorthand) const;
     51  const element * AskElement() const;
     52  const element * EnterElement();
    5353
    54   const_iterator begin();
    55   const_iterator end();
    56   reverse_iterator rbegin();
    57   reverse_iterator rend();
     54  const_iterator begin() const;
     55  const_iterator end() const;
     56  reverse_iterator rbegin() const;
     57  reverse_iterator rend() const;
    5858  bool Output(std::ostream * const output) const;
    5959  bool LoadPeriodentafel(const char * const path);
    … …  
    6262  private:
    6363
    64   bool LoadElementsDatabase(std::istream *input);
     64  bool LoadElementsDatabase(std::istream &input);
    6565  bool LoadValenceDatabase(std::istream *input);
    6666  bool LoadOrbitalsDatabase(std::istream *input);

  • src/unittests/AnalysisCorrelationToPointUnitTest.cpp

    r311d688 re588312  
    4646
    4747  // construct element list
    48   std::vector<element *> elements;
     48  std::vector<const element *> elements;
    4949  hydrogen = World::getInstance().getPeriode()->FindElement(1);
    5050  CPPUNIT_ASSERT(hydrogen != NULL && "hydrogen element not found");

  • src/unittests/AnalysisCorrelationToPointUnitTest.hpp

    r311d688 re588312  
    3737      std::vector<molecule *> allMolecules;
    3838      molecule *TestMolecule;
    39       element *hydrogen;
     39      const element *hydrogen;
    4040
    4141      CorrelationToPointMap *pointmap;

  • src/unittests/AnalysisCorrelationToSurfaceUnitTest.hpp

    r311d688 re588312  
    4545      std::vector<molecule *> allMolecules;
    4646      molecule *TestSurfaceMolecule;
    47       element *hydrogen;
    48       element *carbon;
    49       std::vector<element *> elements;
     47      const element *hydrogen;
     48      const element *carbon;
     49      std::vector<const element *> elements;
    5050
    5151      CorrelationToSurfaceMap *surfacemap;

  • src/unittests/AnalysisPairCorrelationUnitTest.cpp

    r311d688 re588312  
    4949
    5050  // construct element list
    51   std::vector<element *> elements;
     51  std::vector<const element *> elements;
    5252  hydrogen = World::getInstance().getPeriode()->FindElement(1);
    5353  CPPUNIT_ASSERT(hydrogen != NULL && "hydrogen element not found");

  • src/unittests/AnalysisPairCorrelationUnitTest.hpp

    r311d688 re588312  
    3737      std::vector<molecule *> allMolecules;
    3838      molecule *TestMolecule;
    39       element *hydrogen;
     39      const element *hydrogen;
    4040
    4141      PairCorrelationMap *correlationmap;

  • src/unittests/periodentafelTest.cpp

    r311d688 re588312  
    1111#include <cppunit/extensions/TestFactoryRegistry.h>
    1212#include <cppunit/ui/text/TestRunner.h>
     13
     14#include <sstream>
     15#include <iostream>
    1316
    1417#include "Helpers/Assert.hpp"
    … …  
    6770{
    6871  // reload all databases
    69   CPPUNIT_ASSERT(tafel->LoadElementsDatabase(new stringstream(elementsDB,ios_base::in)) && "General element initialization failed");
     72  stringstream elementsDBstream(elementsDB,ios_base::in);
     73  CPPUNIT_ASSERT(tafel->LoadElementsDatabase(elementsDBstream) && "General element initialization failed");
    7074  CPPUNIT_ASSERT(tafel->LoadValenceDatabase(new stringstream(valenceDB,ios_base::in)) && "Valence entry of element initialization failed");
    7175  CPPUNIT_ASSERT(tafel->LoadOrbitalsDatabase(new stringstream(orbitalsDB,ios_base::in)) && "Orbitals entry of element initialization failed");

  • src/unittests/periodentafelTest.hpp

    r311d688 re588312  
    3131private:
    3232
    33       element *hydrogen;
    34       element *carbon;
     33      const element *hydrogen;
     34      const element *carbon;
    3535      periodentafel *tafel;
    3636
Note: See TracChangeset for help on using the changeset viewer.