Ignore:
Timestamp:
Oct 9, 2009, 10:54:52 AM (16 years ago)
Author:
Frederik Heber <heber@…>
Children:
3efb4a
Parents:
70b7aa
Message:

forward declarations used to untangle interdependet classes.

  • basically, everywhere in header files we removed '#include' lines were only pointer to the respective classes were used and the include line was moved to the implementation file.
  • as a sidenote, lots of funny errors happened because headers were included via a nesting over three other includes. Now, all should be declared directly as needed, as only very little include lines remain in header files.
File:
1 edited

Legend:

Unmodified
Added
Removed

  • molecuilder/src/datacreator.cpp

    r70b7aa r17b3a5c  
    88
    99#include "datacreator.hpp"
     10#include "helpers.hpp"
     11#include "parser.hpp"
    1012
    1113//=========================== FUNCTIONS============================
    … …  
    4951/** Plots an energy vs. order.
    5052 * \param &Fragments EnergyMatrix class containing matrix values
    51  * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
     53 * \param KeySets KeySetContainer class holding bond KeySetContainer::Order
    5254 * \param *prefix prefix in filename (without ending)
    5355 * \param *msg message to be place in first line as a comment
    5456 * \return true if file was written successfully
    5557 */
    56 bool CreateDataEnergyOrder(class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum)
     58bool CreateDataEnergyOrder(class EnergyMatrix &Fragments, class KeySetsContainer &KeySets, const char *dir, const char *prefix, const char *msg, const char *datum)
    5759{
    5860  stringstream filename;
    … …  
    6466  output << "# " << msg << ", created on " << datum;
    6567  output << "#Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
    66   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
    67     for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;) {
    68       for(int j=Fragments.RowCounter[ KeySet.OrderSet[BondOrder][i] ];j--;)
    69         for(int k=Fragments.ColumnCounter[ KeySet.OrderSet[BondOrder][i] ];k--;)
    70           Fragments.Matrix[Fragments.MatrixCounter][j][k] += Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
    71     }
    72     output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
     68  for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
     69    for(int i=KeySets.FragmentsPerOrder[BondOrder];i--;) {
     70      for(int j=Fragments.RowCounter[ KeySets.OrderSet[BondOrder][i] ];j--;)
     71        for(int k=Fragments.ColumnCounter[ KeySets.OrderSet[BondOrder][i] ];k--;)
     72          Fragments.Matrix[Fragments.MatrixCounter][j][k] += Fragments.Matrix[ KeySets.OrderSet[BondOrder][i] ][j][k];
     73    }
     74    output << BondOrder+1 << "\t" << KeySets.FragmentsPerOrder[BondOrder];
    7375    for (int l=0;l<Fragments.ColumnCounter[Fragments.MatrixCounter];l++)
    7476      output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter]-1 ][l];
    … …  
    8284 * \param &Energy EnergyMatrix class containing reference values (in MatrixCounter matrix)
    8385 * \param &Fragments EnergyMatrix class containing matrix values
    84  * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
     86 * \param KeySets KeySetContainer class holding bond KeySetContainer::Order
    8587 * \param *prefix prefix in filename (without ending)
    8688 * \param *msg message to be place in first line as a comment
    8789 * \return true if file was written successfully
    8890 */
    89 bool CreateDataDeltaEnergyOrder(class EnergyMatrix &Energy, class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum)
     91bool CreateDataDeltaEnergyOrder(class EnergyMatrix &Energy, class EnergyMatrix &Fragments, class KeySetsContainer &KeySets, const char *dir, const char *prefix, const char *msg, const char *datum)
    9092{
    9193  stringstream filename;
    … …  
    98100  output << "#Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
    99101  Fragments.SetLastMatrix(Energy.Matrix[Energy.MatrixCounter],0);
    100   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
    101     for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;) {
    102       for(int j=Fragments.RowCounter[ KeySet.OrderSet[BondOrder][i] ];j--;)
    103         for(int k=Fragments.ColumnCounter[ KeySet.OrderSet[BondOrder][i] ];k--;)
    104           Fragments.Matrix[Fragments.MatrixCounter][j][k] -= Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
    105     }
    106     output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
     102  for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
     103    for(int i=KeySets.FragmentsPerOrder[BondOrder];i--;) {
     104      for(int j=Fragments.RowCounter[ KeySets.OrderSet[BondOrder][i] ];j--;)
     105        for(int k=Fragments.ColumnCounter[ KeySets.OrderSet[BondOrder][i] ];k--;)
     106          Fragments.Matrix[Fragments.MatrixCounter][j][k] -= Fragments.Matrix[ KeySets.OrderSet[BondOrder][i] ][j][k];
     107    }
     108    output << BondOrder+1 << "\t" << KeySets.FragmentsPerOrder[BondOrder];
    107109    for (int l=0;l<Fragments.ColumnCounter[Energy.MatrixCounter];l++)
    108110      if (fabs(Energy.Matrix[Energy.MatrixCounter][ Energy.RowCounter[Energy.MatrixCounter]-1 ][l]) < MYEPSILON)
    … …  
    118120/** Plot forces vs. order.
    119121 * \param &Fragments ForceMatrix class containing matrix values
    120  * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
     122 * \param KeySets KeySetContainer class holding bond KeySetContainer::Order
    121123 * \param *prefix prefix in filename (without ending)
    122124 * \param *msg message to be place in first line as a comment
    … …  
    124126 * \return true if file was written successfully
    125127 */
    126 bool CreateDataForcesOrder(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix,const  char *msg, const char *datum, void (*CreateForce)(class MatrixContainer &, int))
     128bool CreateDataForcesOrder(class ForceMatrix &Fragments, class KeySetsContainer &KeySets, const char *dir, const char *prefix,const  char *msg, const char *datum, void (*CreateForce)(class MatrixContainer &, int))
    127129{
    128130  stringstream filename;
    … …  
    135137  output << "# Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
    136138  Fragments.SetLastMatrix(0.,0);
    137   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
    138     Fragments.SumSubForces(Fragments, KeySet, BondOrder, 1.);
    139     output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
     139  for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
     140    Fragments.SumSubForces(Fragments, KeySets, BondOrder, 1.);
     141    output << BondOrder+1 << "\t" << KeySets.FragmentsPerOrder[BondOrder];
    140142    CreateForce(Fragments, Fragments.MatrixCounter);
    141143    for (int l=0;l<Fragments.ColumnCounter[Fragments.MatrixCounter];l++)
    … …  
    150152 * \param &Force ForceMatrix containing reference values (in MatrixCounter matrix)
    151153 * \param &Fragments ForceMatrix class containing matrix values
    152  * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
     154 * \param KeySets KeySetContainer class holding bond KeySetContainer::Order
    153155 * \param *prefix prefix in filename (without ending)
    154156 * \param *msg message to be place in first line as a comment
    … …  
    156158 * \return true if file was written successfully
    157159 */
    158 bool CreateDataDeltaForcesOrder(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum, void (*CreateForce)(class MatrixContainer &, int))
     160bool CreateDataDeltaForcesOrder(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySets, const char *dir, const char *prefix, const char *msg, const char *datum, void (*CreateForce)(class MatrixContainer &, int))
    159161{
    160162  stringstream filename;
    … …  
    167169  output << "# Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
    168170  Fragments.SetLastMatrix(Force.Matrix[Force.MatrixCounter],0);
    169   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
    170     Fragments.SumSubForces(Fragments, KeySet, BondOrder, -1.);
    171     output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
     171  for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
     172    Fragments.SumSubForces(Fragments, KeySets, BondOrder, -1.);
     173    output << BondOrder+1 << "\t" << KeySets.FragmentsPerOrder[BondOrder];
    172174    CreateForce(Fragments, Fragments.MatrixCounter);
    173175    for (int l=0;l<Fragments.ColumnCounter[Fragments.MatrixCounter];l++)
    … …  
    182184 * \param &Force ForceMatrix containing reference values (in MatrixCounter matrix)
    183185 * \param &Fragments ForceMatrix class containing matrix values
    184  * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
     186 * \param KeySets KeySetContainer class holding bond KeySetContainer::Order
    185187 * \param *prefix prefix in filename (without ending)
    186188 * \param *msg message to be place in first line as a comment
    … …  
    188190 * \return true if file was written successfully
    189191 */
    190 bool CreateDataDeltaForcesOrderPerAtom(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum)
     192bool CreateDataDeltaForcesOrderPerAtom(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySets, const char *dir, const char *prefix, const char *msg, const char *datum)
    191193{
    192194  stringstream filename;
    … …  
    200202  output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
    201203  Fragments.SetLastMatrix(Force.Matrix[Force.MatrixCounter], 0);
    202   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
     204  for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
    203205    //cout << "Current order is " << BondOrder << "." << endl;
    204     Fragments.SumSubForces(Fragments, KeySet, BondOrder, -1.);
     206    Fragments.SumSubForces(Fragments, KeySets, BondOrder, -1.);
    205207    // errors per atom
    206208    output << endl << "#Order\t" << BondOrder+1 << endl;
    … …  
    229231/** Plot forces error vs. vs atom vs. order.
    230232 * \param &Fragments ForceMatrix class containing matrix values
    231  * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
     233 * \param KeySets KeySetContainer class holding bond KeySetContainer::Order
    232234 * \param *prefix prefix in filename (without ending)
    233235 * \param *msg message to be place in first line as a comment
    … …  
    235237 * \return true if file was written successfully
    236238 */
    237 bool CreateDataForcesOrderPerAtom(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum)
     239bool CreateDataForcesOrderPerAtom(class ForceMatrix &Fragments, class KeySetsContainer &KeySets, const char *dir, const char *prefix, const char *msg, const char *datum)
    238240{
    239241  stringstream filename;
    … …  
    245247  output << "# " << msg << ", created on " << datum;
    246248  output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
    247   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
     249  for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
    248250    //cout << "Current order is " << BondOrder << "." << endl;
    249     Fragments.SumSubForces(Fragments, KeySet, BondOrder, 1.);
     251    Fragments.SumSubForces(Fragments, KeySets, BondOrder, 1.);
    250252    // errors per atom
    251253    output << endl << "#Order\t" << BondOrder+1 << endl;
    … …  
    266268 * \param &Hessian HessianMatrix containing reference values (in MatrixCounter matrix)
    267269 * \param &Fragments HessianMatrix class containing matrix values
    268  * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
     270 * \param KeySets KeySetContainer class holding bond KeySetContainer::Order
    269271 * \param *prefix prefix in filename (without ending)
    270272 * \param *msg message to be place in first line as a comment
    … …  
    272274 * \return true if file was written successfully
    273275 */
    274 bool CreateDataDeltaHessianOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum)
     276bool CreateDataDeltaHessianOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySets, const char *dir, const char *prefix, const char *msg, const char *datum)
    275277{
    276278  stringstream filename;
    … …  
    283285  output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
    284286  Fragments.SetLastMatrix(Hessian.Matrix[Hessian.MatrixCounter], 0);
    285   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
     287  for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
    286288    //cout << "Current order is " << BondOrder << "." << endl;
    287     Fragments.SumSubHessians(Fragments, KeySet, BondOrder, -1.);
     289    Fragments.SumSubHessians(Fragments, KeySets, BondOrder, -1.);
    288290    // errors per atom
    289291    output << endl << "#Order\t" << BondOrder+1 << endl;
    … …  
    304306 * \param &Hessian HessianMatrix containing reference values (in MatrixCounter matrix)
    305307 * \param &Fragments HessianMatrix class containing matrix values
    306  * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
     308 * \param KeySets KeySetContainer class holding bond KeySetContainer::Order
    307309 * \param *prefix prefix in filename (without ending)
    308310 * \param *msg message to be place in first line as a comment
    … …  
    310312 * \return true if file was written successfully
    311313 */
    312 bool CreateDataDeltaFrobeniusOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum)
     314bool CreateDataDeltaFrobeniusOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySets, const char *dir, const char *prefix, const char *msg, const char *datum)
    313315{
    314316  stringstream filename;
    … …  
    323325  output << "# AtomNo\t";
    324326  Fragments.SetLastMatrix(Hessian.Matrix[Hessian.MatrixCounter], 0);
    325   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
     327  for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
    326328    output << "Order" << BondOrder+1 << "\t";
    327329  }
    328330  output << endl;
    329331  output << Fragments.RowCounter[ Fragments.MatrixCounter ] << "\t";
    330   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
     332  for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
    331333    //cout << "Current order is " << BondOrder << "." << endl;
    332     Fragments.SumSubHessians(Fragments, KeySet, BondOrder, -1.);
     334    Fragments.SumSubHessians(Fragments, KeySets, BondOrder, -1.);
    333335    // frobenius norm of errors per atom
    334336    norm = 0.;
    … …  
    348350/** Plot hessian error vs. vs atom vs. order.
    349351 * \param &Fragments HessianMatrix class containing matrix values
    350  * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
     352 * \param KeySets KeySetContainer class holding bond KeySetContainer::Order
    351353 * \param *prefix prefix in filename (without ending)
    352354 * \param *msg message to be place in first line as a comment
    … …  
    354356 * \return true if file was written successfully
    355357 */
    356 bool CreateDataHessianOrderPerAtom(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum)
     358bool CreateDataHessianOrderPerAtom(class HessianMatrix &Fragments, class KeySetsContainer &KeySets, const char *dir, const char *prefix, const char *msg, const char *datum)
    357359{
    358360  stringstream filename;
    … …  
    365367  output << "# AtomNo\t" << Fragments.Header[ Fragments.MatrixCounter ] << endl;
    366368  Fragments.SetLastMatrix(0., 0);
    367   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
     369  for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
    368370    //cout << "Current order is " << BondOrder << "." << endl;
    369     Fragments.SumSubHessians(Fragments, KeySet, BondOrder, 1.);
     371    Fragments.SumSubHessians(Fragments, KeySets, BondOrder, 1.);
    370372    // errors per atom
    371373    output << endl << "#Order\t" << BondOrder+1 << endl;
    … …  
    384386/** Plot matrix vs. fragment.
    385387 */
    386 bool CreateDataFragment(class MatrixContainer &Fragment, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum, void (*CreateFragment)(class MatrixContainer &, int))
     388bool CreateDataFragment(class MatrixContainer &Fragment, class KeySetsContainer &KeySets, const char *dir, const char *prefix, const char *msg, const char *datum, void (*CreateFragment)(class MatrixContainer &, int))
    387389{
    388390  stringstream filename;
    … …  
    394396  output << "# " << msg << ", created on " << datum << endl;
    395397  output << "#Order\tFrag.No.\t" << Fragment.Header[ Fragment.MatrixCounter ] << endl;
    396   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
    397     for(int i=0;i<KeySet.FragmentsPerOrder[BondOrder];i++) {
    398       output << BondOrder+1 << "\t" << KeySet.OrderSet[BondOrder][i]+1;
    399       CreateFragment(Fragment, KeySet.OrderSet[BondOrder][i]);
    400       for (int l=0;l<Fragment.ColumnCounter[ KeySet.OrderSet[BondOrder][i] ];l++)
    401         output << scientific << "\t" << Fragment.Matrix[ KeySet.OrderSet[BondOrder][i] ][ Fragment.RowCounter[ KeySet.OrderSet[BondOrder][i] ] ][l];
     398  for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
     399    for(int i=0;i<KeySets.FragmentsPerOrder[BondOrder];i++) {
     400      output << BondOrder+1 << "\t" << KeySets.OrderSet[BondOrder][i]+1;
     401      CreateFragment(Fragment, KeySets.OrderSet[BondOrder][i]);
     402      for (int l=0;l<Fragment.ColumnCounter[ KeySets.OrderSet[BondOrder][i] ];l++)
     403        output << scientific << "\t" << Fragment.Matrix[ KeySets.OrderSet[BondOrder][i] ][ Fragment.RowCounter[ KeySets.OrderSet[BondOrder][i] ] ][l];
    402404      output << endl;
    403405    }
    … …  
    409411/** Copies fragment energy values into last matrix of \a Matrix with greatest total energy.
    410412 * \param &Matrix MatrixContainer with all fragment energy values
    411  * \param &KeySet KeySetsContainer with associations of each fragment to a bond order
     413 * \param &KeySets KeySetsContainer with associations of each fragment to a bond order
    412414 * \param BondOrder current bond order
    413415 */
    414 void CreateMaxFragmentOrder(class MatrixContainer &Fragments, class KeySetsContainer &KeySet, int BondOrder)
     416void CreateMaxFragmentOrder(class MatrixContainer &Fragments, class KeySetsContainer &KeySets, int BondOrder)
    415417{
    416418  for(int j=Fragments.RowCounter[ Fragments.MatrixCounter ];j--;) {
    417     for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;) {
    418       if (fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) < fabs(Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][1])) {
     419    for(int i=KeySets.FragmentsPerOrder[BondOrder];i--;) {
     420      if (fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) < fabs(Fragments.Matrix[ KeySets.OrderSet[BondOrder][i] ][j][1])) {
    419421        for (int k=Fragments.ColumnCounter[ Fragments.MatrixCounter ];k--;)
    420           Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
     422          Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySets.OrderSet[BondOrder][i] ][j][k];
    421423      }
    422424    }
    … …  
    426428/** Copies fragment energy values into last matrix of \a Matrix with smallest total energy.
    427429 * \param &Matrix MatrixContainer with all fragment energy values
    428  * \param &KeySet KeySetsContainer with associations of each fragment to a bond order
     430 * \param &KeySets KeySetsContainer with associations of each fragment to a bond order
    429431 * \param BondOrder current bond order
    430432 */
    431 void CreateMinFragmentOrder(class MatrixContainer &Fragments, class KeySetsContainer &KeySet, int BondOrder)
     433void CreateMinFragmentOrder(class MatrixContainer &Fragments, class KeySetsContainer &KeySets, int BondOrder)
    432434{
    433435  for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) {
    … …  
    435437    do {  // first get a minimum value unequal to 0
    436438      for (int k=Fragments.ColumnCounter[ Fragments.MatrixCounter ];k--;)
    437         Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
     439        Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySets.OrderSet[BondOrder][i] ][j][k];
    438440      i++;
    439     } while ((fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) < MYEPSILON) && (i<KeySet.FragmentsPerOrder[BondOrder]));
    440     for(;i<KeySet.FragmentsPerOrder[BondOrder];i++) { // then find lowest
    441       if (fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) > fabs(Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][1])) {
     441    } while ((fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) < MYEPSILON) && (i<KeySets.FragmentsPerOrder[BondOrder]));
     442    for(;i<KeySets.FragmentsPerOrder[BondOrder];i++) { // then find lowest
     443      if (fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) > fabs(Fragments.Matrix[ KeySets.OrderSet[BondOrder][i] ][j][1])) {
    442444        for (int k=Fragments.ColumnCounter[ Fragments.MatrixCounter ];k--;)
    443           Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
     445          Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySets.OrderSet[BondOrder][i] ][j][k];
    444446      }
    445447    }
    … …  
    449451/** Plot matrix vs. fragment.
    450452 */
    451 bool CreateDataFragmentOrder(class MatrixContainer &Fragment, class KeySetsContainer &KeySet, const char *dir, const char *prefix, const char *msg, const char *datum, void (*CreateFragmentOrder)(class MatrixContainer &, class KeySetsContainer &, int))
     453bool CreateDataFragmentOrder(class MatrixContainer &Fragment, class KeySetsContainer &KeySets, const char *dir, const char *prefix, const char *msg, const char *datum, void (*CreateFragmentOrder)(class MatrixContainer &, class KeySetsContainer &, int))
    452454{
    453455  stringstream filename;
    … …  
    460462  output << "#Order\tFrag.No.\t" << Fragment.Header[ Fragment.MatrixCounter ] << endl;
    461463  // max
    462   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
     464  for (int BondOrder=0;BondOrder<KeySets.Order;BondOrder++) {
    463465    Fragment.SetLastMatrix(0.,0);
    464     CreateFragmentOrder(Fragment, KeySet, BondOrder);
    465     output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
     466    CreateFragmentOrder(Fragment, KeySets, BondOrder);
     467    output << BondOrder+1 << "\t" << KeySets.FragmentsPerOrder[BondOrder];
    466468    for (int l=0;l<Fragment.ColumnCounter[ Fragment.MatrixCounter ];l++)
    467469      output << scientific << "\t" << Fragment.Matrix[ Fragment.MatrixCounter ][ Fragment.RowCounter[ Fragment.MatrixCounter ]-1 ][l];
    … …  
    618620/** Creates the pyxplotfile for energy data.
    619621 * \param Matrix MatrixContainer with matrix values
    620  * \param KeySet contains bond order
     622 * \param KeySets contains bond order
    621623 * \param *dir directory
    622624 * \param *prefix prefix for all filenames (without ending)
    … …  
    635637 * \return true if file was written successfully
    636638 */
    637 bool CreatePlotOrder(class MatrixContainer &Matrix, const class KeySetsContainer &KeySet, const char *dir, const char *prefix, const int keycolumns, const char *key, const char *logscale, const char *extraline, const int mxtics, const int xtics, const char *xlabel, const char *ylabel, const char *xrange, const char *yrange, const char *xargument, const char *uses, void (*CreatePlotLines)(ofstream &, class MatrixContainer &, const char *, const char *, const char *))
     639bool CreatePlotOrder(class MatrixContainer &Matrix, const class KeySetsContainer &KeySets, const char *dir, const char *prefix, const int keycolumns, const char *key, const char *logscale, const char *extraline, const int mxtics, const int xtics, const char *xlabel, const char *ylabel, const char *xrange, const char *yrange, const char *xargument, const char *uses, void (*CreatePlotLines)(ofstream &, class MatrixContainer &, const char *, const char *, const char *))
    638640{
    639641  stringstream filename;
Note: See TracChangeset for help on using the changeset viewer.