Changes in / [1cc87e:353e82]


Ignore:
Location:
src
Files:
32 edited

Legend:

Unmodified
Added
Removed

  • src/Actions/AnalysisAction/PairCorrelationAction.cpp

    r1cc87e r353e82  
    7575  ofstream output;
    7676  ofstream binoutput;
    77   std::vector< element *> elements;
     77  std::vector<const element *> elements;
    7878  string type;
    7979  Vector Point;

  • src/Actions/AnalysisAction/PointCorrelationAction.cpp

    r1cc87e r353e82  
    7676  ofstream output;
    7777  ofstream binoutput;
    78   std::vector< element *> elements;
     78  std::vector<const element *> elements;
    7979  string type;
    8080  Vector Point;
    … …  
    9696  cout << "Point to correlate to is  " << Point << endl;
    9797  CorrelationToPointMap *correlationmap = NULL;
    98   for(std::vector< element *>::iterator iter = elements.begin(); iter != elements.end(); ++iter)
    99     cout << "element is " << (*iter)->symbol << endl;
     98  for(std::vector<const element *>::iterator iter = elements.begin(); iter != elements.end(); ++iter)
     99    cout << "element is " << (*iter)->getSymbol() << endl;
    100100  std::vector<molecule*> molecules = World::getInstance().getSelectedMolecules();
    101101  if (periodic)

  • src/Actions/AnalysisAction/SurfaceCorrelationAction.cpp

    r1cc87e r353e82  
    7979  ofstream output;
    8080  ofstream binoutput;
    81   std::vector< element *> elements;
     81  std::vector<const element *> elements;
    8282  string type;
    8383  Vector Point;

  • src/Actions/AtomAction/AddAction.cpp

    r1cc87e r353e82  
    5252
    5353Action::state_ptr AtomAddAction::performCall() {
    54   element * elemental = NULL;
     54  const element * elemental = NULL;
    5555  Vector position;
    5656
    … …  
    6363  first->setType(elemental);
    6464  first->setPosition(position);
    65   DoLog(1) && (Log() << Verbose(1) << "Adding new atom with element " << first->getType()->name << " at " << (first->getPosition()) << "." << endl);
     65  DoLog(1) && (Log() << Verbose(1) << "Adding new atom with element " << first->getType()->getName() << " at " << (first->getPosition()) << "." << 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

    r1cc87e r353e82  
    5151Action::state_ptr AtomChangeElementAction::performCall() {
    5252  atom *first = NULL;
    53   element *elemental = NULL;
     53  const element *elemental;
    5454  molecule *mol = NULL;
    5555
    … …  
    5858  for (World::AtomSelectionIterator iter = World::getInstance().beginAtomSelection(); iter != World::getInstance().endAtomSelection(); ++iter) {
    5959    first = iter->second;
    60     DoLog(1) && (Log() << Verbose(1) << "Changing atom " << *first << " to element " << elemental->symbol << "." << endl);
     60    DoLog(1) && (Log() << Verbose(1) << "Changing atom " << *first << " to element " << *elemental << "." << endl);
    6161    mol = first->getMolecule();
    6262    first->removeFromMolecule(); // remove atom

  • src/Actions/MapOfActions.cpp

    r1cc87e r353e82  
    315315
    316316  // value types for the actions
    317   TypeMap["add-atom"] = &typeid(element);
     317  TypeMap["add-atom"] = &typeid(const element);
    318318  TypeMap["bond-file"] = &typeid(std::string);
    319319  TypeMap["bond-table"] = &typeid(std::string);
    … …  
    321321  TypeMap["center-in-box"] = &typeid(BoxValue);
    322322  TypeMap["change-box"] = &typeid(BoxValue);
    323   TypeMap["change-element"] = &typeid(element);
     323  TypeMap["change-element"] = &typeid(const element);
    324324  TypeMap["change-molname"] = &typeid(std::string);
    325325  TypeMap["clear-atom-selection"] = &typeid(void);
    … …  
    386386  TypeMap["distances"] = &typeid(VectorValue);
    387387  TypeMap["DoRotate"] = &typeid(bool);
    388   TypeMap["element"] = &typeid(element);
    389   TypeMap["elements"] = &typeid(std::vector<element *>);
     388  TypeMap["element"] = &typeid(const element);
     389  TypeMap["elements"] = &typeid(std::vector<const element *>);
    390390  TypeMap["end-step"] = &typeid(int);
    391391  TypeMap["id-mapping"] = &typeid(bool);
    … …  
    416416  TypeEnumMap[&typeid(atom)] = Atom;
    417417  TypeEnumMap[&typeid(std::vector<atom *>)] = ListOfAtoms;
    418   TypeEnumMap[&typeid(element)] = Element;
    419   TypeEnumMap[&typeid(std::vector<element *>)] = ListOfElements;
     418  TypeEnumMap[&typeid(const element)] = Element;
     419  TypeEnumMap[&typeid(std::vector<const element *>)] = ListOfElements;
    420420
    421421  // default values for any action that needs one (always string!)
    … …  
    622622}
    623623
    624 void MapOfActions::queryCurrentValue(const char * name, class element * &_T)  {
     624void MapOfActions::queryCurrentValue(const char * name, const element * &_T)  {
    625625  int Z = -1;
    626   if (typeid( element ) == *TypeMap[name]) {
     626  if (typeid(const element ) == *TypeMap[name]) {
    627627    if (CurrentValue.find(name) == CurrentValue.end())
    628628      throw MissingValueException(__FILE__, __LINE__);
    … …  
    706706}
    707707
    708 void MapOfActions::queryCurrentValue(const char * name, std::vector<element *>&_T)
     708void MapOfActions::queryCurrentValue(const char * name, std::vector<const element *>&_T)
    709709{
    710710  int Z = -1;
    711   element *elemental = NULL;
    712   if (typeid( std::vector<element *> ) == *TypeMap[name]) {
     711  const element *elemental = NULL;
     712  if (typeid( std::vector<const element *> ) == *TypeMap[name]) {
    713713    if (CurrentValue.find(name) == CurrentValue.end())
    714714      throw MissingValueException(__FILE__, __LINE__);
    … …  
    758758}
    759759
    760 void MapOfActions::setCurrentValue(const char * name, class element * &_T)
    761 {
    762   if (typeid( element ) == *TypeMap[name]) {
     760void MapOfActions::setCurrentValue(const char * name, const element * &_T)
     761{
     762  if (typeid(const element ) == *TypeMap[name]) {
    763763    std::ostringstream stream;
    764764    stream << _T->Z;
    … …  
    818818}
    819819
    820 void MapOfActions::setCurrentValue(const char * name, std::vector<element *>&_T)
    821 {
    822   if (typeid( std::vector<element *> ) == *TypeMap[name]) {
     820void MapOfActions::setCurrentValue(const char * name, std::vector<const element *>&_T)
     821{
     822  if (typeid( std::vector<const element *> ) == *TypeMap[name]) {
    823823    std::ostringstream stream;
    824     for (std::vector<element *>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
     824    for (std::vector<const element *>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
    825825      stream << (*iter)->Z << " ";
    826826    }

  • src/Actions/MapOfActions.hpp

    r1cc87e r353e82  
    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

    r1cc87e r353e82  
    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

    r1cc87e r353e82  
    540540    const element * const elemental = World::getInstance().getPeriode()->FindElement(iter->first);
    541541    ZtoIndexMap.insert( pair<int,int> (iter->first, counter) );
    542     *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;
     542    *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;
    543543  }
    544544}

  • src/Parser/XyzParser.cpp

    r1cc87e r353e82  
    8686  vector<atom*> atoms = World::getInstance().getAllAtoms();
    8787  for(vector<atom*>::iterator it = atoms.begin(); it != atoms.end(); it++) {
    88     *file << noshowpoint << (*it)->getType()->symbol << "\t" << (*it)->at(0) << "\t" << (*it)->at(1) << "\t" << (*it)->at(2) << endl;
     88    *file << noshowpoint << (*it)->getType()->getSymbol() << "\t" << (*it)->at(0) << "\t" << (*it)->at(1) << "\t" << (*it)->at(2) << endl;
    8989  }
    9090}

  • src/UIElements/Dialog.hpp

    r1cc87e r353e82  
    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

    r1cc87e r353e82  
    554554  {
    555555    stringstream sstr;
    556     sstr << (*iter).first << "\t" << (*iter).second->name;
     556    sstr << (*iter).first << "\t" << (*iter).second->getName();
    557557    inputBox->addItem(QString(sstr.str().c_str()),QVariant((*iter).first));
    558558  }
    … …  
    589589  {
    590590    stringstream sstr;
    591     sstr << (*iter).first << "\t" << (*iter).second->name;
     591    sstr << (*iter).first << "\t" << (*iter).second->getName();
    592592    inputBox->addItem(QString(sstr.str().c_str()),QVariant((*iter).first));
    593593  }
    … …  
    816816}
    817817
    818 ElementQTQueryPipe::ElementQTQueryPipe(element **_content, QTDialog *_dialog, QComboBox *_theBox) :
     818ElementQTQueryPipe::ElementQTQueryPipe(const element **_content, QTDialog *_dialog, QComboBox *_theBox) :
    819819  content(_content),
    820820  dialog(_dialog),
    … …  
    832832}
    833833
    834 ElementsQTQueryPipe::ElementsQTQueryPipe(std::vector<element *>*_content, QTDialog *_dialog, QComboBox *_theBox) :
     834ElementsQTQueryPipe::ElementsQTQueryPipe(std::vector<const element *>*_content, QTDialog *_dialog, QComboBox *_theBox) :
    835835  content(_content),
    836836  dialog(_dialog),
    … …  
    844844  QVariant data = theBox->itemData(newIndex);
    845845  int idx = data.toInt();
    846   element *elemental = World::getInstance().getPeriode()->FindElement(idx);
     846  const element *elemental = World::getInstance().getPeriode()->FindElement(idx);
    847847  if(elemental)
    848848    (*content).push_back(elemental);

  • src/UIElements/QT4/QTDialog.hpp

    r1cc87e r353e82  
    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

    r1cc87e r353e82  
    569569  bool badInput=false;
    570570  bool aborted = false;
    571   element * temp = NULL;
     571  const element * temp = NULL;
    572572  do{
    573573    badInput = false;

  • src/analysis_bonds.cpp

    r1cc87e r353e82  
    215215          if (((OtherAtom->getType() == first) || (OtherAtom->getType() == 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

    r1cc87e r353e82  
    3333 * \return Map of doubles with values the pair of the two atoms.
    3434 */
    35 PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements)
     35PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<const element *> &elements)
    3636{
    3737  Info FunctionInfo(__func__);
    … …  
    4848
    4949  // create all possible pairs of elements
    50   set <pair<element *, element *> > PairsOfElements;
     50  set <pair<const element *,const element *> > PairsOfElements;
    5151  if (elements.size() >= 2) {
    52     for (vector<element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
    53       for (vector<element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
     52    for (vector<const element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
     53      for (vector<const element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
    5454        if (type1 != type2) {
    55           PairsOfElements.insert( pair<element *, element*>(*type1,*type2) );
    56           DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << (*type1)->symbol << " and " << (*type2)->symbol << "." << endl);
     55          PairsOfElements.insert( make_pair(*type1,*type2) );
     56          DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << *(*type1) << " and " << *(*type2) << "." << endl);
    5757        }
    5858  } else if (elements.size() == 1) { // one to all are valid
    59     element *elemental = *elements.begin();
    60     PairsOfElements.insert( pair<element *, element*>(elemental,(element *)NULL) );
    61     PairsOfElements.insert( pair<element *, element*>((element *)NULL,elemental) );
     59    const element *elemental = *elements.begin();
     60    PairsOfElements.insert( pair<const element *,const element*>(elemental,0) );
     61    PairsOfElements.insert( pair<const element *,const element*>(0,elemental) );
    6262  } else { // all elements valid
    6363    PairsOfElements.insert( pair<element *, element*>((element *)NULL, (element *)NULL) );
    … …  
    7474          DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
    7575          if ((*iter)->getId() < (*runner)->getId()){
    76             for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
     76            for (set <pair<const element *, const element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
    7777              if ((PairRunner->first == (**iter).getType()) && (PairRunner->second == (**runner).getType())) {
    7878                distance = domain.periodicDistance((*iter)->getPosition(),(*runner)->getPosition());
    … …  
    9595 * \return Map of doubles with values the pair of the two atoms.
    9696 */
    97 PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const int ranges[NDIM] )
     97PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const int ranges[NDIM] )
    9898{
    9999  Info FunctionInfo(__func__);
    … …  
    115115
    116116  // create all possible pairs of elements
    117   set <pair<element *, element *> > PairsOfElements;
     117  set <pair<const element *,const element *> > PairsOfElements;
    118118  if (elements.size() >= 2) {
    119     for (vector<element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
    120       for (vector<element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
     119    for (vector<const element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
     120      for (vector<const element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
    121121        if (type1 != type2) {
    122           PairsOfElements.insert( pair<element *, element*>(*type1,*type2) );
    123           DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << (*type1)->symbol << " and " << (*type2)->symbol << "." << endl);
     122          PairsOfElements.insert( make_pair(*type1,*type2) );
     123          DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << *(*type1) << " and " << *(*type2) << "." << endl);
    124124        }
    125125  } else if (elements.size() == 1) { // one to all are valid
    126     element *elemental = *elements.begin();
    127     PairsOfElements.insert( pair<element *, element*>(elemental,(element *)NULL) );
    128     PairsOfElements.insert( pair<element *, element*>((element *)NULL,elemental) );
     126    const element *elemental = *elements.begin();
     127    PairsOfElements.insert( pair<const element *,const element*>(elemental,0) );
     128    PairsOfElements.insert( pair<const element *,const element*>(0,elemental) );
    129129  } else { // all elements valid
    130130    PairsOfElements.insert( pair<element *, element*>((element *)NULL, (element *)NULL) );
    … …  
    149149                  DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
    150150                  if ((*iter)->getId() < (*runner)->getId()){
    151                     for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
     151                    for (set <pair<const element *,const element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
    152152                      if ((PairRunner->first == (**iter).getType()) && (PairRunner->second == (**runner).getType())) {
    153153                        periodicOtherX = FullInverseMatrix * ((*runner)->getPosition()); // x now in [0,1)^3
    … …  
    178178 * \return Map of dobules with values as pairs of atom and the vector
    179179 */
    180 CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point )
     180CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Vector *point )
    181181{
    182182  Info FunctionInfo(__func__);
    … …  
    196196    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    197197      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
    198       for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
     198      for (vector<const element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
    199199        if ((*type == NULL) || ((*iter)->getType() == *type)) {
    200200          distance = domain.periodicDistance((*iter)->getPosition(),*point);
    … …  
    215215 * \return Map of dobules with values as pairs of atom and the vector
    216216 */
    217 CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] )
     217CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Vector *point, const int ranges[NDIM] )
    218218{
    219219  Info FunctionInfo(__func__);
    … …  
    237237    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    238238      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
    239       for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
     239      for (vector<const element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
    240240        if ((*type == NULL) || ((*iter)->getType() == *type)) {
    241241          periodicX = FullInverseMatrix * ((*iter)->getPosition()); // x now in [0,1)^3
    … …  
    263263 * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
    264264 */
    265 CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC )
     265CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Tesselation * const Surface, const LinkedCell *LC )
    266266{
    267267  Info FunctionInfo(__func__);
    … …  
    284284    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    285285      DoLog(3) && (Log() << Verbose(3) << "\tCurrent atom is " << *(*iter) << "." << endl);
    286       for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
     286      for (vector<const element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
    287287        if ((*type == NULL) || ((*iter)->getType() == *type)) {
    288288          TriangleIntersectionList Intersections((*iter)->getPosition(),Surface,LC);
    … …  
    309309 * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
    310310 */
    311 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
     311CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<const element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
    312312{
    313313  Info FunctionInfo(__func__);
    … …  
    335335    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    336336      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
    337       for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
     337      for (vector<const element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
    338338        if ((*type == NULL) || ((*iter)->getType() == *type)) {
    339339          periodicX = FullInverseMatrix * ((*iter)->getPosition()); // x now in [0,1)^3

  • src/analysis_correlation.hpp

    r1cc87e r353e82  
    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

    r1cc87e r353e82  
    194194{
    195195  if (out != NULL) {
    196     *out << getType()->symbol << "\t" << at(0) << "\t" << at(1) << "\t" << at(2) << "\t" << endl;
     196    *out << getType()->getSymbol() << "\t" << at(0) << "\t" << at(1) << "\t" << at(2) << "\t" << endl;
    197197    return true;
    198198  } else
    … …  
    232232{
    233233  if (out != NULL) {
    234     *out << getType()->symbol << "\t";
     234    *out << getType()->getSymbol() << "\t";
    235235    *out << Trajectory.R.at(step)[0] << "\t";
    236236    *out << Trajectory.R.at(step)[1] << "\t";
    … …  
    250250  Vector recentered(getPosition());
    251251  recentered -= *center;
    252   *out << "\t\t" << getType()->symbol << " [ " << recentered[0] << "\t" << recentered[1] << "\t" << recentered[2] << " ]" << endl;
     252  *out << "\t\t" << getType()->getSymbol() << " [ " << recentered[0] << "\t" << recentered[1] << "\t" << recentered[2] << " ]" << endl;
    253253  if (AtomNo != NULL)
    254254    *AtomNo++;

  • src/config.cpp

    r1cc87e r353e82  
    13391339    AtomNo = 0;
    13401340    for (molecule::const_iterator iter = (*MolRunner)->begin(); iter != (*MolRunner)->end(); ++iter) {
    1341       sprintf(name, "%2s%2d",(*iter)->getType()->symbol, elementNo[(*iter)->getType()->Z]);
     1341      sprintf(name, "%2s%2d",(*iter)->getType()->getSymbol().c_str(), elementNo[(*iter)->getType()->Z]);
    13421342      elementNo[(*iter)->getType()->Z] = (elementNo[(*iter)->getType()->Z]+1) % 100;   // confine to two digits
    13431343      fprintf(f,
    … …  
    13541354             (double)(*iter)->getType()->NoValenceOrbitals,          /* temperature factor */
    13551355             "0",            /* segment identifier */
    1356              (*iter)->getType()->symbol,    /* element symbol */
     1356             (*iter)->getType()->getSymbol().c_str(),    /* element symbol */
    13571357             "0");           /* charge */
    13581358      AtomNo++;
    … …  
    13921392  AtomNo = 0;
    13931393  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    1394     sprintf(name, "%2s%2d",(*iter)->getType()->symbol, elementNo[(*iter)->getType()->Z]);
     1394    sprintf(name, "%2s%2d",(*iter)->getType()->getSymbol().c_str(), elementNo[(*iter)->getType()->Z]);
    13951395    elementNo[(*iter)->getType()->Z] = (elementNo[(*iter)->getType()->Z]+1) % 100;   // confine to two digits
    13961396    fprintf(f,
    … …  
    14071407           (double)(*iter)->getType()->NoValenceOrbitals,          /* temperature factor */
    14081408           "0",            /* segment identifier */
    1409            (*iter)->getType()->symbol,    /* element symbol */
     1409           (*iter)->getType()->getSymbol().c_str(),    /* element symbol */
    14101410           "0");           /* charge */
    14111411    AtomNo++;
    … …  
    14521452    *output << (*iter)->at(0) << "\t" << (*iter)->at(1) << "\t" << (*iter)->at(2) << "\t";
    14531453    *output << static_cast<double>((*iter)->getType()->Valence) << "\t";
    1454     *output << (*iter)->getType()->symbol << "\t";
     1454    *output << (*iter)->getType()->getSymbol() << "\t";
    14551455    for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
    14561456      *output << (*runner)->GetOtherAtom(*iter)->nr << "\t";
    … …  
    15241524        *output << (*iter)->at(0) << "\t" << (*iter)->at(1) << "\t" << (*iter)->at(2) << "\t";
    15251525        *output << (double)(*iter)->getType()->Valence << "\t";
    1526         *output << (*iter)->getType()->symbol << "\t";
     1526        *output << (*iter)->getType()->getSymbol() << "\t";
    15271527        for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
    15281528          *output << LocalNotoGlobalNoMap[ (*runner)->GetOtherAtom((*iter))->getId() ] << "\t";

  • src/element.cpp

    r1cc87e r353e82  
    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

    r1cc87e r353e82  
    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

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

  • src/molecule.hpp

    r1cc87e r353e82  
    324324
    325325  // Recognize doubly appearing molecules in a list of them
    326   int * IsEqualToWithinThreshold(molecule *OtherMolecule, double threshold);
    327326  int * GetFatherSonAtomicMap(molecule *OtherMolecule);
    328327

  • src/periodentafel.cpp

    r1cc87e r353e82  
    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

    r1cc87e r353e82  
    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

    r1cc87e r353e82  
    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

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

  • src/unittests/AnalysisCorrelationToSurfaceUnitTest.hpp

    r1cc87e r353e82  
    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

    r1cc87e r353e82  
    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

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

  • src/unittests/periodentafelTest.cpp

    r1cc87e r353e82  
    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

    r1cc87e r353e82  
    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.