Changeset e5c0a1


Ignore:
Timestamp:
Aug 6, 2010, 2:01:13 PM (15 years ago)
Author:
Tillmann Crueger <crueger@…>
Branches:
Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable
Children:
822f01
Parents:
2a76b0
Message:

Made the periodentafel return only "const element *" instead of "element * const", to avoid unexpected changes to stored elements

  • Note: returning "type * const" from a function does not make sense, since the pointer has to be copied anyway (calling convention), so the calling function can just do another copy to get a non const version of the pointer
Location:
src
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • src/Actions/AnalysisAction/PairCorrelationAction.cpp

    r2a76b0 re5c0a1  
    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

    r2a76b0 re5c0a1  
    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)
     99  for(std::vector<const element *>::iterator iter = elements.begin(); iter != elements.end(); ++iter)
    100100    cout << "element is " << (*iter)->getSymbol() << endl;
    101101  std::vector<molecule*> molecules = World::getInstance().getSelectedMolecules();

  • src/Actions/AnalysisAction/SurfaceCorrelationAction.cpp

    r2a76b0 re5c0a1  
    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

    r2a76b0 re5c0a1  
    5252
    5353Action::state_ptr AtomAddAction::performCall() {
    54   element * elemental = NULL;
     54  const element * elemental = NULL;
    5555  Vector position;
    5656

  • src/Actions/AtomAction/ChangeElementAction.cpp

    r2a76b0 re5c0a1  
    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);

  • src/Actions/MapOfActions.cpp

    r2a76b0 re5c0a1  
    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

    r2a76b0 re5c0a1  
    163163
    164164  void queryCurrentValue(const char * name, class atom * &_T);
    165   void queryCurrentValue(const char * name, class element * &_T);
     165  void queryCurrentValue(const char * name, const element * &_T);
    166166  void queryCurrentValue(const char * name, class molecule * &_T);
    167167  void queryCurrentValue(const char * name, class Box &_T);
    168168  void queryCurrentValue(const char * name, class Vector &_T);
    169169  void queryCurrentValue(const char * name, std::vector<atom *>&_T);
    170   void queryCurrentValue(const char * name, std::vector<element *>&_T);
     170  void queryCurrentValue(const char * name, std::vector<const element *>&_T);
    171171  void queryCurrentValue(const char * name, std::vector<molecule *>&_T);
    172172  template<typename T> void queryCurrentValue(const char * name, T &_T)
    … …  
    197197
    198198  void setCurrentValue(const char * name, class atom * &_T);
    199   void setCurrentValue(const char * name, class element * &_T);
     199  void setCurrentValue(const char * name, const element * &_T);
    200200  void setCurrentValue(const char * name, class molecule * &_T);
    201201  void setCurrentValue(const char * name, class Box &_T);
    202202  void setCurrentValue(const char * name, class Vector &_T);
    203203  void setCurrentValue(const char * name, std::vector<atom *>&_T);
    204   void setCurrentValue(const char * name, std::vector<element *>&_T);
     204  void setCurrentValue(const char * name, std::vector<const element *>&_T);
    205205  void setCurrentValue(const char * name, std::vector<molecule *>&_T);
    206206  template<class T> void setCurrentValue(const char * name, T &_T)

  • src/Formula.cpp

    r2a76b0 re5c0a1  
    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/UIElements/Dialog.hpp

    r2a76b0 re5c0a1  
    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

    r2a76b0 re5c0a1  
    818818}
    819819
    820 ElementQTQueryPipe::ElementQTQueryPipe(element **_content, QTDialog *_dialog, QComboBox *_theBox) :
     820ElementQTQueryPipe::ElementQTQueryPipe(const element **_content, QTDialog *_dialog, QComboBox *_theBox) :
    821821  content(_content),
    822822  dialog(_dialog),
    … …  
    834834}
    835835
    836 ElementsQTQueryPipe::ElementsQTQueryPipe(std::vector<element *>*_content, QTDialog *_dialog, QComboBox *_theBox) :
     836ElementsQTQueryPipe::ElementsQTQueryPipe(std::vector<const element *>*_content, QTDialog *_dialog, QComboBox *_theBox) :
    837837  content(_content),
    838838  dialog(_dialog),
    … …  
    846846  QVariant data = theBox->itemData(newIndex);
    847847  int idx = data.toInt();
    848   element *elemental = World::getInstance().getPeriode()->FindElement(idx);
     848  const element *elemental = World::getInstance().getPeriode()->FindElement(idx);
    849849  if(elemental)
    850850    (*content).push_back(elemental);

  • src/UIElements/QT4/QTDialog.hpp

    r2a76b0 re5c0a1  
    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

    r2a76b0 re5c0a1  
    566566  bool badInput=false;
    567567  bool aborted = false;
    568   element * temp = NULL;
     568  const element * temp = NULL;
    569569  do{
    570570    badInput = false;

  • src/analysis_correlation.cpp

    r2a76b0 re5c0a1  
    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) );
     54          PairsOfElements.insert( make_pair(*type1,*type2) );
    5555          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) );
     121          PairsOfElements.insert( make_pair(*type1,*type2) );
    122122          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

    r2a76b0 re5c0a1  
    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/periodentafel.cpp

    r2a76b0 re5c0a1  
    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();
    … …  
    8585 * \param *pointer element to be removed
    8686 */
    87 size_t periodentafel::RemoveElement(element * const pointer)
     87size_t periodentafel::RemoveElement(const element * pointer)
    8888{
    8989  return RemoveElement(pointer->getNumber());
    … …  
    113113 * \return pointer to element or NULL if not found
    114114 */
    115 element * const periodentafel::FindElement(atomicNumber_t Z) const
     115const element * periodentafel::FindElement(atomicNumber_t Z) const
    116116{
    117117  const_iterator res = elements.find(Z);
    … …  
    124124 * \return pointer to element
    125125 */
    126 element * const periodentafel::FindElement(const string &shorthand) const
     126const element * periodentafel::FindElement(const string &shorthand) const
    127127{
    128128  element *res = 0;
    … …  
    139139 * \return desired element or NULL
    140140 */
    141 element * const periodentafel::AskElement() const
    142 {
    143   element * walker = NULL;
     141const element * periodentafel::AskElement() const
     142{
     143  const element * walker = NULL;
    144144  int Z;
    145145  do {
    … …  
    154154 * \return pointer to either present or newly created element
    155155 */
    156 element * const periodentafel::EnterElement()
     156const element * periodentafel::EnterElement()
    157157{
    158158  atomicNumber_t Z = 0;
    159159  DoLog(0) && (Log() << Verbose(0) << "Atomic number: " << Z << endl);
    160160  cin >> Z;
    161   element * const res = FindElement(Z);
     161  const element *res = FindElement(Z);
    162162  if (!res) {
    163163    // TODO: make this using the constructor
    … …  
    179179
    180180/******************** Access to iterators ****************************/
    181 periodentafel::const_iterator periodentafel::begin(){
     181periodentafel::const_iterator periodentafel::begin() const{
    182182  return elements.begin();
    183183}
    184184
    185 periodentafel::const_iterator periodentafel::end(){
     185periodentafel::const_iterator periodentafel::end() const{
    186186  return elements.end();
    187187}
    188188
    189 periodentafel::reverse_iterator periodentafel::rbegin(){
     189periodentafel::reverse_iterator periodentafel::rbegin() const{
    190190  return reverse_iterator(elements.end());
    191191}
    192192
    193 periodentafel::reverse_iterator periodentafel::rend(){
     193periodentafel::reverse_iterator periodentafel::rend() const{
    194194  return reverse_iterator(elements.begin());
    195195}
    … …  
    227227  if (!input.fail())
    228228    DoLog(0) && (Log() << Verbose(0) << "Using " << filename << " as elements database." << endl);
    229   status = status && LoadElementsDatabase(&input);
     229  status = status && LoadElementsDatabase(input);
    230230  input.close();
    231231  input.clear();
    … …  
    286286 * \return true - parsing successful, false - something went wrong
    287287 */
    288 bool periodentafel::LoadElementsDatabase(istream *input)
     288bool periodentafel::LoadElementsDatabase(istream &input)
    289289{
    290290  bool status = true;
    291   int counter = 0;
    292   pair< std::map<atomicNumber_t,element*>::iterator, bool > InserterTest;
    293   if (!(*input).fail()) {
    294     (*input).getline(header1, MAXSTRINGSIZE);
    295     (*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;
    296299    DoLog(0) && (Log() << Verbose(0) <<  "Parsed elements:");
    297     while (!(*input).eof()) {
     300    while (!input.eof()) {
    298301      element *neues = new element;
    299       (*input) >> neues->getName();;
    300       //(*input) >> ws;
    301       (*input) >> neues->getSymbol();
    302       //(*input) >> ws;
    303       (*input) >> neues->period;
    304       //(*input) >> ws;
    305       (*input) >> neues->group;
    306       //(*input) >> ws;
    307       (*input) >> neues->block;
    308       //(*input) >> ws;
    309       (*input) >> neues->Z;
    310       //(*input) >> ws;
    311       (*input) >> neues->mass;
    312       //(*input) >> ws;
    313       (*input) >> neues->CovalentRadius;
    314       //(*input) >> ws;
    315       (*input) >> neues->VanDerWaalsRadius;
    316       //(*input) >> ws;
    317       (*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;
    318321      //neues->Output((ofstream *)&cout);
    319322      if ((neues->getNumber() > 0) && (neues->getNumber() < MAX_ELEMENTS)) {
    320         if (elements.count(neues->getNumber())) {// if element already present, remove and delete old one (i.e. replace it)
    321           //cout << neues->symbol << " is present already." << endl;
    322           element * const Elemental = FindElement(neues->getNumber());
    323           ASSERT(Elemental != NULL, "element should be present but is not??");
    324           *Elemental = *neues;
    325           delete(neues);
    326           neues = Elemental;
    327         } else {
    328           InserterTest = elements.insert(pair <atomicNumber_t,element*> (neues->getNumber(), neues));
    329           ASSERT(InserterTest.second, "Could not insert new element into periodentafel on LoadElementsDatabase().");
    330         }
     323        parsedElements[neues->Z] = neues;
    331324        DoLog(0) && (Log() << Verbose(0) << " " << *neues);
    332         counter++;
    333325      } else {
    334326        DoeLog(2) && (eLog() << Verbose(2) << "Detected empty line or invalid element in elements db, discarding." << endl);
    … …  
    336328        delete(neues);
    337329      }
     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      }
    338336    }
    339337    DoLog(0) && (Log() << Verbose(0) << endl);
    … …  
    343341  }
    344342
    345   if (counter == 0)
     343  if (!parsedElements.size())
    346344    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  }
    347366
    348367  return status;

  • src/periodentafel.hpp

    r2a76b0 re5c0a1  
    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

    r2a76b0 re5c0a1  
    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

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

  • src/unittests/AnalysisCorrelationToSurfaceUnitTest.hpp

    r2a76b0 re5c0a1  
    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

    r2a76b0 re5c0a1  
    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

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

  • src/unittests/periodentafelTest.cpp

    r2a76b0 re5c0a1  
    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

    r2a76b0 re5c0a1  
    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.