Changeset cca9ef for src


Ignore:
Timestamp:
Dec 4, 2010, 11:54:32 PM (14 years ago)
Author:
Frederik Heber <heber@…>
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:
0d4424
Parents:
3bc926
git-author:
Frederik Heber <heber@…> (11/15/10 12:58:27)
git-committer:
Frederik Heber <heber@…> (12/04/10 23:54:32)
Message:

Renamed Matrix to RealSpaceMatrix.

  • class Matrix only represents 3x3 matrices, whereas we are now going to extend the class MatrixContent to contain arbritrary dimensions.
  • renamed class and file
Location:
src
Files:
45 edited
2 moved

Legend:

Unmodified
Added
Removed

  • src/Actions/AnalysisAction/PrincipalAxisSystemAction.cpp

    r3bc926 rcca9ef  
    2222#include "Helpers/Log.hpp"
    2323#include "Helpers/Verbose.hpp"
    24 #include "LinearAlgebra/Matrix.hpp"
     24#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2525#include "LinearAlgebra/Vector.hpp"
    2626#include "element.hpp"
    … …  
    4040/** =========== define the function ====================== */
    4141Action::state_ptr AnalysisPrincipalAxisSystemAction::performCall() {
    42   Matrix InertiaTensor;
     42  RealSpaceMatrix InertiaTensor;
    4343
    4444  DoLog(0) && (Log() << Verbose(0) << "Evaluating prinicipal axis." << endl);

  • src/Actions/MoleculeAction/RotateToPrincipalAxisSystemAction.cpp

    r3bc926 rcca9ef  
    2323#include "Helpers/Verbose.hpp"
    2424#include "LinearAlgebra/Line.hpp"
    25 #include "LinearAlgebra/Matrix.hpp"
     25#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2626#include "LinearAlgebra/Vector.hpp"
    2727#include "element.hpp"
    … …  
    5050    mol = iter->second;
    5151    DoLog(0) && (Log() << Verbose(0) << "Converting to prinicipal axis system." << endl);
    52     Matrix InertiaTensor;
     52    RealSpaceMatrix InertiaTensor;
    5353    Vector *CenterOfGravity = mol->DetermineCenterOfGravity();
    5454

  • src/Actions/SelectionAction/AllAtomsInsideCuboidAction.cpp

    r3bc926 rcca9ef  
    2525#include "Helpers/Log.hpp"
    2626#include "Helpers/Verbose.hpp"
    27 #include "LinearAlgebra/Matrix.hpp"
     27#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2828#include "LinearAlgebra/Vector.hpp"
    2929#include "Shapes/BaseShapes.hpp"
    … …  
    4545Action::state_ptr SelectionAllAtomsInsideCuboidAction::performCall() {
    4646  std::vector<atom *> selectedAtoms = World::getInstance().getSelectedAtoms();
    47   Matrix RotationMatrix;
     47  RealSpaceMatrix RotationMatrix;
    4848
    4949  // obtain information
    … …  
    7070Action::state_ptr SelectionAllAtomsInsideCuboidAction::performRedo(Action::state_ptr _state){
    7171  SelectionAllAtomsInsideCuboidState *state = assert_cast<SelectionAllAtomsInsideCuboidState*>(_state.get());
    72   Matrix RotationMatrix;
     72  RealSpaceMatrix RotationMatrix;
    7373
    7474  RotationMatrix.setRotation(state->params.Xangle, state->params.Yangle, state->params.Zangle);

  • src/Actions/SelectionAction/NotAllAtomsInsideCuboidAction.cpp

    r3bc926 rcca9ef  
    2525#include "Helpers/Log.hpp"
    2626#include "Helpers/Verbose.hpp"
    27 #include "LinearAlgebra/Matrix.hpp"
     27#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2828#include "LinearAlgebra/Vector.hpp"
    2929#include "Shapes/BaseShapes.hpp"
    … …  
    4545Action::state_ptr SelectionNotAllAtomsInsideCuboidAction::performCall() {
    4646  std::vector<atom *> selectedAtoms = World::getInstance().getSelectedAtoms();
    47   Matrix RotationMatrix;
     47  RealSpaceMatrix RotationMatrix;
    4848
    4949  // obtain information
    … …  
    7070Action::state_ptr SelectionNotAllAtomsInsideCuboidAction::performRedo(Action::state_ptr _state){
    7171  SelectionNotAllAtomsInsideCuboidState *state = assert_cast<SelectionNotAllAtomsInsideCuboidState*>(_state.get());
    72   Matrix RotationMatrix;
     72  RealSpaceMatrix RotationMatrix;
    7373
    7474  RotationMatrix.setRotation(state->params.Xangle, state->params.Yangle, state->params.Zangle);

  • src/Actions/ValueStorage.cpp

    r3bc926 rcca9ef  
    3131#include "Helpers/Verbose.hpp"
    3232#include "LinearAlgebra/BoxVector.hpp"
    33 #include "LinearAlgebra/Matrix.hpp"
     33#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3434#include "LinearAlgebra/Vector.hpp"
    3535#include "atom.hpp"
    … …  
    9595
    9696void ValueStorage::queryCurrentValue(const char * name, class Box &_T) {
    97   Matrix M;
     97  RealSpaceMatrix M;
    9898  double tmp;
    9999  if (typeid( Box ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
    … …  
    254254void ValueStorage::setCurrentValue(const char * name, class Box &_T)
    255255{
    256   const Matrix &M = _T.getM();
     256  const RealSpaceMatrix &M = _T.getM();
    257257  if (typeid( Box ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
    258258    std::ostringstream stream;

  • src/Actions/WorldAction/CenterOnEdgeAction.cpp

    r3bc926 rcca9ef  
    2424#include "LinearAlgebra/Vector.hpp"
    2525#include "World.hpp"
    26 #include "LinearAlgebra/Matrix.hpp"
     26#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2727
    2828#include <iostream>
    … …  
    5959  }
    6060  // set new box size
    61   Matrix domain;
     61  RealSpaceMatrix domain;
    6262  for (int i=0;i<NDIM;i++) {
    6363    double tmp = Max[i]-Min[i];

  • src/Actions/WorldAction/ChangeBoxAction.cpp

    r3bc926 rcca9ef  
    2424#include "World.hpp"
    2525#include "Box.hpp"
    26 #include "LinearAlgebra/Matrix.hpp"
     26#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2727
    2828#include <iostream>

  • src/Actions/WorldAction/RepeatBoxAction.cpp

    r3bc926 rcca9ef  
    2525#include "molecule.hpp"
    2626#include "LinearAlgebra/Vector.hpp"
    27 #include "LinearAlgebra/Matrix.hpp"
     27#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2828#include "Helpers/Verbose.hpp"
    2929#include "World.hpp"
    … …  
    6363
    6464  (cout << "Repeating box " << params.Repeater << " times for (x,y,z) axis." << endl);
    65   Matrix M = World::getInstance().getDomain().getM();
    66   Matrix newM = M;
     65  RealSpaceMatrix M = World::getInstance().getDomain().getM();
     66  RealSpaceMatrix newM = M;
    6767  Vector x,y;
    6868  int n[NDIM];
    69   Matrix repMat;
     69  RealSpaceMatrix repMat;
    7070  for (int axis = 0; axis < NDIM; axis++) {
    7171    params.Repeater[axis] = floor(params.Repeater[axis]);

  • src/Actions/WorldAction/ScaleBoxAction.cpp

    r3bc926 rcca9ef  
    2626#include "World.hpp"
    2727#include "Box.hpp"
    28 #include "LinearAlgebra/Matrix.hpp"
     28#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2929
    3030#include <iostream>
    … …  
    5353  }
    5454
    55   Matrix M = World::getInstance().getDomain().getM();
    56   Matrix scale;
     55  RealSpaceMatrix M = World::getInstance().getDomain().getM();
     56  RealSpaceMatrix scale;
    5757
    5858  for (int i=0;i<NDIM;i++) {

  • src/Box.cpp

    r3bc926 rcca9ef  
    2626#include <cstdlib>
    2727
    28 #include "LinearAlgebra/Matrix.hpp"
     28#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2929#include "LinearAlgebra/Vector.hpp"
    3030#include "LinearAlgebra/Plane.hpp"
    … …  
    3838Box::Box()
    3939{
    40   M= new Matrix();
     40  M= new RealSpaceMatrix();
    4141  M->setIdentity();
    42   Minv = new Matrix();
     42  Minv = new RealSpaceMatrix();
    4343  Minv->setIdentity();
    4444  conditions.resize(3);
    … …  
    4747
    4848Box::Box(const Box& src){
    49   M=new Matrix(*src.M);
    50   Minv = new Matrix(*src.Minv);
     49  M=new RealSpaceMatrix(*src.M);
     50  Minv = new RealSpaceMatrix(*src.Minv);
    5151  conditions = src.conditions;
    5252}
    … …  
    5858}
    5959
    60 const Matrix &Box::getM() const{
     60const RealSpaceMatrix &Box::getM() const{
    6161  return *M;
    6262}
    63 const Matrix &Box::getMinv() const{
     63const RealSpaceMatrix &Box::getMinv() const{
    6464  return *Minv;
    6565}
    6666
    67 void Box::setM(Matrix _M){
     67void Box::setM(RealSpaceMatrix _M){
    6868  ASSERT(_M.determinant()!=0,"Matrix in Box construction was not invertible");
    6969  *M    =_M;
    … …  
    264264    delete M;
    265265    delete Minv;
    266     M    = new Matrix(*src.M);
    267     Minv = new Matrix(*src.Minv);
     266    M    = new RealSpaceMatrix(*src.M);
     267    Minv = new RealSpaceMatrix(*src.Minv);
    268268    conditions = src.conditions;
    269269  }
    … …  
    271271}
    272272
    273 Box &Box::operator=(const Matrix &mat){
     273Box &Box::operator=(const RealSpaceMatrix &mat){
    274274  setM(mat);
    275275  return *this;

  • src/Box.hpp

    r3bc926 rcca9ef  
    99#define BOX_HPP_
    1010
    11 class Matrix;
     11class RealSpaceMatrix;
    1212class Vector;
    1313class Shape;
    … …  
    4444   * Get the matrix describing the form of the parallelepiped
    4545   */
    46   const Matrix &getM() const;
     46  const RealSpaceMatrix &getM() const;
    4747
    4848  /**
    4949   * Get the inverse of the matrix M (see above).
    5050   */
    51   const Matrix &getMinv() const;
     51  const RealSpaceMatrix &getMinv() const;
    5252
    5353  /**
    5454   * Set the form of the parallelepiped.
    5555   */
    56   void setM(Matrix);
     56  void setM(RealSpaceMatrix);
    5757
    5858  Box &operator=(const Box&);
    59   Box &operator=(const Matrix&);
     59  Box &operator=(const RealSpaceMatrix&);
    6060
    6161  /**
    … …  
    110110private:
    111111  Conditions_t conditions;
    112   Matrix *M;    //!< Defines the layout of the box
    113   Matrix *Minv; //!< Inverse of M to avoid recomputation
     112  RealSpaceMatrix *M;    //!< Defines the layout of the box
     113  RealSpaceMatrix *Minv; //!< Inverse of M to avoid recomputation
    114114};
    115115

  • src/LinearAlgebra/Makefile.am

    r3bc926 rcca9ef  
    1818  LineSegmentSet.cpp \
    1919  linearsystemofequations.cpp \
    20   Matrix.cpp \
    2120  MatrixContent.cpp \
    2221  Plane.cpp \
     22  RealSpaceMatrix.cpp \
    2323  Space.cpp \
    2424  vector_ops.cpp \
    … …  
    3434  LineSegmentSet.hpp \
    3535  linearsystemofequations.hpp \
    36   Matrix.hpp \
    3736  MatrixContent.hpp \
     37  RealSpaceMatrix.hpp \
    3838  Plane.hpp \
    3939  Space.hpp \

  • src/LinearAlgebra/MatrixContent.cpp

    r3bc926 rcca9ef  
    1414#include "Helpers/MemDebug.hpp"
    1515
    16 #include "LinearAlgebra/Matrix.hpp"
     16#include "LinearAlgebra/RealSpaceMatrix.hpp"
    1717#include "Helpers/Assert.hpp"
    1818#include "Exceptions/NotInvertibleException.hpp"

  • src/LinearAlgebra/MatrixContent.hpp

    r3bc926 rcca9ef  
    4040{
    4141  friend Vector operator*(const MatrixContent &mat,const Vector &vec);
    42   friend class Matrix;
     42  friend class RealSpaceMatrix;
    4343public:
    4444  MatrixContent(size_t rows, size_t columns);

  • src/LinearAlgebra/RealSpaceMatrix.cpp

    r3bc926 rcca9ef  
    77
    88/*
    9  * Matrix.cpp
     9 * RealSpaceMatrix.cpp
    1010 *
    1111 *  Created on: Jun 25, 2010
    … …  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "LinearAlgebra/Matrix.hpp"
     22#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2323#include "Helpers/Assert.hpp"
    2424#include "Exceptions/NotInvertibleException.hpp"
    … …  
    3939using namespace std;
    4040
    41 Matrix::Matrix()
     41RealSpaceMatrix::RealSpaceMatrix()
    4242{
    4343  content = new MatrixContent(NDIM, NDIM);
    … …  
    4545}
    4646
    47 Matrix::Matrix(const double* src)
     47RealSpaceMatrix::RealSpaceMatrix(const double* src)
    4848{
    4949  content = new MatrixContent(NDIM, NDIM, src);
    … …  
    5151}
    5252
    53 Matrix::Matrix(const Matrix &src)
     53RealSpaceMatrix::RealSpaceMatrix(const RealSpaceMatrix &src)
    5454{
    5555  content = new MatrixContent(src.content);
    … …  
    5757}
    5858
    59 Matrix::Matrix(const MatrixContent &src)
     59RealSpaceMatrix::RealSpaceMatrix(const MatrixContent &src)
    6060{
    6161  content = new MatrixContent(src);
    … …  
    6363}
    6464
    65 Matrix::Matrix(MatrixContent* _content)
     65RealSpaceMatrix::RealSpaceMatrix(MatrixContent* _content)
    6666{
    6767  content = new MatrixContent(_content);
    … …  
    6969}
    7070
    71 Matrix::~Matrix()
     71RealSpaceMatrix::~RealSpaceMatrix()
    7272{
    7373  // delete all views
    … …  
    8282}
    8383
    84 void Matrix::createViews(){
     84void RealSpaceMatrix::createViews(){
    8585  // create row views
    8686  for(int i=NDIM;i--;){
    … …  
    9898}
    9999
    100 void Matrix::setIdentity(){
     100void RealSpaceMatrix::setIdentity(){
    101101  content->setIdentity();
    102102}
    103103
    104 void Matrix::setZero(){
     104void RealSpaceMatrix::setZero(){
    105105  content->setZero();
    106106}
    107107
    108 void Matrix::setRotation(const double x, const double y, const double z)
     108void RealSpaceMatrix::setRotation(const double x, const double y, const double z)
    109109{
    110110  set(0,0, cos(y)*cos(z));
    … …  
    119119}
    120120
    121 Matrix &Matrix::operator=(const Matrix &src)
     121RealSpaceMatrix &RealSpaceMatrix::operator=(const RealSpaceMatrix &src)
    122122{
    123123  // MatrixContent checks for self-assignment
    … …  
    126126}
    127127
    128 const Matrix &Matrix::operator+=(const Matrix &rhs)
     128const RealSpaceMatrix &RealSpaceMatrix::operator+=(const RealSpaceMatrix &rhs)
    129129{
    130130  *content += *(rhs.content);
    … …  
    132132}
    133133
    134 const Matrix &Matrix::operator-=(const Matrix &rhs)
     134const RealSpaceMatrix &RealSpaceMatrix::operator-=(const RealSpaceMatrix &rhs)
    135135{
    136136  *content -= *(rhs.content);
    … …  
    138138}
    139139
    140 const Matrix &Matrix::operator*=(const Matrix &rhs)
     140const RealSpaceMatrix &RealSpaceMatrix::operator*=(const RealSpaceMatrix &rhs)
    141141{
    142142  (*content) *= (*rhs.content);
    … …  
    144144}
    145145
    146 const Matrix Matrix::operator+(const Matrix &rhs) const
    147 {
    148   Matrix tmp = *this;
     146const RealSpaceMatrix RealSpaceMatrix::operator+(const RealSpaceMatrix &rhs) const
     147{
     148  RealSpaceMatrix tmp = *this;
    149149  tmp+=rhs;
    150150  return tmp;
    151151}
    152152
    153 const Matrix Matrix::operator-(const Matrix &rhs) const
    154 {
    155   Matrix tmp = *this;
     153const RealSpaceMatrix RealSpaceMatrix::operator-(const RealSpaceMatrix &rhs) const
     154{
     155  RealSpaceMatrix tmp = *this;
    156156  tmp-=rhs;
    157157  return tmp;
    158158}
    159159
    160 const Matrix Matrix::operator*(const Matrix &rhs) const
    161 {
    162   Matrix tmp(content);
     160const RealSpaceMatrix RealSpaceMatrix::operator*(const RealSpaceMatrix &rhs) const
     161{
     162  RealSpaceMatrix tmp(content);
    163163  tmp *= rhs;
    164164  return tmp;
    165165}
    166166
    167 double &Matrix::at(size_t i, size_t j)
     167double &RealSpaceMatrix::at(size_t i, size_t j)
    168168{
    169169  return content->at(i,j);
    170170}
    171171
    172 const double Matrix::at(size_t i, size_t j) const
     172const double RealSpaceMatrix::at(size_t i, size_t j) const
    173173{
    174174  return content->at(i,j);
    175175}
    176176
    177 Vector &Matrix::row(size_t i)
     177Vector &RealSpaceMatrix::row(size_t i)
    178178{
    179179  ASSERT(i>=0&&i<NDIM,"Index i for Matrix access out of range");
    … …  
    181181}
    182182
    183 const Vector &Matrix::row(size_t i) const
     183const Vector &RealSpaceMatrix::row(size_t i) const
    184184{
    185185  ASSERT(i>=0&&i<NDIM,"Index i for Matrix access out of range");
    … …  
    187187}
    188188
    189 Vector &Matrix::column(size_t i)
     189Vector &RealSpaceMatrix::column(size_t i)
    190190{
    191191  ASSERT(i>=0&&i<NDIM,"Index i for Matrix access out of range");
    … …  
    193193}
    194194
    195 const Vector &Matrix::column(size_t i) const
     195const Vector &RealSpaceMatrix::column(size_t i) const
    196196{
    197197  ASSERT(i>=0&&i<NDIM,"Index i for Matrix access out of range");
    … …  
    199199}
    200200
    201 Vector &Matrix::diagonal()
     201Vector &RealSpaceMatrix::diagonal()
    202202{
    203203  return *diagonal_ptr;
    204204}
    205205
    206 const Vector &Matrix::diagonal() const
     206const Vector &RealSpaceMatrix::diagonal() const
    207207{
    208208  return *diagonal_ptr;
    209209}
    210210
    211 void Matrix::set(size_t i, size_t j, const double value)
     211void RealSpaceMatrix::set(size_t i, size_t j, const double value)
    212212{
    213213  content->set(i,j, value);
    214214}
    215215
    216 double Matrix::determinant() const{
     216double RealSpaceMatrix::determinant() const{
    217217  return at(0,0)*at(1,1)*at(2,2)
    218218       + at(0,1)*at(1,2)*at(2,0)
    … …  
    224224
    225225
    226 Matrix Matrix::invert() const{
     226RealSpaceMatrix RealSpaceMatrix::invert() const{
    227227  double det = determinant();
    228228  if(fabs(det)<MYEPSILON){
    … …  
    231231
    232232  double detReci = 1./det;
    233   Matrix res;
     233  RealSpaceMatrix res;
    234234  res.set(0,0,  detReci*RDET2(at(1,1),at(2,1),at(1,2),at(2,2)));    // A_11
    235235  res.set(1,0, -detReci*RDET2(at(1,0),at(2,0),at(1,2),at(2,2)));    // A_21
    … …  
    244244}
    245245
    246 Matrix Matrix::transpose() const
     246RealSpaceMatrix RealSpaceMatrix::transpose() const
    247247{
    248248  std::cout << "const Matrix::transpose()." << std::endl;
    249   Matrix res = Matrix(const_cast<const MatrixContent *>(content)->transpose());
     249  RealSpaceMatrix res = RealSpaceMatrix(const_cast<const MatrixContent *>(content)->transpose());
    250250  return res;
    251251}
    252252
    253 Matrix &Matrix::transpose()
     253RealSpaceMatrix &RealSpaceMatrix::transpose()
    254254{
    255255  std::cout << "Matrix::transpose()." << std::endl;
    … …  
    258258}
    259259
    260 Vector Matrix::transformToEigenbasis()
     260Vector RealSpaceMatrix::transformToEigenbasis()
    261261{
    262262  gsl_vector *eval = content->transformToEigenbasis();
    … …  
    266266}
    267267
    268 const Matrix &Matrix::operator*=(const double factor)
     268const RealSpaceMatrix &RealSpaceMatrix::operator*=(const double factor)
    269269    {
    270270  *content *= factor;
    … …  
    272272}
    273273
    274 const Matrix operator*(const double factor,const Matrix& mat)
    275 {
    276   Matrix tmp = mat;
     274const RealSpaceMatrix operator*(const double factor,const RealSpaceMatrix& mat)
     275{
     276  RealSpaceMatrix tmp = mat;
    277277  return tmp *= factor;
    278278}
    279279
    280 const Matrix operator*(const Matrix &mat,const double factor)
     280const RealSpaceMatrix operator*(const RealSpaceMatrix &mat,const double factor)
    281281{
    282282  return factor*mat;
    283283}
    284284
    285 bool Matrix::operator==(const Matrix &rhs) const
     285bool RealSpaceMatrix::operator==(const RealSpaceMatrix &rhs) const
    286286{
    287287  return (*content == *(rhs.content));
    … …  
    292292 * \return allocated NDIM*NDIM array with the symmetric matrix
    293293 */
    294 Matrix ReturnFullMatrixforSymmetric(const double * const symm)
    295 {
    296   Matrix matrix;
     294RealSpaceMatrix ReturnFullMatrixforSymmetric(const double * const symm)
     295{
     296  RealSpaceMatrix matrix;
    297297  matrix.set(0,0, symm[0]);
    298298  matrix.set(1,0, symm[1]);
    … …  
    307307};
    308308
    309 ostream &operator<<(ostream &ost,const Matrix &mat)
     309ostream &operator<<(ostream &ost,const RealSpaceMatrix &mat)
    310310{
    311311  for(int i = 0;i<NDIM;++i){
    … …  
    320320}
    321321
    322 Vector operator*(const Matrix &mat,const Vector &vec)
     322Vector operator*(const RealSpaceMatrix &mat,const Vector &vec)
    323323{
    324324  return (*mat.content) * vec;
    325325}
    326326
    327 Vector &operator*=(Vector& lhs,const Matrix &mat)
     327Vector &operator*=(Vector& lhs,const RealSpaceMatrix &mat)
    328328{
    329329  lhs = mat*lhs;

  • src/LinearAlgebra/RealSpaceMatrix.hpp

    r3bc926 rcca9ef  
    11/*
    2  * Matrix.hpp
     2 * RealSpaceMatrix.hpp
    33 *
    44 *  Created on: Jun 25, 2010
    … …  
    66 */
    77
    8 #ifndef MATRIX_HPP_
    9 #define MATRIX_HPP_
     8#ifndef REALSPACEMATRIX_HPP_
     9#define REALSPACEMATRIX_HPP_
    1010
    1111#include <iosfwd>
    … …  
    1919class MatrixContent;
    2020
    21 class Matrix
     21/** 3x3 Matrix class.
     22 * This class has some specific features for 3D space such as rotations or
     23 * hard-coded determinants.
     24 */
     25class RealSpaceMatrix
    2226{
    23   friend Vector operator*(const Matrix&,const Vector&);
     27  friend Vector operator*(const RealSpaceMatrix&,const Vector&);
    2428public:
    25   Matrix();
     29  RealSpaceMatrix();
    2630
    2731  /**
    … …  
    4145   *
    4246   */
    43   Matrix(const double*);
    44   Matrix(const Matrix&);
    45   Matrix(const MatrixContent&);
    46   virtual ~Matrix();
     47  RealSpaceMatrix(const double*);
     48  RealSpaceMatrix(const RealSpaceMatrix&);
     49  RealSpaceMatrix(const MatrixContent&);
     50  virtual ~RealSpaceMatrix();
    4751
    4852  /**
    … …  
    107111   * Rather costly, so use precomputation as often as possible.
    108112   */
    109   Matrix invert() const;
     113  RealSpaceMatrix invert() const;
    110114
    111115  /**
    … …  
    120124   * Calculate the transpose of the matrix.
    121125   */
    122   Matrix transpose() const;
    123   Matrix &transpose();
     126  RealSpaceMatrix transpose() const;
     127  RealSpaceMatrix &transpose();
    124128
    125129  // operators
    126   Matrix &operator=(const Matrix&);
     130  RealSpaceMatrix &operator=(const RealSpaceMatrix&);
    127131
    128   const Matrix &operator+=(const Matrix&);
    129   const Matrix &operator-=(const Matrix&);
    130   const Matrix &operator*=(const Matrix&);
     132  const RealSpaceMatrix &operator+=(const RealSpaceMatrix&);
     133  const RealSpaceMatrix &operator-=(const RealSpaceMatrix&);
     134  const RealSpaceMatrix &operator*=(const RealSpaceMatrix&);
    131135
    132   const Matrix &operator*=(const double);
     136  const RealSpaceMatrix &operator*=(const double);
    133137
    134   const Matrix operator+(const Matrix&) const;
    135   const Matrix operator-(const Matrix&) const;
    136   const Matrix operator*(const Matrix&) const;
     138  const RealSpaceMatrix operator+(const RealSpaceMatrix&) const;
     139  const RealSpaceMatrix operator-(const RealSpaceMatrix&) const;
     140  const RealSpaceMatrix operator*(const RealSpaceMatrix&) const;
    137141
    138   bool operator==(const Matrix&) const;
     142  bool operator==(const RealSpaceMatrix&) const;
    139143
    140144private:
    141   Matrix(MatrixContent*);
     145  RealSpaceMatrix(MatrixContent*);
    142146  void createViews();
    143147  MatrixContent *content;
    … …  
    148152};
    149153
    150 const Matrix operator*(const double,const Matrix&);
    151 const Matrix operator*(const Matrix&,const double);
     154const RealSpaceMatrix operator*(const double,const RealSpaceMatrix&);
     155const RealSpaceMatrix operator*(const RealSpaceMatrix&,const double);
    152156
    153157/**
    … …  
    165169 * 5 -> (2,2)
    166170 */
    167 Matrix ReturnFullMatrixforSymmetric(const double * const cell_size);
     171RealSpaceMatrix ReturnFullMatrixforSymmetric(const double * const cell_size);
    168172
    169 std::ostream &operator<<(std::ostream&,const Matrix&);
    170 Vector operator*(const Matrix&,const Vector&);
    171 Vector& operator*=(Vector&,const Matrix&);
     173std::ostream &operator<<(std::ostream&,const RealSpaceMatrix&);
     174Vector operator*(const RealSpaceMatrix&,const Vector&);
     175Vector& operator*=(Vector&,const RealSpaceMatrix&);
    172176
    173 #endif /* MATRIX_HPP_ */
     177#endif /* REALSPACEMATRIX_HPP_ */

  • src/LinearAlgebra/Vector.hpp

    r3bc926 rcca9ef  
    2222
    2323class Vector;
    24 class Matrix;
     24class RealSpaceMatrix;
    2525class MatrixContent;
    2626struct VectorContent;
    … …  
    3333class Vector : public Space{
    3434  friend Vector operator*(const MatrixContent&,const Vector&);
    35   friend class Matrix;
     35  friend class RealSpaceMatrix;
    3636public:
    3737  Vector();

  • src/Parser/PcpParser.cpp

    r3bc926 rcca9ef  
    3131#include "Helpers/Log.hpp"
    3232#include "Helpers/Verbose.hpp"
    33 #include "LinearAlgebra/Matrix.hpp"
     33#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3434#include "molecule.hpp"
    3535#include "PcpParser.hpp"
    … …  
    375375  DoLog(0) && (Log() << Verbose(0) << "Saving changes to pcp." << std::endl);
    376376
    377   const Matrix &domain = World::getInstance().getDomain().getM();
     377  const RealSpaceMatrix &domain = World::getInstance().getDomain().getM();
    378378  class ThermoStatContainer *Thermostats = World::getInstance().getThermostats();
    379379  if (!file->fail()) {

  • src/Shapes/ShapeOps.cpp

    r3bc926 rcca9ef  
    233233/************************* transform *****************/
    234234
    235 Transform_impl::Transform_impl(const Shape::impl_ptr &_arg, const Matrix &_transformation) :
     235Transform_impl::Transform_impl(const Shape::impl_ptr &_arg, const RealSpaceMatrix &_transformation) :
    236236  ShapeOpsBase_impl(_arg),transformation(_transformation)
    237237{
    … …  
    254254
    255255Vector Transform_impl::translateOutNormal(const Vector& point){
    256   Matrix mat = transformation.invert().transpose();
     256  RealSpaceMatrix mat = transformation.invert().transpose();
    257257  return mat * point;
    258258}
    … …  
    272272}
    273273
    274 Shape transform(const Shape &arg, const Matrix &transformation){
     274Shape transform(const Shape &arg, const RealSpaceMatrix &transformation){
    275275  Shape::impl_ptr impl = Shape::impl_ptr(new Transform_impl(getShapeImpl(arg),transformation));
    276276  return Shape(impl);

  • src/Shapes/ShapeOps.hpp

    r3bc926 rcca9ef  
    1111#include "Shapes/Shape.hpp"
    1212
    13 class Matrix;
     13class RealSpaceMatrix;
    1414
    1515Shape resize(const Shape&,double);
    1616Shape translate(const Shape&, const Vector&);
    1717Shape stretch(const Shape&, const Vector&);
    18 Shape transform(const Shape&,const Matrix&);
     18Shape transform(const Shape&,const RealSpaceMatrix&);
    1919
    2020#endif /* SHAPEOPS_HPP_ */

  • src/Shapes/ShapeOps_impl.hpp

    r3bc926 rcca9ef  
    1111#include "Shapes/Shape_impl.hpp"
    1212#include "LinearAlgebra/Vector.hpp"
    13 #include "LinearAlgebra/Matrix.hpp"
     13#include "LinearAlgebra/RealSpaceMatrix.hpp"
    1414
    1515#include <vector>
    … …  
    8787{
    8888public:
    89   Transform_impl(const Shape::impl_ptr&, const Matrix&);
     89  Transform_impl(const Shape::impl_ptr&, const RealSpaceMatrix&);
    9090  virtual ~Transform_impl();
    9191protected:
    … …  
    9797  virtual std::vector<Vector> getHomogeneousPointsOnSurface(const size_t N) const;
    9898private:
    99   Matrix transformation;
    100   Matrix transformationInv;
     99  RealSpaceMatrix transformation;
     100  RealSpaceMatrix transformationInv;
    101101};
    102102

  • src/UIElements/CommandLineUI/Query/BoxCommandLineQuery.cpp

    r3bc926 rcca9ef  
    2525#include "Helpers/Log.hpp"
    2626#include "Helpers/Verbose.hpp"
    27 #include "LinearAlgebra/Matrix.hpp"
     27#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2828
    2929CommandLineDialog::BoxCommandLineQuery::BoxCommandLineQuery(string title, string _description) :
    … …  
    3838  if (CommandLineParser::getInstance().vm.count(getTitle())) {
    3939    temp = CommandLineParser::getInstance().vm[getTitle()].as< BoxValue >();
    40     Matrix M;
     40    RealSpaceMatrix M;
    4141    M.set(0,0, temp.xx);
    4242    M.set(0,1, temp.yx);

  • src/UIElements/Dialog.cpp

    r3bc926 rcca9ef  
    2929class Box;
    3030class element;
    31 class Matrix;
     31class RealSpaceMatrix;
    3232class molecule;
    3333class Vector;

  • src/UIElements/Qt4/Pipe/BoxQtQueryPipe.cpp

    r3bc926 rcca9ef  
    2525
    2626#include "Helpers/MemDebug.hpp"
    27 #include "LinearAlgebra/Matrix.hpp"
     27#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2828#include "Box.hpp"
    2929
    … …  
    3333  inputTable(_inputTable)
    3434{
    35   tmpM = new Matrix();
     35  tmpM = new RealSpaceMatrix();
    3636  tmpM->setZero();
    3737}

  • src/UIElements/Qt4/Pipe/BoxQtQueryPipe.hpp

    r3bc926 rcca9ef  
    1515class Box;
    1616class QtDialog;
    17 class Matrix;
     17class RealSpaceMatrix;
    1818
    1919
    … …  
    3232  QTableWidget *inputTable;
    3333
    34   Matrix *tmpM;
     34  RealSpaceMatrix *tmpM;
    3535};
    3636

  • src/UIElements/Qt4/Query/BoxQtQuery.cpp

    r3bc926 rcca9ef  
    2727#include "UIElements/Qt4/Pipe/BoxQtQueryPipe.hpp"
    2828
    29 #include "LinearAlgebra/Matrix.hpp"
     29#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3030#include "World.hpp"
    3131
    … …  
    4747
    4848  // fill the box with current matrix
    49   const Matrix &domain = World::getInstance().getDomain().getM();
     49  const RealSpaceMatrix &domain = World::getInstance().getDomain().getM();
    5050  for (int i=0;i<3;i++)
    5151    for (int j=0;j<3;j++) {

  • src/UIElements/TextUI/Query/BoxTextQuery.cpp

    r3bc926 rcca9ef  
    2626#include "Helpers/Log.hpp"
    2727#include "Helpers/Verbose.hpp"
    28 #include "LinearAlgebra/Matrix.hpp"
     28#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2929
    3030
    … …  
    4646    std::cin >> temp[i];
    4747  }
    48   Matrix M;
     48  RealSpaceMatrix M;
    4949  M.set(0,0, temp[0]);
    5050  M.set(0,1, temp[1]);

  • src/UIElements/TextUI/Query/VectorTextQuery.cpp

    r3bc926 rcca9ef  
    2727#include "Helpers/Verbose.hpp"
    2828#include "LinearAlgebra/Vector.hpp"
    29 #include "LinearAlgebra/Matrix.hpp"
     29#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3030#include "World.hpp"
    3131
    … …  
    4040bool TextDialog::VectorTextQuery::handle() {
    4141  std::cout << getDescription() << std::endl;
    42   const Matrix &M = World::getInstance().getDomain().getM();
     42  const RealSpaceMatrix &M = World::getInstance().getDomain().getM();
    4343  char coords[3] = {'x', 'y', 'z'};
    4444  for (int i=0;i<3;i++)

  • src/UIElements/TextUI/Query/VectorsTextQuery.cpp

    r3bc926 rcca9ef  
    2727#include "Helpers/Verbose.hpp"
    2828#include "LinearAlgebra/Vector.hpp"
    29 #include "LinearAlgebra/Matrix.hpp"
     29#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3030#include "World.hpp"
    3131
    … …  
    4141  std::cout << getDescription() << std::endl;
    4242  char coords[3] = {'x', 'y', 'z'};
    43   const Matrix &M = World::getInstance().getDomain().getM();
     43  const RealSpaceMatrix &M = World::getInstance().getDomain().getM();
    4444  for (int i=0;i<3;i++)
    4545    std::cout << coords[i] << "[0.." << M.at(i,i) << ( (i!=2) ? "], " : "]: ");

  • src/World.cpp

    r3bc926 rcca9ef  
    3838#include "Helpers/Assert.hpp"
    3939#include "Box.hpp"
    40 #include "LinearAlgebra/Matrix.hpp"
     40#include "LinearAlgebra/RealSpaceMatrix.hpp"
    4141#include "defs.hpp"
    4242
    … …  
    100100}
    101101
    102 void World::setDomain(const Matrix &mat){
     102void World::setDomain(const RealSpaceMatrix &mat){
    103103  OBSERVE;
    104104  *cell_size = mat;
    … …  
    108108{
    109109  OBSERVE;
    110   Matrix M = ReturnFullMatrixforSymmetric(matrix);
     110  RealSpaceMatrix M = ReturnFullMatrixforSymmetric(matrix);
    111111  cell_size->setM(M);
    112112}
    … …  
    747747{
    748748  cell_size = new Box;
    749   Matrix domain;
     749  RealSpaceMatrix domain;
    750750  domain.at(0,0) = 20;
    751751  domain.at(1,1) = 20;

  • src/World.hpp

    r3bc926 rcca9ef  
    4141class config;
    4242class ManipulateAtomsProcess;
    43 class Matrix;
     43class RealSpaceMatrix;
    4444class molecule;
    4545class MoleculeDescriptor;
    … …  
    147147   * Matrix needs to be symmetric
    148148   */
    149   void setDomain(const Matrix &mat);
     149  void setDomain(const RealSpaceMatrix &mat);
    150150
    151151  /**

  • src/analysis_correlation.cpp

    r3bc926 rcca9ef  
    3333#include "triangleintersectionlist.hpp"
    3434#include "LinearAlgebra/Vector.hpp"
    35 #include "LinearAlgebra/Matrix.hpp"
     35#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3636#include "Helpers/Verbose.hpp"
    3737#include "World.hpp"
    … …  
    145145  outmap = new PairCorrelationMap;
    146146  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++){
    147     Matrix FullMatrix = World::getInstance().getDomain().getM();
    148     Matrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
     147    RealSpaceMatrix FullMatrix = World::getInstance().getDomain().getM();
     148    RealSpaceMatrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
    149149    DoLog(2) && (Log()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
    150150    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    … …  
    244244  outmap = new CorrelationToPointMap;
    245245  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++) {
    246     Matrix FullMatrix = World::getInstance().getDomain().getM();
    247     Matrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
     246    RealSpaceMatrix FullMatrix = World::getInstance().getDomain().getM();
     247    RealSpaceMatrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
    248248    DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
    249249    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
    … …  
    342342  BoundaryTriangleSet *ShortestTriangle = NULL;
    343343  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++) {
    344     Matrix FullMatrix = World::getInstance().getDomain().getM();
    345     Matrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
     344    RealSpaceMatrix FullMatrix = World::getInstance().getDomain().getM();
     345    RealSpaceMatrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
    346346    DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
    347347    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {

  • src/atom_atominfo.hpp

    r3bc926 rcca9ef  
    2626class AtomInfo;
    2727class element;
    28 class Matrix;
     28class RealSpaceMatrix;
    2929
    3030/********************************************** declarations *******************************/

  • src/boundary.cpp

    r3bc926 rcca9ef  
    4040#include "World.hpp"
    4141#include "LinearAlgebra/Plane.hpp"
    42 #include "LinearAlgebra/Matrix.hpp"
     42#include "LinearAlgebra/RealSpaceMatrix.hpp"
    4343#include "Box.hpp"
    4444
    … …  
    792792  int N[NDIM];
    793793  int n[NDIM];
    794   const Matrix &M = World::getInstance().getDomain().getM();
    795   Matrix Rotations;
    796   const Matrix &MInverse = World::getInstance().getDomain().getMinv();
     794  const RealSpaceMatrix &M = World::getInstance().getDomain().getM();
     795  RealSpaceMatrix Rotations;
     796  const RealSpaceMatrix &MInverse = World::getInstance().getDomain().getMinv();
    797797  Vector AtomTranslations;
    798798  Vector FillerTranslations;
    … …  
    944944  int N[NDIM];
    945945  int n[NDIM];
    946   const Matrix &M = World::getInstance().getDomain().getM();
    947   Matrix Rotations;
    948   const Matrix &MInverse = World::getInstance().getDomain().getMinv();
     946  const RealSpaceMatrix &M = World::getInstance().getDomain().getM();
     947  RealSpaceMatrix Rotations;
     948  const RealSpaceMatrix &MInverse = World::getInstance().getDomain().getMinv();
    949949  Vector AtomTranslations;
    950950  Vector FillerTranslations;

  • src/config.cpp

    r3bc926 rcca9ef  
    3939#include "ThermoStatContainer.hpp"
    4040#include "World.hpp"
    41 #include "LinearAlgebra/Matrix.hpp"
     41#include "LinearAlgebra/RealSpaceMatrix.hpp"
    4242#include "Box.hpp"
    4343
    … …  
    637637{
    638638  bool result = true;
    639   const Matrix &domain = World::getInstance().getDomain().getM();
     639  const RealSpaceMatrix &domain = World::getInstance().getDomain().getM();
    640640  ofstream * const output = new ofstream(filename, ios::out);
    641641  if (output != NULL) {

  • src/ellipsoid.cpp

    r3bc926 rcca9ef  
    3434#include "tesselation.hpp"
    3535#include "LinearAlgebra/Vector.hpp"
    36 #include "LinearAlgebra/Matrix.hpp"
     36#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3737#include "Helpers/Verbose.hpp"
    3838
    … …  
    4848  Vector helper, RefPoint;
    4949  double distance = -1.;
    50   Matrix Matrix;
     50  RealSpaceMatrix Matrix;
    5151  double InverseLength[3];
    5252  double psi,theta,phi; // euler angles in ZX'Z'' convention

  • src/molecule.cpp

    r3bc926 rcca9ef  
    4343#include "tesselation.hpp"
    4444#include "LinearAlgebra/Vector.hpp"
    45 #include "LinearAlgebra/Matrix.hpp"
     45#include "LinearAlgebra/RealSpaceMatrix.hpp"
    4646#include "World.hpp"
    4747#include "Box.hpp"
    … …  
    316316  Vector Orthovector1, Orthovector2;  // temporary vectors in coordination construction
    317317  Vector InBondvector;    // vector in direction of *Bond
    318   const Matrix &matrix =  World::getInstance().getDomain().getM();
     318  const RealSpaceMatrix &matrix =  World::getInstance().getDomain().getM();
    319319  bond *Binder = NULL;
    320320
    … …  
    778778void molecule::SetBoxDimension(Vector *dim)
    779779{
    780   Matrix domain;
     780  RealSpaceMatrix domain;
    781781  for(int i =0; i<NDIM;++i)
    782782    domain.at(i,i) = dim->at(i);
    … …  
    862862bool molecule::CheckBounds(const Vector *x) const
    863863{
    864   const Matrix &domain = World::getInstance().getDomain().getM();
     864  const RealSpaceMatrix &domain = World::getInstance().getDomain().getM();
    865865  bool result = true;
    866866  for (int i=0;i<NDIM;i++) {

  • src/molecule_fragmentation.cpp

    r3bc926 rcca9ef  
    3434#include "periodentafel.hpp"
    3535#include "World.hpp"
    36 #include "LinearAlgebra/Matrix.hpp"
     36#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3737#include "Box.hpp"
    3838#include "stackclass.hpp"
    … …  
    17391739  atom *Walker = NULL;
    17401740  atom *OtherWalker = NULL;
    1741   Matrix matrix = World::getInstance().getDomain().getM();
     1741  RealSpaceMatrix matrix = World::getInstance().getDomain().getM();
    17421742  enum Shading *ColorList = NULL;
    17431743  double tmp;

  • src/molecule_geometry.cpp

    r3bc926 rcca9ef  
    2424#include "Helpers/Verbose.hpp"
    2525#include "LinearAlgebra/Line.hpp"
    26 #include "LinearAlgebra/Matrix.hpp"
     26#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2727#include "LinearAlgebra/Plane.hpp"
    2828
    … …  
    166166{
    167167  Vector *a = new Vector(0.5,0.5,0.5);
    168   const Matrix &M = World::getInstance().getDomain().getM();
     168  const RealSpaceMatrix &M = World::getInstance().getDomain().getM();
    169169  (*a) *= M;
    170170  return a;
    … …  
    287287void molecule::DeterminePeriodicCenter(Vector &center)
    288288{
    289   const Matrix &matrix = World::getInstance().getDomain().getM();
    290   const Matrix &inversematrix = World::getInstance().getDomain().getM();
     289  const RealSpaceMatrix &matrix = World::getInstance().getDomain().getM();
     290  const RealSpaceMatrix &inversematrix = World::getInstance().getDomain().getM();
    291291  double tmp;
    292292  bool flag;

  • src/molecule_graph.cpp

    r3bc926 rcca9ef  
    3636#include "Helpers/fast_functions.hpp"
    3737#include "Helpers/Assert.hpp"
    38 #include "LinearAlgebra/Matrix.hpp"
     38#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3939#include "Box.hpp"
    4040#include "stackclass.hpp"

  • src/moleculelist.cpp

    r3bc926 rcca9ef  
    4040#include "tesselation.hpp"
    4141#include "Helpers/Assert.hpp"
    42 #include "LinearAlgebra/Matrix.hpp"
     42#include "LinearAlgebra/RealSpaceMatrix.hpp"
    4343#include "Box.hpp"
    4444#include "stackclass.hpp"
    … …  
    487487  int FragmentCounter = 0;
    488488  ofstream output;
    489   Matrix cell_size = World::getInstance().getDomain().getM();
    490   Matrix cell_size_backup = cell_size;
     489  RealSpaceMatrix cell_size = World::getInstance().getDomain().getM();
     490  RealSpaceMatrix cell_size_backup = cell_size;
    491491
    492492  // store the fragments as config and as xyz
    … …  
    629629  // center at set box dimensions
    630630  mol->CenterEdge(&center);
    631   Matrix domain;
     631  RealSpaceMatrix domain;
    632632  for(int i =0;i<NDIM;++i)
    633633    domain.at(i,i) = center[i];

  • src/tesselationhelpers.cpp

    r3bc926 rcca9ef  
    3838#include "Helpers/Verbose.hpp"
    3939#include "LinearAlgebra/Plane.hpp"
    40 #include "LinearAlgebra/Matrix.hpp"
     40#include "LinearAlgebra/RealSpaceMatrix.hpp"
    4141
    4242void GetSphere(Vector * const center, const Vector &a, const Vector &b, const Vector &c, const double RADIUS)
    4343{
    4444        Info FunctionInfo(__func__);
    45   Matrix mat;
     45  RealSpaceMatrix mat;
    4646  double m11, m12, m13, m14;
    4747

  • src/unittests/BoxUnittest.cpp

    r3bc926 rcca9ef  
    2929
    3030#include "LinearAlgebra/Vector.hpp"
    31 #include "LinearAlgebra/Matrix.hpp"
     31#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3232#include "Box.hpp"
    3333#include "Helpers/Assert.hpp"
    … …  
    4040void BoxUnittest::setUp(){
    4141  ASSERT_DO(Assert::Throw);
    42   unit = new Matrix;
     42  unit = new RealSpaceMatrix;
    4343  unit->setIdentity();
    44   zero = new Matrix;
    45   invertible = new Matrix;
     44  zero = new RealSpaceMatrix;
     45  invertible = new RealSpaceMatrix;
    4646  invertible->diagonal() = Vector(1,2,3);
    47   uninvertible = new Matrix;
     47  uninvertible = new RealSpaceMatrix;
    4848  uninvertible->column(0) = Vector(1,0,1);
    4949  uninvertible->column(2) = Vector(1,0,1);
    5050
    51   Matrix boxMat;
     51  RealSpaceMatrix boxMat;
    5252  unitBox = new Box;
    5353  stretchedBox1 = new Box;

  • src/unittests/BoxUnittest.hpp

    r3bc926 rcca9ef  
    1111#include <cppunit/extensions/HelperMacros.h>
    1212
    13 class Matrix;
     13class RealSpaceMatrix;
    1414class Box;
    1515
    … …  
    3838  void BoundaryMixedTest();
    3939
    40   Matrix *unit;
    41   Matrix *zero;
    42   Matrix *invertible;
    43   Matrix *uninvertible;
     40  RealSpaceMatrix *unit;
     41  RealSpaceMatrix *zero;
     42  RealSpaceMatrix *invertible;
     43  RealSpaceMatrix *uninvertible;
    4444
    4545  Box *unitBox;

  • src/unittests/MatrixUnittest.cpp

    r3bc926 rcca9ef  
    2626#include "MatrixUnittest.hpp"
    2727#include "LinearAlgebra/Vector.hpp"
    28 #include "LinearAlgebra/Matrix.hpp"
     28#include "LinearAlgebra/RealSpaceMatrix.hpp"
    2929#include "Exceptions/NotInvertibleException.hpp"
    3030
    … …  
    3737
    3838void MatrixUnittest::setUp(){
    39   zero = new Matrix();
     39  zero = new RealSpaceMatrix();
    4040  for(int i =NDIM;i--;) {
    4141    for(int j =NDIM;j--;) {
    … …  
    4343    }
    4444  }
    45   one = new Matrix();
     45  one = new RealSpaceMatrix();
    4646  for(int i =NDIM;i--;){
    4747    one->at(i,i)=1.;
    4848  }
    49   full=new Matrix();
     49  full=new RealSpaceMatrix();
    5050  for(int i=NDIM;i--;){
    5151    for(int j=NDIM;j--;){
    … …  
    5353    }
    5454  }
    55   diagonal = new Matrix();
     55  diagonal = new RealSpaceMatrix();
    5656  for(int i=NDIM;i--;){
    5757    diagonal->at(i,i)=i+1.;
    5858  }
    59   perm1 = new Matrix();
     59  perm1 = new RealSpaceMatrix();
    6060  perm1->column(0) = unitVec[0];
    6161  perm1->column(1) = unitVec[2];
    … …  
    6363
    6464
    65   perm2 = new Matrix();
     65  perm2 = new RealSpaceMatrix();
    6666  perm2->column(0) = unitVec[1];
    6767  perm2->column(1) = unitVec[0];
    6868  perm2->column(2) = unitVec[2];
    6969
    70   perm3 = new Matrix();
     70  perm3 = new RealSpaceMatrix();
    7171  perm3->column(0) = unitVec[1];
    7272  perm3->column(1) = unitVec[2];
    7373  perm3->column(2) = unitVec[0];
    7474
    75   perm4 = new Matrix();
     75  perm4 = new RealSpaceMatrix();
    7676  perm4->column(0) = unitVec[2];
    7777  perm4->column(1) = unitVec[1];
    7878  perm4->column(2) = unitVec[0];
    7979
    80   perm5 = new Matrix();
     80  perm5 = new RealSpaceMatrix();
    8181  perm5->column(0) = unitVec[2];
    8282  perm5->column(1) = unitVec[0];
    … …  
    9797
    9898void MatrixUnittest::AccessTest(){
    99   Matrix mat;
     99  RealSpaceMatrix mat;
    100100  for(int i=NDIM;i--;){
    101101    for(int j=NDIM;j--;){
    … …  
    119119
    120120void MatrixUnittest::VectorTest(){
    121   Matrix mat;
     121  RealSpaceMatrix mat;
    122122  for(int i=NDIM;i--;){
    123123    CPPUNIT_ASSERT_EQUAL(mat.row(i),zeroVec);
    … …  
    173173
    174174void MatrixUnittest::TransposeTest(){
    175   Matrix res;
     175  RealSpaceMatrix res;
    176176
    177177  // transpose of unit is unit
    … …  
    187187
    188188void MatrixUnittest::OperationTest(){
    189   Matrix res;
     189  RealSpaceMatrix res;
    190190
    191191  res =(*zero) *(*zero);
    … …  
    260260
    261261void MatrixUnittest::RotationTest(){
    262   Matrix res;
    263   Matrix inverse;
     262  RealSpaceMatrix res;
     263  RealSpaceMatrix inverse;
    264264
    265265  // zero rotation angles yields unity matrix
    … …  
    278278  // ... or transposed
    279279  res.setRotation(M_PI/3.,0.,0.);
    280   CPPUNIT_ASSERT_EQUAL(inverse, ((const Matrix) res).transpose());
     280  CPPUNIT_ASSERT_EQUAL(inverse, ((const RealSpaceMatrix) res).transpose());
    281281}
    282282
    … …  
    285285  CPPUNIT_ASSERT_THROW(full->invert(),NotInvertibleException);
    286286
    287   Matrix res;
     287  RealSpaceMatrix res;
    288288  res = (*one)*one->invert();
    289289  CPPUNIT_ASSERT_EQUAL(res,*one);

  • src/unittests/MatrixUnittest.hpp

    r3bc926 rcca9ef  
    1111#include <cppunit/extensions/HelperMacros.h>
    1212
    13 class Matrix;
     13class RealSpaceMatrix;
    1414
    1515class MatrixUnittest : public CppUnit::TestFixture
    … …  
    3939  void VecMultTest();
    4040
    41   Matrix *zero;
    42   Matrix *one;
    43   Matrix *full;
    44   Matrix *diagonal;
    45   Matrix *perm1;
    46   Matrix *perm2;
    47   Matrix *perm3;
    48   Matrix *perm4;
    49   Matrix *perm5;
     41  RealSpaceMatrix *zero;
     42  RealSpaceMatrix *one;
     43  RealSpaceMatrix *full;
     44  RealSpaceMatrix *diagonal;
     45  RealSpaceMatrix *perm1;
     46  RealSpaceMatrix *perm2;
     47  RealSpaceMatrix *perm3;
     48  RealSpaceMatrix *perm4;
     49  RealSpaceMatrix *perm5;
    5050};
    5151

  • src/unittests/vectorunittest.cpp

    r3bc926 rcca9ef  
    3131#include "LinearAlgebra/Plane.hpp"
    3232#include "Exceptions/LinearDependenceException.hpp"
    33 #include "LinearAlgebra/Matrix.hpp"
     33#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3434
    3535#ifdef HAVE_TESTRUNNER
Note: See TracChangeset for help on using the changeset viewer.