Changes in / [a576eb:79ac03]


Ignore:
Files:
35 added
4 deleted
117 edited

Legend:

Unmodified
Added
Removed

  • src/Actions/FragmentationAction/FragmentationAction.cpp

    ra576eb r79ac03  
    3737#include "Atom/atom.hpp"
    3838#include "CodePatterns/Log.hpp"
     39#include "Fragmentation/Exporters/ExportGraph_ToFiles.hpp"
    3940#include "Fragmentation/Fragmentation.hpp"
     41#include "Fragmentation/Graph.hpp"
    4042#include "Fragmentation/HydrogenSaturation_enum.hpp"
     43#include "Graph/AdjacencyList.hpp"
    4144#include "Graph/DepthFirstSearchAnalysis.hpp"
     45#include "Helpers/defs.hpp"
    4246#include "molecule.hpp"
    4347#include "World.hpp"
    4448
     49#include <boost/filesystem.hpp>
    4550#include <iostream>
     51#include <map>
    4652#include <string>
     53#include <vector>
    4754
    4855#include "Actions/FragmentationAction/FragmentationAction.hpp"
    … …  
    5663Action::state_ptr FragmentationFragmentationAction::performCall() {
    5764  clock_t start,end;
    58   molecule *mol = NULL;
    59   int ExitFlag = 0;
     65  int ExitFlag = -1;
     66  World &world = World::getInstance();
    6067
     68  // inform about used parameters
    6169  LOG(0, "STATUS: Fragmenting molecular system with current connection matrix maximum bond distance "
    6270      << params.distance.get() << " up to "
    … …  
    6573      << params.types.get() << "." << std::endl);
    6674
     75  // check for selected atoms
     76  if (world.beginAtomSelection() == world.endAtomSelection()) {
     77    ELOG(1, "There are not atoms selected for fragmentation.");
     78    return Action::failure;
     79  }
     80
     81  // go through all atoms, note down their molecules and group them
     82  typedef std::multimap<molecule *, atom *> clusters_t;
     83  typedef std::vector<atomId_t> atomids_t;
     84  atomids_t atomids;
     85  clusters_t clusters;
     86  for (World::AtomSelectionConstIterator iter = world.beginAtomSelection();
     87      iter != world.endAtomSelection(); ++iter) {
     88    clusters.insert( std::make_pair(iter->second->getMolecule(), iter->second) );
     89    atomids.push_back(iter->second->getId());
     90  }
     91  LOG(1, "INFO: There are " << clusters.size()  << " molecules to consider.");
     92
     93  // get whether to saturate or not
     94  const enum HydrogenSaturation saturation =  params.DoSaturation.get() ? DoSaturate : DontSaturate;
     95
     96  // parse in Adjacency file
     97  boost::shared_ptr<AdjacencyList> FileChecker;
     98  boost::filesystem::path filename(params.prefix.get() + std::string(ADJACENCYFILE));
     99  if (boost::filesystem::exists(filename) && boost::filesystem::is_regular_file(filename)) {
     100    std::ifstream File;
     101    File.open(filename.string().c_str(), ios::out);
     102    FileChecker.reset(new AdjacencyList(File));
     103    File.close();
     104  } else {
     105    LOG(1, "INFO: Could not open default adjacency file " << filename.string() << ".");
     106    FileChecker.reset(new AdjacencyList);
     107  }
     108
    67109  DepthFirstSearchAnalysis DFS;
    68   for (World::MoleculeSelectionConstIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
    69     mol = iter->second;
    70     ASSERT(mol != NULL, "No molecule has been picked for fragmentation.");
    71     LOG(2, "INFO: Fragmenting molecule with bond distance " << params.distance.get() << " angstroem, order of " << params.order.get() << ".");
    72     start = clock();
    73     if (mol->hasBondStructure()) {
    74       Fragmentation Fragmenter(mol, params.DoSaturation.get() ? DoSaturate : DontSaturate);
    75       Fragmenter.setOutputTypes(params.types.get());
    76       ExitFlag = Fragmenter.FragmentMolecule(params.order.get(), params.prefix.get(), DFS);
     110  start = clock();
     111  // go through all keys (i.e. all molecules)
     112  clusters_t::const_iterator advanceiter;
     113  Graph TotalGraph;
     114  int keysetcounter = 0;
     115  for (clusters_t::const_iterator iter = clusters.begin();
     116      iter != clusters.end();
     117      iter = advanceiter) {
     118    // get iterator to past last atom in this molecule
     119    molecule * mol = iter->first;
     120    advanceiter = clusters.upper_bound(mol);
     121
     122    // copy molecule's atoms' ids as parameters to Fragmentation's AtomMask
     123    std::vector<atomId_t> mols_atomids;
     124    std::transform(iter, advanceiter, std::back_inserter(mols_atomids),
     125        boost::bind( &atom::getNr,
     126            boost::bind( &clusters_t::value_type::second, _1 ))
     127    );
     128    LOG(2, "INFO: Fragmenting in molecule " << mol->getName() << " in " << clusters.count(mol)
     129        << " atoms, out of " << mol->getAtomCount() << ".");
     130    const enum HydrogenSaturation saturation =  params.DoSaturation.get() ? DoSaturate : DontSaturate;
     131    Fragmentation Fragmenter(mol, *FileChecker, saturation);
     132
     133    // perform fragmentation
     134    LOG(0, std::endl << " ========== Fragmentation of molecule " << mol->getName() << " ========================= ");
     135    {
     136      const int tempFlag = Fragmenter.FragmentMolecule(mols_atomids, params.order.get(), params.prefix.get(), DFS);
     137      if ((ExitFlag == 2) && (tempFlag != 2))
     138        ExitFlag = tempFlag; // if there is one molecule that needs further fragmentation, it overrides others
     139      if (ExitFlag == -1)
     140        ExitFlag = tempFlag; // if we are the first, we set the standard
    77141    }
    78     World::getInstance().setExitFlag(ExitFlag);
    79     end = clock();
    80     LOG(0, "STATUS: Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s.");
     142    TotalGraph.InsertGraph(Fragmenter.getGraph(), keysetcounter);
     143
    81144  }
     145  LOG(0, "STATUS: There are " << keysetcounter << " fragments.");
     146
     147  // store molecule's fragment to file
     148  {
     149    ExportGraph_ToFiles exporter(TotalGraph, saturation);
     150    exporter.setPrefix(params.prefix.get());
     151    exporter.setOutputTypes(params.types.get());
     152    exporter();
     153  }
     154
     155  // store Adjacency to file
     156  {
     157    std::string filename = params.prefix.get() + ADJACENCYFILE;
     158    std::ofstream AdjacencyFile;
     159    AdjacencyFile.open(filename.c_str(), ios::out);
     160    AdjacencyList adjacency(atomids);
     161    adjacency.StoreToFile(AdjacencyFile);
     162    AdjacencyFile.close();
     163  }
     164
     165  World::getInstance().setExitFlag(ExitFlag);
     166  end = clock();
     167  LOG(0, "STATUS: Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s.");
     168
    82169  return Action::success;
    83170}

  • src/Actions/GraphAction/DepthFirstSearchAction.cpp

    ra576eb r79ac03  
    4040#include "Graph/CyclicStructureAnalysis.hpp"
    4141#include "Graph/DepthFirstSearchAnalysis.hpp"
     42#include "Graph/ListOfLocalAtoms.hpp"
    4243#include "molecule.hpp"
    4344#include "MoleculeLeafClass.hpp"
    … …  
    5657Action::state_ptr GraphDepthFirstSearchAction::performCall() {
    5758  LOG(1, "Depth-First-Search Analysis.");
    58   atom **ListOfAtoms = NULL;
     59  ListOfLocalAtoms_t ListOfAtoms;
    5960  std::deque<bond *> *LocalBackEdgeStack = NULL;
    6061  DepthFirstSearchAnalysis DFS;
    … …  
    6667    while (Subgraphs->next != NULL) {
    6768      Subgraphs = Subgraphs->next;
    68       ListOfAtoms = NULL;
     69      ListOfAtoms.clear();
    6970      Subgraphs->Leaf->FillListOfLocalAtoms(ListOfAtoms, Subgraphs->Leaf->getAtomCount());
    7071      LocalBackEdgeStack = new std::deque<bond *>; // no need to have it Subgraphs->Leaf->BondCount size
    … …  
    7576      Subgraphs->Leaf = NULL;
    7677      delete(Subgraphs->previous);
    77       delete[](ListOfAtoms);  // allocated by FillListOfLocalAtoms
    7878      FragmentCounter++;
    7979    }

  • src/Actions/MoleculeAction/SaveAdjacencyAction.cpp

    ra576eb r79ac03  
    4040
    4141#include "CodePatterns/Log.hpp"
    42 #include "Graph/BondGraph.hpp"
     42#include "Graph/AdjacencyList.hpp"
    4343#include "molecule.hpp"
    4444#include "World.hpp"
    … …  
    5555  molecule *mol = NULL;
    5656
     57  // gather all desired ids
     58  typedef std::vector<atomId_t> atomids_t;
     59  atomids_t atomids;
    5760  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
    5861    mol = iter->second;
    59     LOG(0, "Storing adjacency to path " << params.adjacencyfile.get() << ".");
    60     // TODO: sollte stream nicht filename benutzen, besser fuer unit test
    61     mol->StoreAdjacencyToFile(params.adjacencyfile.get().leaf().string(), params.adjacencyfile.get().branch_path().string());
     62    const molecule::atomIdSet &mol_atomids = mol->getAtomIds();
     63    atomids.insert(atomids.end(), mol_atomids.begin(), mol_atomids.end());
    6264  }
     65
     66  // store to file
     67  AdjacencyList adjacency(atomids);
     68  std::ofstream AdjacencyFile;
     69  const std::string filename = params.adjacencyfile.get().string();
     70  LOG(0, "STATUS: Storing adjacency of selected molecules to " << filename << ".");
     71  AdjacencyFile.open(filename.c_str(), ios::out);
     72  adjacency.StoreToFile(AdjacencyFile);
     73  AdjacencyFile.close();
     74
    6375  return Action::success;
    6476}

  • src/Atom/atom_bondedparticle.cpp

    ra576eb r79ac03  
    7979  }
    8080  ost << " -- TotalDegree: " << TotalDegree;
    81 };
    82 
    83 /** Output of atom::Nr along with all bond partners.
    84  * \param *AdjacencyFile output stream
    85  */
    86 void BondedParticle::OutputAdjacency(ofstream * const AdjacencyFile) const
    87 {
    88   const BondList& ListOfBonds = getListOfBonds();
    89   *AdjacencyFile << getNr() << "\t";
    90   for (BondList::const_iterator Runner = ListOfBonds.begin(); Runner != ListOfBonds.end(); (++Runner))
    91     *AdjacencyFile << (*Runner)->GetOtherAtom(this)->getNr() << "\t";
    92   *AdjacencyFile << endl;
    9381};
    9482

  • src/Atom/atom_bondedparticle.hpp

    ra576eb r79ac03  
    4747  void resetBondDegree();
    4848  void OutputBondOfAtom(std::ostream &ost) const;
    49   void OutputAdjacency(ofstream * const AdjacencyFile) const;
    5049  void OutputBonds(ofstream * const BondFile) const;
    5150  void OutputOrder(ofstream *file) const;

  • src/Dynamics/LinearInterpolationBetweenSteps.hpp

    ra576eb r79ac03  
    9191      }
    9292    }
    93 
    94 //    // store the list to single step files
    95 //    int *SortIndex = new int[atoms.size()];
    96 //    for (int i=atoms.size(); i--; )
    97 //      SortIndex[i] = i;
    98 //
    99 //    status = MoleculePerStep->OutputConfigForListOfFragments(prefix, SortIndex);
    100 //    delete[](SortIndex);
    10193  };
    10294

  • src/Fragmentation/AdaptivityMap.cpp

    ra576eb r79ac03  
    4242
    4343#include "Atom/atom.hpp"
     44#include "Fragmentation/AtomMask.hpp"
    4445#include "Helpers/defs.hpp"
    4546#include "Helpers/helpers.hpp"
    … …  
    191192/** Marks all candidate sites for update if below adaptive threshold.
    192193 * Picks a given number of highest values and set *AtomMask to true.
    193  * \param *AtomMask defines true/false per global Atom::Nr to mask in/out each nuclear site, used to activate given number of site to increment order adaptively
     194 * \param AtomMask defines true/false per global Atom::Nr to mask in/out each nuclear site, used to activate given number of site to increment order adaptively
    194195 * \param Order desired order
    195196 * \param *mol molecule with atoms
    196197 * \return true - if update is necessary, false - not
    197198 */
    198 bool AdaptivityMap::MarkUpdateCandidates(bool *AtomMask, int Order, molecule *mol) const
    199 {
    200   atom *Walker = NULL;
    201   int No = -1;
    202   bool status = false;
     199bool AdaptivityMap::MarkUpdateCandidates(AtomMask_t &AtomMask, int Order, molecule *mol) const
     200{
    203201  ASSERT( FinalRootCandidates != NULL,
    204202      "AdaptivityMap::MarkUpdateCandidates() - FinalRootCandidates is not allocated yet.");
    205   for(AdaptiveCriteriaValueMap::const_iterator runner = FinalRootCandidates->upper_bound(pow(10.,Order)); runner != FinalRootCandidates->end(); runner++) {
    206     No = (*runner).second.first;
    207     Walker = mol->FindAtom(No);
    208     //if (Walker->AdaptiveOrder < MinimumRingSize[Walker->getNr()]) {
    209       LOG(2, "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", setting entry " << No << " of Atom mask to true.");
    210       AtomMask[No] = true;
    211       status = true;
    212     //} else
    213       //LOG(2, "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", however MinimumRingSize of " << MinimumRingSize[Walker->getNr()] << " does not allow further adaptive increase.");
    214   }
    215   return status;
     203  const AdaptiveCriteriaValueMap::const_iterator enditer = FinalRootCandidates->upper_bound(pow(10.,Order));
     204  for(AdaptiveCriteriaValueMap::const_iterator runner = FinalRootCandidates->begin();
     205      runner != enditer; ++runner) {
     206    const int No = (*runner).second.first;
     207    const atom *Walker = mol->FindAtom(No);
     208    LOG(2, "Root " << No << " is already below threshold (10^{" << Order <<"}: " << runner->first << ", setting entry " << No << " of Atom mask to false.");
     209    AtomMask.setFalse(No);
     210  }
     211  return enditer != FinalRootCandidates->end();
    216212};
    217213

  • src/Fragmentation/AdaptivityMap.hpp

    ra576eb r79ac03  
    2121#include "Fragmentation/KeySet.hpp"
    2222
     23class AtomMask_t;
    2324class molecule;
    2425
    … …  
    3334  void ReMapAdaptiveCriteriaListToValue(molecule *mol);
    3435  int CountLinesinFile(std::ifstream &InputFile) const;
    35   bool MarkUpdateCandidates(bool *AtomMask, int Order, molecule *mol) const ;
     36  bool MarkUpdateCandidates(AtomMask_t &AtomMask, int Order, molecule *mol) const ;
    3637
    3738  bool IsAdaptiveCriteriaListEmpty() const;

  • src/Fragmentation/Fragmentation.cpp

    ra576eb r79ac03  
    4646#include "Element/periodentafel.hpp"
    4747#include "Fragmentation/AdaptivityMap.hpp"
     48#include "Fragmentation/AtomMask.hpp"
    4849#include "Fragmentation/fragmentation_helpers.hpp"
    4950#include "Fragmentation/Graph.hpp"
     51#include "Fragmentation/helpers.hpp"
    5052#include "Fragmentation/KeySet.hpp"
    5153#include "Fragmentation/PowerSetGenerator.hpp"
    5254#include "Fragmentation/UniqueFragments.hpp"
    5355#include "Graph/BondGraph.hpp"
    54 #include "Graph/CheckAgainstAdjacencyFile.hpp"
     56#include "Graph/AdjacencyList.hpp"
     57#include "Graph/ListOfLocalAtoms.hpp"
    5558#include "molecule.hpp"
    56 #include "MoleculeLeafClass.hpp"
    57 #include "MoleculeListClass.hpp"
    58 #include "Parser/FormatParserStorage.hpp"
    5959#include "World.hpp"
    6060
    … …  
    6363 *
    6464 * \param _mol molecule for internal use (looking up atoms)
     65 * \param _FileChecker instance contains adjacency parsed from elsewhere
    6566 * \param _saturation whether to treat hydrogen special and saturate dangling bonds or not
    6667 */
    67 Fragmentation::Fragmentation(molecule *_mol, const enum HydrogenSaturation _saturation) :
     68Fragmentation::Fragmentation(molecule *_mol, AdjacencyList &_FileChecker, const enum HydrogenSaturation _saturation) :
    6869  mol(_mol),
    69   saturation(_saturation)
     70  saturation(_saturation),
     71  FileChecker(_FileChecker)
    7072{}
    7173
    … …  
    8991 * of vertex indices: Global always means the index in "this" molecule, whereas local refers to the molecule or
    9092 * subgraph in the MoleculeListClass.
     93 * \param atomids atomic ids (local to Fragmentation::mol) to fragment, used in AtomMask
    9194 * \param Order up to how many neighbouring bonds a fragment contains in BondOrderScheme::BottumUp scheme
    9295 * \param prefix prefix string for every fragment file name (may include path)
    … …  
    9497 * \return 1 - continue, 2 - stop (no fragmentation occured)
    9598 */
    96 int Fragmentation::FragmentMolecule(int Order, std::string prefix, DepthFirstSearchAnalysis &DFS)
    97 {
    98   MoleculeListClass *BondFragments = NULL;
    99   int FragmentCounter;
    100   MoleculeLeafClass *MolecularWalker = NULL;
    101   MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
    102   fstream File;
    103   bool FragmentationToDo = true;
     99int Fragmentation::FragmentMolecule(const std::vector<atomId_t> &atomids, int Order, std::string prefix, DepthFirstSearchAnalysis &DFS)
     100{
     101  std::fstream File;
    104102  bool CheckOrder = false;
    105   Graph **FragmentList = NULL;
    106   Graph TotalGraph;     // graph with all keysets however local numbers
    107103  int TotalNumberOfKeySets = 0;
    108   atom ***ListOfLocalAtoms = NULL;
    109   bool *AtomMask = NULL;
    110 
    111   LOG(0, endl);
     104
     105  LOG(0, std::endl);
    112106  switch (saturation) {
    113107    case DoSaturate:
    … …  
    123117
    124118  // ++++++++++++++++++++++++++++ INITIAL STUFF: Bond structure analysis, file parsing, ... ++++++++++++++++++++++++++++++++++++++++++
     119  bool FragmentationToDo = true;
    125120
    126121  // ===== 1. Check whether bond structure is same as stored in files ====
    … …  
    128123  // === compare it with adjacency file ===
    129124  {
    130     std::ifstream File;
    131     std::string filename;
    132     filename = prefix + ADJACENCYFILE;
    133     File.open(filename.c_str(), ios::out);
    134     LOG(1, "Looking at bond structure stored in adjacency file and comparing to present one ... ");
    135 
    136     CheckAgainstAdjacencyFile FileChecker(World::getInstance().beginAtomSelection(), World::getInstance().endAtomSelection());
    137     FragmentationToDo = FragmentationToDo && FileChecker(File);
    138   }
    139 
    140   // === reset bond degree and perform CorrectBondDegree ===
    141   for(World::MoleculeIterator iter = World::getInstance().getMoleculeIter();
    142       iter != World::getInstance().moleculeEnd();
    143       ++iter) {
    144     // correct bond degree
    145     World::AtomComposite Set = (*iter)->getAtomSet();
    146     World::getInstance().getBondGraph()->CorrectBondDegree(Set);
    147   }
    148 
    149   // ===== 2. perform a DFS analysis to gather info on cyclic structure and a list of disconnected subgraphs =====
    150   // NOTE: We assume here that DFS has been performed and molecule structure is current.
    151   Subgraphs = DFS.getMoleculeStructure();
     125    const std::vector<atomId_t> globalids = getGlobalIdsFromLocalIds(*mol, atomids);
     126    AdjacencyList WorldAdjacency(globalids);
     127    FragmentationToDo = FragmentationToDo && (FileChecker > WorldAdjacency);
     128  }
     129
     130  // ===== 2. create AtomMask that takes Saturation condition into account
     131  AtomMask_t AtomMask(atomids);
     132  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
     133    // remove in hydrogen and we do saturate
     134    if ((saturation == DoSaturate) && ((*iter)->getType()->getAtomicNumber() == 1)) // skip hydrogen
     135      AtomMask.setFalse((*iter)->getNr());
     136  }
    152137
    153138  // ===== 3. if structure still valid, parse key set file and others =====
    … …  
    156141
    157142  // ===== 4. check globally whether there's something to do actually (first adaptivity check)
    158   FragmentationToDo = FragmentationToDo && ParseOrderAtSiteFromFile(prefix);
     143  FragmentationToDo = FragmentationToDo && ParseOrderAtSiteFromFile(atomids, prefix);
    159144
    160145  // =================================== Begin of FRAGMENTATION ===============================
    161146  // ===== 6a. assign each keyset to its respective subgraph =====
    162   const int MolCount = World::getInstance().numMolecules();
    163   ListOfLocalAtoms = new atom **[MolCount];
    164   for (int i=0;i<MolCount;i++)
    165     ListOfLocalAtoms[i] = NULL;
    166   FragmentCounter = 0;
    167   Subgraphs->next->AssignKeySetsToFragment(mol, &ParsedFragmentList, ListOfLocalAtoms, FragmentList, FragmentCounter, true);
    168   delete[](ListOfLocalAtoms);
     147  ListOfLocalAtoms_t ListOfLocalAtoms;
     148  Graph FragmentList;
     149  AssignKeySetsToFragment(ParsedFragmentList, ListOfLocalAtoms, FragmentList, true);
    169150
    170151  // ===== 6b. prepare and go into the adaptive (Order<0), single-step (Order==0) or incremental (Order>0) cycle
    171   KeyStack *RootStack = new KeyStack[Subgraphs->next->Count()];
    172   AtomMask = new bool[mol->getAtomCount()+1];
    173   AtomMask[mol->getAtomCount()] = false;
     152  KeyStack RootStack;
    174153  FragmentationToDo = false;  // if CheckOrderAtSite just ones recommends fragmentation, we will save fragments afterwards
    175   while ((CheckOrder = CheckOrderAtSite(AtomMask, &ParsedFragmentList, Order, prefix))) {
     154  bool LoopDoneAlready = false;
     155  while ((CheckOrder = CheckOrderAtSite(AtomMask, ParsedFragmentList, Order, prefix, LoopDoneAlready))) {
    176156    FragmentationToDo = FragmentationToDo || CheckOrder;
    177     AtomMask[mol->getAtomCount()] = true;   // last plus one entry is used as marker that we have been through this loop once already in CheckOrderAtSite()
     157    LoopDoneAlready = true;   // last plus one entry is used as marker that we have been through this loop once already in CheckOrderAtSite()
    178158    // ===== 6b. fill RootStack for each subgraph (second adaptivity check) =====
    179     Subgraphs->next->FillRootStackForSubgraphs(RootStack, AtomMask, (FragmentCounter = 0), saturation);
    180 
    181     // ===== 7. fill the bond fragment list =====
    182     FragmentCounter = 0;
    183     MolecularWalker = Subgraphs;
    184     while (MolecularWalker->next != NULL) {
    185       MolecularWalker = MolecularWalker->next;
    186       LOG(1, "Fragmenting subgraph " << MolecularWalker << ".");
    187       if (MolecularWalker->Leaf->hasBondStructure()) {
    188         // call BOSSANOVA method
    189         LOG(0, endl << " ========== BOND ENERGY of subgraph " << FragmentCounter << " ========================= ");
    190         FragmentBOSSANOVA(MolecularWalker->Leaf, FragmentList[FragmentCounter], RootStack[FragmentCounter]);
    191       } else {
    192         ELOG(1, "Subgraph " << MolecularWalker << " has no atoms!");
    193       }
    194       FragmentCounter++;  // next fragment list
    195     }
     159    FillRootStackForSubgraphs(RootStack, AtomMask);
     160
     161    // call BOSSANOVA method
     162    FragmentBOSSANOVA(mol, FragmentList, RootStack);
    196163  }
    197164  LOG(2, "CheckOrder is " << CheckOrder << ".");
    198   delete[](RootStack);
    199   delete[](AtomMask);
    200165
    201166  // ==================================== End of FRAGMENTATION ============================================
    202167
    203168  // ===== 8a. translate list into global numbers (i.e. ones that are valid in "this" molecule, not in MolecularWalker->Leaf)
    204   Subgraphs->next->TranslateIndicesToGlobalIDs(FragmentList, (FragmentCounter = 0), TotalNumberOfKeySets, TotalGraph);
    205 
    206   // free subgraph memory again
    207   FragmentCounter = 0;
    208   while (Subgraphs != NULL) {
    209     // remove entry in fragment list
    210     // remove subgraph fragment
    211     MolecularWalker = Subgraphs->next;
    212     Subgraphs->Leaf = NULL;
    213     delete(Subgraphs);
    214     Subgraphs = MolecularWalker;
    215   }
    216   // free fragment list
    217   for (int i=0; i< FragmentCounter; ++i )
    218     delete(FragmentList[i]);
    219   delete[](FragmentList);
    220 
    221   LOG(0, FragmentCounter << " subgraph fragments have been removed.");
    222 
    223   // ===== 8b. gather keyset lists (graphs) from all subgraphs and transform into MoleculeListClass =====
    224   //if (FragmentationToDo) {    // we should always store the fragments again as coordination might have changed slightly without changing bond structure
    225   // allocate memory for the pointer array and transmorph graphs into full molecular fragments
    226   BondFragments = new MoleculeListClass(World::getPointer());
    227   int k=0;
    228   for(Graph::iterator runner = TotalGraph.begin(); runner != TotalGraph.end(); runner++) {
    229     KeySet test = (*runner).first;
    230     LOG(0, "Fragment No." << (*runner).second.first << " with TEFactor " << (*runner).second.second << ".");
    231     BondFragments->insert(StoreFragmentFromKeySet(test, World::getInstance().getConfig()));
    232     k++;
    233   }
    234   LOG(0, k << "/" << BondFragments->ListOfMolecules.size() << " fragments generated from the keysets.");
    235 
    236   // ===== 9. Save fragments' configuration and keyset files et al to disk ===
    237   if (BondFragments->ListOfMolecules.size() != 0) {
    238     // create the SortIndex from BFS labels to order in the config file
    239     int *SortIndex = NULL;
    240     CreateMappingLabelsToConfigSequence(SortIndex);
    241 
    242     LOG(1, "Writing " << BondFragments->ListOfMolecules.size() << " possible bond fragmentation configs");
    243     bool write_status = true;
    244     for (std::vector<std::string>::const_iterator iter = typelist.begin();
    245         iter != typelist.end();
    246         ++iter) {
    247       LOG(2, "INFO: Writing bond fragments for type " << (*iter) << ".");
    248       write_status = write_status
    249       && BondFragments->OutputConfigForListOfFragments(
    250           prefix,
    251           SortIndex,
    252           FormatParserStorage::getInstance().getTypeFromName(*iter));
    253     }
    254     if (write_status)
    255       LOG(1, "All configs written.");
    256     else
    257       LOG(1, "Some config writing failed.");
    258 
    259     // store force index reference file
    260     BondFragments->StoreForcesFile(prefix, SortIndex);
    261 
    262     // store keysets file
    263     TotalGraph.StoreKeySetFile(prefix);
    264 
    265     {
    266       // store Adjacency file
    267       std::string filename = prefix + ADJACENCYFILE;
    268       mol->StoreAdjacencyToFile(filename);
    269     }
    270 
    271     // store Hydrogen saturation correction file
    272     BondFragments->AddHydrogenCorrection(prefix);
    273 
    274     // store adaptive orders into file
    275     StoreOrderAtSiteFile(prefix);
    276 
    277     // restore orbital and Stop values
    278     //CalculateOrbitals(*configuration);
    279 
    280     // free memory for bond part
    281     LOG(1, "Freeing bond memory");
    282     delete[](SortIndex);
    283   } else {
    284     LOG(1, "FragmentList is zero on return, splitting failed.");
    285   }
    286   // remove all create molecules again from the World including their atoms
    287   for (MoleculeList::iterator iter = BondFragments->ListOfMolecules.begin();
    288       !BondFragments->ListOfMolecules.empty();
    289       iter = BondFragments->ListOfMolecules.begin()) {
    290     // remove copied atoms and molecule again
    291     molecule *mol = *iter;
    292     mol->removeAtomsinMolecule();
    293     World::getInstance().destroyMolecule(mol);
    294     BondFragments->ListOfMolecules.erase(iter);
    295   }
    296   delete(BondFragments);
     169  TranslateIndicesToGlobalIDs(FragmentList, TotalNumberOfKeySets, TotalGraph);
     170
     171  LOG(1, "STATUS: We have created " << TotalGraph.size() << " fragments.");
     172
     173
     174  // store adaptive orders into file
     175  StoreOrderAtSiteFile(prefix);
     176
    297177  LOG(0, "End of bond fragmentation.");
    298 
    299178  return ((int)(!FragmentationToDo)+1);    // 1 - continue, 2 - stop (no fragmentation occured)
    300179};
    … …  
    317196 * \return pointer to Graph list
    318197 */
    319 void Fragmentation::FragmentBOSSANOVA(molecule *mol, Graph *&FragmentList, KeyStack &RootStack)
    320 {
     198void Fragmentation::FragmentBOSSANOVA(molecule *mol, Graph &FragmentList, KeyStack &RootStack)
     199{
     200  Info FunctionInfo(__func__);
    321201  Graph ***FragmentLowerOrdersList = NULL;
    322202  int NumLevels = 0;
    … …  
    330210  int RootNr = 0;
    331211  UniqueFragments FragmentSearch;
    332 
    333   LOG(0, "Begin of FragmentBOSSANOVA.");
    334212
    335213  // FragmentLowerOrdersList is a 2D-array of pointer to MoleculeListClass objects, one dimension represents the ANOVA expansion of a single order (i.e. 5)
    … …  
    420298  FreeAllOrdersList(FragmentLowerOrdersList, RootStack, mol);
    421299  delete[](NumMoleculesOfOrder);
    422 
    423   LOG(0, "End of FragmentBOSSANOVA.");
    424300};
    425 
    426 /** Stores a fragment from \a KeySet into \a molecule.
    427  * First creates the minimal set of atoms from the KeySet, then creates the bond structure from the complete
    428  * molecule and adds missing hydrogen where bonds were cut.
    429  * \param *out output stream for debugging messages
    430  * \param &Leaflet pointer to KeySet structure
    431  * \param IsAngstroem whether we have Ansgtroem or bohrradius
    432  * \return pointer to constructed molecule
    433  */
    434 molecule * Fragmentation::StoreFragmentFromKeySet(KeySet &Leaflet, bool IsAngstroem)
    435 {
    436   Info info(__func__);
    437   atom **SonList = new atom*[mol->getAtomCount()+1];
    438   molecule *Leaf = World::getInstance().createMolecule();
    439 
    440   for(int i=0;i<=mol->getAtomCount();i++)
    441     SonList[i] = NULL;
    442 
    443   StoreFragmentFromKeySet_Init(mol, Leaf, Leaflet, SonList);
    444   // create the bonds between all: Make it an induced subgraph and add hydrogen
    445 //  LOG(2, "Creating bonds from father graph (i.e. induced subgraph creation).");
    446   CreateInducedSubgraphOfFragment(mol, Leaf, SonList, IsAngstroem);
    447 
    448   //Leaflet->Leaf->ScanForPeriodicCorrection(out);
    449   delete[](SonList);
    450   return Leaf;
    451 };
    452 
    453301
    454302/** Estimates by educated guessing (using upper limit) the expected number of fragments.
    … …  
    471319    c = (ListOfBonds.size() > c) ? ListOfBonds.size() : c;
    472320  }
    473   FragmentCount = mol->getNoNonHydrogen()*(1 << (c*order));
     321  FragmentCount = (saturation == DoSaturate ? mol->getNoNonHydrogen() : mol->getAtomCount()) *(1 << (c*order));
    474322  LOG(1, "Upper limit for this subgraph is " << FragmentCount << " for "
    475323      << mol->getNoNonHydrogen() << " non-H atoms with maximum bond degree of " << c << ".");
    … …  
    479327
    480328/** Checks whether the OrderAtSite is still below \a Order at some site.
    481  * \param *AtomMask defines true/false per global Atom::Nr to mask in/out each nuclear site, used to activate given number of site to increment order adaptively
     329 * \param AtomMask defines true/false per global Atom::Nr to mask in/out each nuclear site, used to activate given number of site to increment order adaptively
    482330 * \param *GlobalKeySetList list of keysets with global ids (valid in "this" molecule) needed for adaptive increase
    483331 * \param Order desired Order if positive, desired exponent in threshold criteria if negative (0 is single-step)
    484332 * \param path path to ENERGYPERFRAGMENT file (may be NULL if Order is non-negative)
     333 * \param LoopDoneAlready indicate whether we have done a fragmentation loop already
    485334 * \return true - needs further fragmentation, false - does not need fragmentation
    486335 */
    487 bool Fragmentation::CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, std::string path)
     336bool Fragmentation::CheckOrderAtSite(AtomMask_t &AtomMask, const Graph &GlobalKeySetList, int Order, std::string path, bool LoopDoneAlready)
    488337{
    489338  bool status = false;
    490339
    491   // initialize mask list
    492   for(int i=mol->getAtomCount();i--;)
    493     AtomMask[i] = false;
    494 
    495340  if (Order < 0) { // adaptive increase of BondOrder per site
    496     if (AtomMask[mol->getAtomCount()] == true)  // break after one step
     341    if (LoopDoneAlready)  // break after one step
    497342      return false;
    498343
    499344    // transmorph graph keyset list into indexed KeySetList
    500     if (GlobalKeySetList == NULL) {
    501       ELOG(1, "Given global key set list (graph) is NULL!");
    502       return false;
    503     }
    504     AdaptivityMap * IndexKeySetList = GlobalKeySetList->GraphToAdaptivityMap();
     345    AdaptivityMap * IndexKeySetList = GlobalKeySetList.GraphToAdaptivityMap();
    505346
    506347    // parse the EnergyPerFragment file
    … …  
    512353    if (IndexKeySetList->IsAdaptiveCriteriaListEmpty()) {
    513354      ELOG(2, "Unable to parse file, incrementing all.");
    514       for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    515         if ((saturation == DontSaturate) || ((*iter)->getType()->getAtomicNumber() != 1)) // skip hydrogen
    516         {
    517           AtomMask[(*iter)->getNr()] = true;  // include all (non-hydrogen) atoms
    518           status = true;
    519         }
    520       }
     355      status = true;
    521356    } else {
    522       IndexKeySetList->MarkUpdateCandidates(AtomMask, Order, mol);
     357      // mark as false all sites that are below threshold already
     358      status = IndexKeySetList->MarkUpdateCandidates(AtomMask, Order, mol);
    523359    }
    524360
    … …  
    526362  } else { // global increase of Bond Order
    527363    for(molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
    528       if ((saturation == DontSaturate) || ((*iter)->getType()->getAtomicNumber() != 1)) // skip hydrogen
    529       {
    530         AtomMask[(*iter)->getNr()] = true;  // include all (non-hydrogen) atoms
    531         if ((Order != 0) && ((*iter)->AdaptiveOrder < Order)) // && ((*iter)->AdaptiveOrder < MinimumRingSize[(*iter)->getNr()]))
     364      if (AtomMask.isTrue((*iter)->getNr())) { // skip masked out
     365        // remove all that have reached desired order
     366        if ((Order != 0) && ((*iter)->AdaptiveOrder >= Order)) // && ((*iter)->AdaptiveOrder < MinimumRingSize[(*iter)->getNr()]))
     367          AtomMask.setFalse((*iter)->getNr());
     368        else
    532369          status = true;
    533370      }
    534371    }
    535     if ((!Order) && (!AtomMask[mol->getAtomCount()]))  // single stepping, just check
     372    if ((!Order) && (!LoopDoneAlready))  // single stepping, just check
    536373      status = true;
    537374
    … …  
    576413/** Parses pairs(Atom::Nr, Atom::AdaptiveOrder) from file and stores in molecule's Atom's.
    577414 * Atoms not present in the file get "0".
     415 * \param atomids atoms to fragment, used in AtomMask
    578416 * \param &path path to file ORDERATSITEFILEe
    579417 * \return true - file found and scanned, false - file not found
    580418 * \sa ParseKeySetFile() and CheckAdjacencyFileAgainstMolecule() as this is meant to be used in conjunction with the two
    581419 */
    582 bool Fragmentation::ParseOrderAtSiteFromFile(std::string &path)
    583 {
    584   unsigned char *OrderArray = new unsigned char[mol->getAtomCount()];
    585   bool *MaxArray = new bool[mol->getAtomCount()];
     420bool Fragmentation::ParseOrderAtSiteFromFile(const std::vector<atomId_t> &atomids, std::string &path)
     421{
     422  Info FunctionInfo(__func__);
     423  typedef unsigned char order_t;
     424  typedef std::map<atomId_t, order_t> OrderArray_t;
     425  OrderArray_t OrderArray;
     426  AtomMask_t MaxArray(atomids);
    586427  bool status;
    587428  int AtomNr, value;
    … …  
    589430  ifstream file;
    590431
    591   for(int i=0;i<mol->getAtomCount();i++) {
    592     OrderArray[i] = 0;
    593     MaxArray[i] = false;
    594   }
    595 
    596   LOG(1, "Begin of ParseOrderAtSiteFromFile");
    597432  line = path + ORDERATSITEFILE;
    598433  file.open(line.c_str());
    … …  
    605440        OrderArray[AtomNr] = value;
    606441        file >> value;
    607         MaxArray[AtomNr] = value;
     442        MaxArray.setValue(AtomNr, (bool)value);
    608443        //LOG(2, "AtomNr " << AtomNr << " with order " << (int)OrderArray[AtomNr] << " and max order set to " << (int)MaxArray[AtomNr] << ".");
    609444      }
    … …  
    614449    for(molecule::iterator iter=mol->begin();iter!=mol->end();++iter){
    615450      (*iter)->AdaptiveOrder = OrderArray[(*iter)->getNr()];
    616       (*iter)->MaxOrder = MaxArray[(*iter)->getNr()];
     451      (*iter)->MaxOrder = MaxArray.isTrue((*iter)->getNr());
    617452    }
    618453    //SetAtomValueToIndexedArray( OrderArray, &atom::getNr(), &atom::AdaptiveOrder );
    … …  
    625460    status = false;
    626461  }
    627   delete[](OrderArray);
    628   delete[](MaxArray);
    629 
    630   LOG(1, "End of ParseOrderAtSiteFromFile");
     462
    631463  return status;
    632464};
    633465
    634 /** Create a SortIndex to map from atomic labels to the sequence in which the atoms are given in the config file.
    635  * \param *out output stream for debugging
    636  * \param *&SortIndex Mapping array of size molecule::AtomCount
    637  * \return true - success, false - failure of SortIndex alloc
    638  */
    639 bool Fragmentation::CreateMappingLabelsToConfigSequence(int *&SortIndex)
    640 {
    641   if (SortIndex != NULL) {
    642     LOG(1, "SortIndex is " << SortIndex << " and not NULL as expected.");
     466/** Fills the root stack for sites to be used as root in fragmentation depending on order or adaptivity criteria
     467 * Again, as in \sa FillBondStructureFromReference steps recursively through each Leaf in this chain list of molecule's.
     468 * \param &RootStack stack to be filled
     469 * \param AtomMask defines true/false per global Atom::Nr to mask in/out each nuclear site
     470 * \return true - stack is non-empty, fragmentation necessary, false - stack is empty, no more sites to update
     471 */
     472void Fragmentation::FillRootStackForSubgraphs(KeyStack &RootStack, const AtomMask_t &AtomMask)
     473{
     474  for(molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
     475    const atom * const Father = (*iter)->GetTrueFather();
     476    if (AtomMask.isTrue(Father->getNr())) // apply mask
     477      if ((saturation == DontSaturate) || ((*iter)->getType()->getAtomicNumber() != 1)) // skip hydrogen
     478        RootStack.push_front((*iter)->getNr());
     479  }
     480}
     481
     482/** The indices per keyset are compared to the respective father's Atom::Nr in each subgraph and thus put into \a **&FragmentList.
     483 * \param *KeySetList list with all keysets
     484 * \param ListOfLocalAtoms Lookup table for each subgraph and index of each atom in global molecule, may be NULL on start, then it is filled
     485 * \param **&FragmentList list to be allocated and returned
     486 * \param FreeList true - ***ListOfLocalAtoms is free'd before return, false - it is not
     487 * \retuen true - success, false - failure
     488 */
     489bool Fragmentation::AssignKeySetsToFragment(Graph &KeySetList, ListOfLocalAtoms_t &ListOfLocalAtoms, Graph &FragmentList, bool FreeList)
     490{
     491  Info FunctionInfo(__func__);
     492  bool status = true;
     493  size_t KeySetCounter = 0;
     494
     495  // fill ListOfLocalAtoms if NULL was given
     496  if (!mol->FillListOfLocalAtoms(ListOfLocalAtoms, mol->getAtomCount())) {
     497    LOG(1, "Filling of ListOfLocalAtoms failed.");
    643498    return false;
    644499  }
    645   SortIndex = new int[mol->getAtomCount()+1];
    646   for(int i=mol->getAtomCount()+1;i--;)
    647     SortIndex[i] = -1;
    648 
    649   int AtomNo = 0;
    650   for(molecule::const_iterator iter=mol->begin();iter!=mol->end();++iter){
    651     ASSERT(SortIndex[(*iter)->getNr()]==-1,"Same SortIndex set twice");
    652     SortIndex[(*iter)->getNr()] = AtomNo++;
    653   }
    654 
    655   return true;
    656 };
    657 
    658 
    659 /** Initializes some value for putting fragment of \a *mol into \a *Leaf.
    660  * \param *mol total molecule
    661  * \param *Leaf fragment molecule
    662  * \param &Leaflet pointer to KeySet structure
    663  * \param **SonList calloc'd list which atom of \a *Leaf is a son of which atom in \a *mol
    664  * \return number of atoms in fragment
    665  */
    666 int Fragmentation::StoreFragmentFromKeySet_Init(molecule *mol, molecule *Leaf, KeySet &Leaflet, atom **SonList)
    667 {
    668   atom *FatherOfRunner = NULL;
    669 
    670   // first create the minimal set of atoms from the KeySet
    671   int size = 0;
    672   for(KeySet::iterator runner = Leaflet.begin(); runner != Leaflet.end(); runner++) {
    673     FatherOfRunner = mol->FindAtom((*runner));  // find the id
    674     SonList[FatherOfRunner->getNr()] = Leaf->AddCopyAtom(FatherOfRunner);
    675     size++;
    676   }
    677   return size;
    678 };
    679 
    680 
    681 /** Creates an induced subgraph out of a fragmental key set, adding bonds and hydrogens (if treated specially).
    682  * \param *out output stream for debugging messages
    683  * \param *mol total molecule
    684  * \param *Leaf fragment molecule
    685  * \param IsAngstroem whether we have Ansgtroem or bohrradius
    686  * \param **SonList list which atom of \a *Leaf is a son of which atom in \a *mol
    687  */
    688 void Fragmentation::CreateInducedSubgraphOfFragment(molecule *mol, molecule *Leaf, atom **SonList, bool IsAngstroem)
    689 {
    690   bool LonelyFlag = false;
    691   atom *OtherFather = NULL;
    692   atom *FatherOfRunner = NULL;
    693 
    694   // we increment the iter just before skipping the hydrogen
    695   // as we use AddBond, we cannot have a const_iterator here
    696   for (molecule::iterator iter = Leaf->begin(); iter != Leaf->end();) {
    697     LonelyFlag = true;
    698     FatherOfRunner = (*iter)->father;
    699     ASSERT(FatherOfRunner,"Atom without father found");
    700     if (SonList[FatherOfRunner->getNr()] != NULL)  {  // check if this, our father, is present in list
    701       // create all bonds
    702       const BondList& ListOfBonds = FatherOfRunner->getListOfBonds();
    703       for (BondList::const_iterator BondRunner = ListOfBonds.begin();
    704           BondRunner != ListOfBonds.end();
    705           ++BondRunner) {
    706         OtherFather = (*BondRunner)->GetOtherAtom(FatherOfRunner);
    707         if (SonList[OtherFather->getNr()] != NULL) {
    708 //          LOG(2, "INFO: Father " << *FatherOfRunner << " of son " << *SonList[FatherOfRunner->getNr()]
    709 //              << " is bound to " << *OtherFather << ", whose son is "
    710 //              << *SonList[OtherFather->getNr()] << ".");
    711           if (OtherFather->getNr() > FatherOfRunner->getNr()) { // add bond (Nr check is for adding only one of both variants: ab, ba)
    712             std::stringstream output;
    713 //            output << "ACCEPT: Adding Bond: "
    714             output << Leaf->AddBond((*iter), SonList[OtherFather->getNr()], (*BondRunner)->BondDegree);
    715 //            LOG(3, output.str());
    716             //NumBonds[(*iter)->getNr()]++;
    717           } else {
    718 //            LOG(3, "REJECY: Not adding bond, labels in wrong order.");
    719           }
    720           LonelyFlag = false;
    721         } else {
    722 //          LOG(2, "INFO: Father " << *FatherOfRunner << " of son " << *SonList[FatherOfRunner->getNr()]
    723 //              << " is bound to " << *OtherFather << ", who has no son in this fragment molecule.");
    724           if (saturation == DoSaturate) {
    725 //          LOG(3, "ACCEPT: Adding Hydrogen to " << (*iter)->Name << " and a bond in between.");
    726             if (!Leaf->AddHydrogenReplacementAtom((*BondRunner), (*iter), FatherOfRunner, OtherFather, IsAngstroem))
    727               exit(1);
    728           }
    729           //NumBonds[(*iter)->getNr()] += Binder->BondDegree;
    730         }
     500
     501  if (KeySetList.size() != 0) { // if there are some scanned keysets at all
     502    // assign scanned keysets
     503    KeySet TempSet;
     504    for (Graph::iterator runner = KeySetList.begin(); runner != KeySetList.end(); runner++) { // key sets contain global numbers!
     505      if (ListOfLocalAtoms[mol->FindAtom(*((*runner).first.begin()))->getNr()] != NULL) {// as we may assume that that bond structure is unchanged, we only test the first key in each set
     506        // translate keyset to local numbers
     507        for (KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
     508          TempSet.insert(ListOfLocalAtoms[mol->FindAtom(*sprinter)->getNr()]->getNr());
     509        // insert into FragmentList
     510        FragmentList.insert(GraphPair(TempSet, pair<int, double> (KeySetCounter++, (*runner).second.second)));
    731511      }
    732     } else {
    733     ELOG(1, "Son " << (*iter)->getName() << " has father " << FatherOfRunner->getName() << " but its entry in SonList is " << SonList[FatherOfRunner->getNr()] << "!");
    734     }
    735     if ((LonelyFlag) && (Leaf->getAtomCount() > 1)) {
    736       LOG(0, **iter << "has got bonds only to hydrogens!");
    737     }
    738     ++iter;
    739     if (saturation == DoSaturate) {
    740       while ((iter != Leaf->end()) && ((*iter)->getType()->getAtomicNumber() == 1)){ // skip added hydrogen
    741         iter++;
    742       }
    743     }
    744   }
    745 };
    746 
    747 /** Sets the desired output types of the fragment configurations.
    748  *
    749  * @param types vector of desired types.
    750  */
    751 void Fragmentation::setOutputTypes(const std::vector<std::string> &types)
    752 {
    753   typelist = types;
     512      TempSet.clear();
     513    }
     514  } else
     515    LOG(1, "KeySetList is NULL or empty.");
     516
     517  if (FreeList) {
     518    // free the index lookup list
     519    ListOfLocalAtoms.clear();
     520  }
     521  return status;
    754522}
     523
     524/** Translate list into global numbers (i.e. ones that are valid in "this" molecule, not in MolecularWalker->Leaf)
     525 * \param &FragmentList Graph with local numbers per fragment
     526 * \param &TotalNumberOfKeySets global key set counter
     527 * \param &TotalGraph Graph to be filled with global numbers
     528 */
     529void Fragmentation::TranslateIndicesToGlobalIDs(Graph &FragmentList, int &TotalNumberOfKeySets, Graph &TotalGraph)
     530{
     531  Info FunctionInfo(__func__);
     532  for (Graph::iterator runner = FragmentList.begin(); runner != FragmentList.end(); runner++) {
     533    KeySet TempSet;
     534    for (KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
     535      TempSet.insert((mol->FindAtom(*sprinter))->GetTrueFather()->getId());
     536    TotalGraph.insert(GraphPair(TempSet, pair<int, double> (TotalNumberOfKeySets++, (*runner).second.second)));
     537  }
     538}
     539

  • src/Fragmentation/Fragmentation.hpp

    ra576eb r79ac03  
    1414#endif
    1515
    16 #include <string>
    17 
    1816#include "Graph/DepthFirstSearchAnalysis.hpp"
    1917
     18#include "Fragmentation/fragmentation_helpers.hpp"
     19#include "Fragmentation/Graph.hpp"
    2020#include "Fragmentation/HydrogenSaturation_enum.hpp"
    21 #include "Fragmentation/fragmentation_helpers.hpp"
     21#include "types.hpp"
    2222
     23#include <map>
    2324#include <string>
    2425#include <vector>
    2526
    2627class atom;
    27 class Graph;
     28class AtomMask_t;
     29class AdjacencyList;
    2830class KeySet;
    2931class molecule;
    … …  
    3234{
    3335public:
    34   Fragmentation(molecule *_mol, const enum HydrogenSaturation _saturation);
     36  Fragmentation(molecule *_mol, AdjacencyList &_FileChecker, const enum HydrogenSaturation _saturation);
    3537  ~Fragmentation();
    3638
    37   int FragmentMolecule(int Order, std::string prefix, DepthFirstSearchAnalysis &DFS);
     39  int FragmentMolecule(const std::vector<atomId_t> &atomids, int Order, std::string prefix, DepthFirstSearchAnalysis &DFS);
    3840
    39   void setOutputTypes(const std::vector<std::string> &types);
     41  const Graph& getGraph() const {
     42    return TotalGraph;
     43  }
    4044
    4145private:
    4246
    43   void FragmentBOSSANOVA(molecule *mol, Graph *&FragmentList, KeyStack &RootStack);
     47  void FragmentBOSSANOVA(molecule *mol, Graph &FragmentList, KeyStack &RootStack);
    4448  int GuesstimateFragmentCount(int order);
    4549
    46   bool CreateMappingLabelsToConfigSequence(int *&SortIndex);
    47 
    4850  // order at site
    49   bool CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, std::string path);
     51  bool CheckOrderAtSite(AtomMask_t &AtomMask, const Graph &GlobalKeySetList, int Order, std::string path, bool LoopDoneAlready);
    5052  bool StoreOrderAtSiteFile(std::string &path);
    51   bool ParseOrderAtSiteFromFile(std::string &path);
     53  bool ParseOrderAtSiteFromFile(const std::vector<atomId_t> &atomids, std::string &path);
    5254
    5355  // storing fragments
    54   molecule * StoreFragmentFromKeySet(KeySet &Leaflet, bool IsAngstroem);
    55   int StoreFragmentFromKeySet_Init(molecule *mol, molecule *Leaf, KeySet &Leaflet, atom **SonList);
    56   void CreateInducedSubgraphOfFragment(molecule *mol, molecule *Leaf, atom **SonList, bool IsAngstroem);
     56  void FillRootStackForSubgraphs(KeyStack &RootStack, const AtomMask_t &AtomMask);
     57  bool AssignKeySetsToFragment(Graph &KeySetList, ListOfLocalAtoms_t &ListOfLocalAtoms, Graph &FragmentList, bool FreeList = false);
     58  void TranslateIndicesToGlobalIDs(Graph &FragmentList, int &TotalNumberOfKeySets, Graph &TotalGraph);
    5759
    5860private:
    … …  
    6163  //!> whether to saturate dangling bonds with hydrogen and hence treat hydrogen special
    6264  const enum HydrogenSaturation saturation;
    63   //!> list of parser types for which a configuration file per fragment is stored
    64   std::vector<std::string> typelist;
     65  //!> reference to an external adjacency for comparison
     66  AdjacencyList &FileChecker;
     67  //!> Resulting Graph with all keysets
     68  Graph TotalGraph;
    6569};
    6670

  • src/Fragmentation/Graph.cpp

    ra576eb r79ac03  
    6464 * \param *counter keyset counter that gets increased
    6565 */
    66 void Graph::InsertGraph(Graph &graph, int *counter)
     66void Graph::InsertGraph(const Graph &graph, int &counter)
    6767{
    6868  GraphTestPair testGraphInsert;
    6969
    70   for(Graph::iterator runner = graph.begin(); runner != graph.end(); runner++) {
    71     testGraphInsert = insert(GraphPair ((*runner).first,pair<int,double>((*counter)++,((*runner).second).second)));  // store fragment number and current factor
     70  for(Graph::const_iterator runner = graph.begin(); runner != graph.end(); runner++) {
     71    testGraphInsert = insert(GraphPair ((*runner).first,pair<int,double>(++counter,((*runner).second).second)));  // store fragment number and current factor
    7272    if (testGraphInsert.second) {
    73       LOG(2, "INFO: KeySet " << (*counter)-1 << " successfully inserted.");
     73      LOG(2, "INFO: KeySet " << counter-1 << " successfully inserted.");
    7474    } else {
    75       LOG(2, "INFO: KeySet " << (*counter)-1 << " failed to insert, present fragment is " << ((*(testGraphInsert.first)).second).first);
     75      LOG(2, "INFO: KeySet " << counter-1 << " failed to insert, present fragment is " << ((*(testGraphInsert.first)).second).first);
    7676      ((*(testGraphInsert.first)).second).second += (*runner).second.second;
    7777      LOG(2, "INFO: New factor is " << (*(testGraphInsert.first)).second.second << ".");
    … …  
    132132 * \return true - file written successfully, false - writing failed
    133133 */
    134 bool Graph::StoreKeySetFile(std::string &path)
     134bool Graph::StoreKeySetFile(std::string &path) const
    135135{
    136136  bool status =  true;
    … …  
    141141  LOG(1, "INFO: Saving key sets of the total graph ... ");
    142142  if(output.good()) {
    143     for(Graph::iterator runner = begin(); runner != end(); runner++) {
    144       for (KeySet::iterator sprinter = (*runner).first.begin();sprinter != (*runner).first.end(); sprinter++) {
     143    for(Graph::const_iterator runner = begin(); runner != end(); runner++) {
     144      for (KeySet::const_iterator sprinter = (*runner).first.begin();sprinter != (*runner).first.end(); sprinter++) {
    145145        if (sprinter != (*runner).first.begin())
    146146          output << "\t";
    … …  
    156156  }
    157157  output.close();
    158   output.clear();
    159158
    160159  return status;
    … …  
    210209 * \return true - file written successfully, false - writing failed
    211210 */
    212 bool Graph::StoreTEFactorsFile(char *path)
     211bool Graph::StoreTEFactorsFile(char *path) const
    213212{
    214213  ofstream output;
    … …  
    224223  LOG(1, "INFO: Saving TEFactors of the total graph ... ");
    225224  if(output != NULL) {
    226     for(Graph::iterator runner = begin(); runner != end(); runner++)
     225    for(Graph::const_iterator runner = begin(); runner != end(); runner++)
    227226      output << (*runner).second.second << endl;
    228227    LOG(1, "INFO: done." << endl);

  • src/Fragmentation/Graph.hpp

    ra576eb r79ac03  
    3030  ~Graph();
    3131
    32   void InsertGraph(Graph &graph, int *counter);
     32  void InsertGraph(const Graph &graph, int &counter);
    3333
    3434  bool ParseKeySetFile(std::string &path);
    35   bool StoreKeySetFile(std::string &path);
     35  bool StoreKeySetFile(std::string &path) const;
    3636  bool ParseTEFactorsFile(char *path);
    37   bool StoreTEFactorsFile(char *path);
     37  bool StoreTEFactorsFile(char *path) const;
    3838
    3939  AdaptivityMap * GraphToAdaptivityMap() const;

  • src/Fragmentation/Makefile.am

    ra576eb r79ac03  
    33
    44FRAGMENTATIONSOURCE = \
     5        Fragmentation/Exporters/ExportGraph_ToFiles.cpp \
     6        Fragmentation/Exporters/ExportGraph.cpp \
     7        Fragmentation/Homology/FragmentEdge.cpp \
     8        Fragmentation/Homology/FragmentNode.cpp \
     9        Fragmentation/Homology/HomologyContainer.cpp \
     10        Fragmentation/Homology/HomologyGraph.cpp \
     11        Fragmentation/Homology/HomologyGraph_getFromKeyset.cpp \
    512        Fragmentation/AdaptivityMap.cpp \
    613        Fragmentation/BondsPerShortestPath.cpp \
    … …  
    1623        Fragmentation/MatrixContainer.cpp \
    1724        Fragmentation/PowerSetGenerator.cpp \
     25        Fragmentation/SortIndex.cpp \
    1826        Fragmentation/UniqueFragments.cpp
    1927
    2028FRAGMENTATIONHEADER = \
     29        Fragmentation/Exporters/ExportGraph_ToFiles.hpp \
     30        Fragmentation/Exporters/ExportGraph.hpp \
     31        Fragmentation/Homology/FragmentEdge.hpp \
     32        Fragmentation/Homology/FragmentNode.hpp \
     33        Fragmentation/Homology/HomologyContainer.hpp \
     34        Fragmentation/Homology/HomologyGraph.hpp \
    2135        Fragmentation/AdaptivityMap.hpp \
     36        Fragmentation/AtomMask.hpp \
    2237        Fragmentation/BondsPerShortestPath.hpp \
    2338        Fragmentation/defs.hpp \
    … …  
    3449        Fragmentation/KeySetsContainer.hpp \
    3550        Fragmentation/MatrixContainer.hpp \
     51        Fragmentation/Mask.hpp \
     52        Fragmentation/MoleculeMask.hpp \
    3653        Fragmentation/PowerSetGenerator.hpp \
     54        Fragmentation/SortIndex.hpp \
    3755        Fragmentation/UniqueFragments.hpp
    3856

  • src/Fragmentation/fragmentation_helpers.cpp

    ra576eb r79ac03  
    4545#include "Element/element.hpp"
    4646#include "Fragmentation/AdaptivityMap.hpp"
     47#include "Fragmentation/AtomMask.hpp"
    4748#include "Fragmentation/Graph.hpp"
    4849#include "Fragmentation/KeySet.hpp"
    … …  
    5455
    5556/** print atom mask for debugging.
    56  * \param *out output stream for debugging
    57  * \param *AtomMask defines true/false per global Atom::Nr to mask in/out each nuclear site, used to activate given number of site to increment order adaptively
     57 * \param AtomMask defines true/false per global Atom::Nr to mask in/out each nuclear site, used to activate given number of site to increment order adaptively
    5858 * \param AtomCount number of entries in \a *AtomMask
    5959 */
    60 void PrintAtomMask(bool *AtomMask, int AtomCount)
     60void PrintAtomMask(const AtomMask_t &AtomMask, int AtomCount)
    6161{
    6262  {
    … …  
    7171    output << "Atom mask is: ";
    7272    for(int i=0;i<AtomCount;i++)
    73       output << (AtomMask[i] ? "t" : "f");
     73      output << AtomMask.printBit(i);
    7474    LOG(2, output.str());
    7575  }
    … …  
    7777
    7878/** Combines all KeySets from all orders into single ones (with just unique entries).
    79  * \param *out output stream for debugging
    80  * \param *&FragmentList list to fill
     79 * \param &FragmentList list to fill
    8180 * \param ***FragmentLowerOrdersList
    8281 * \param &RootStack stack with all root candidates (unequal to each atom in complete molecule if adaptive scheme is applied)
    8382 * \param *mol molecule with atoms and bonds
    8483 */
    85 int CombineAllOrderListIntoOne(Graph *&FragmentList, Graph ***FragmentLowerOrdersList, KeyStack &RootStack, molecule *mol)
     84int CombineAllOrderListIntoOne(Graph &FragmentList, Graph ***FragmentLowerOrdersList, KeyStack &RootStack, molecule *mol)
    8685{
    8786  int RootNr = 0;
    … …  
    9392
    9493  LOG(0, "Combining the lists of all orders per order and finally into a single one.");
    95   if (FragmentList == NULL) {
    96     FragmentList = new Graph;
    97     counter = 0;
    98   } else {
    99     counter = FragmentList->size();
    100   }
     94  counter = FragmentList.size();
    10195
    10296  StartNr = RootStack.back();
    … …  
    108102    for(int i=0;i<NumLevels;i++) {
    109103      if (FragmentLowerOrdersList[RootNr][i] != NULL) {
    110         (*FragmentList).InsertGraph((*FragmentLowerOrdersList[RootNr][i]), &counter);
     104        FragmentList.InsertGraph((*FragmentLowerOrdersList[RootNr][i]), counter);
    111105      }
    112106    }
    … …  
    146140};
    147141
     142const std::vector<atomId_t> getGlobalIdsFromLocalIds(const molecule &mol, const std::vector<atomId_t> &atomids)
     143{
     144  std::vector<atomId_t> globalids;
     145  std::transform(atomids.begin(), atomids.end(), std::back_inserter(globalids),
     146      boost::bind( &atom::getId,
     147          boost::bind( &molecule::FindAtom, boost::cref(mol), _1 ))
     148  );
     149  return globalids;
     150}

  • src/Fragmentation/fragmentation_helpers.hpp

    ra576eb r79ac03  
    66 */
    77
    8 #ifndef FRAGMENTATION_HELPERS_HPP_
    9 #define FRAGMENTATION_HELPERS_HPP_
     8#ifndef FRAGMENTATION_FRAGMENTATION_HELPERS_HPP_
     9#define FRAGMENTATION_FRAGMENTATION_HELPERS_HPP_
    1010
    1111
    … …  
    2020#include <vector>
    2121
     22#include "types.hpp"
     23
    2224typedef std::deque<int> KeyStack;
    2325
     26class AtomMask_t;
    2427class Graph;
    2528class KeySet;
    2629class molecule;
    2730
    28 void PrintAtomMask(bool *AtomMask, int AtomCount);
     31void PrintAtomMask(const AtomMask_t &AtomMask, int AtomCount);
    2932
    30 int CombineAllOrderListIntoOne(Graph *&FragmentList, Graph ***FragmentLowerOrdersList, KeyStack &RootStack, molecule *mol);
     33int CombineAllOrderListIntoOne(Graph &FragmentList, Graph ***FragmentLowerOrdersList, KeyStack &RootStack, molecule *mol);
    3134void FreeAllOrdersList(Graph ***FragmentLowerOrdersList, KeyStack &RootStack, molecule *mol);
    3235
    33 #endif /* FRAGMENTATION_HELPERS_HPP_ */
     36const std::vector<atomId_t> getGlobalIdsFromLocalIds(const molecule &mol, const std::vector<atomId_t> &atomids);
     37
     38#endif /* FRAGMENTATION_FRAGMENTATION_HELPERS_HPP_ */

  • src/Graph/DepthFirstSearchAnalysis.cpp

    ra576eb r79ac03  
    4848#include "Descriptors/AtomDescriptor.hpp"
    4949#include "Descriptors/MoleculeDescriptor.hpp"
     50#include "Graph/ListOfLocalAtoms.hpp"
    5051#include "molecule.hpp"
    5152#include "MoleculeLeafClass.hpp"
    … …  
    121122
    122123
    123 bool DepthFirstSearchAnalysis::PickLocalBackEdges(atom **ListOfLocalAtoms, std::deque<bond *> *&LocalStack) const
     124bool DepthFirstSearchAnalysis::PickLocalBackEdges(const ListOfLocalAtoms_t &ListOfLocalAtoms, std::deque<bond *> *&LocalStack) const
    124125{
    125126  bool status = true;
    … …  
    133134
    134135  do { // go through all bonds and push local ones
    135     Walker = ListOfLocalAtoms[Binder->leftatom->getNr()]; // get one atom in the reference molecule
     136    const ListOfLocalAtoms_t::const_iterator leftiter = ListOfLocalAtoms.find(Binder->leftatom->getNr());
     137    ASSERT( leftiter != ListOfLocalAtoms.end(),
     138        "DepthFirstSearchAnalysis::PickLocalBackEdges() - could not find atom id "
     139        +toString(Binder->leftatom->getNr())+" in ListOfLocalAtoms.");
     140    Walker = leftiter->second; // get one atom in the reference molecule
    136141    if (Walker != NULL) { // if this Walker exists in the subgraph ...
    137142      const BondList& ListOfBonds = Walker->getListOfBonds();
    … …  
    140145          ++Runner) {
    141146        OtherAtom = (*Runner)->GetOtherAtom(Walker);
    142         if (OtherAtom == ListOfLocalAtoms[(*Runner)->rightatom->getNr()]) { // found the bond
     147        const ListOfLocalAtoms_t::const_iterator rightiter = ListOfLocalAtoms.find((*Runner)->rightatom->getNr());
     148        if (OtherAtom == rightiter->second) { // found the bond
    143149          LocalStack->push_front((*Runner));
    144150          LOG(3, "INFO: Found local edge " << *(*Runner) << ".");

  • src/Graph/DepthFirstSearchAnalysis.hpp

    ra576eb r79ac03  
    2020class atom;
    2121class bond;
     22class ListOfLocalAtoms_t;
    2223class MoleculeLeafClass;
    2324class molecule;
    … …  
    6667   * Reference is the internal BackEdgeStack.
    6768   *
    68    * \param **ListOfLocalAtoms array of father atom::nr to local atom::nr (reverse of atom::father)
     69   * \param ListOfLocalAtoms array of father atom::nr to local atom::nr (reverse of atom::father)
    6970   * \param *LocalStack stack to be filled
    7071   * \return true - everything ok, false - ReferenceStack was empty
    7172   */
    72   bool PickLocalBackEdges(atom **ListOfLocalAtoms, std::deque<bond *> *&LocalStack) const;
     73  bool PickLocalBackEdges(const ListOfLocalAtoms_t &ListOfLocalAtoms, std::deque<bond *> *&LocalStack) const;
    7374
    7475  /** Getter for BackEdgeStack.

  • src/Graph/Makefile.am

    ra576eb r79ac03  
    66        Graph/BreadthFirstSearchAdd.cpp \
    77        Graph/BuildInducedSubgraph.cpp \
    8         Graph/CheckAgainstAdjacencyFile.cpp \
     8        Graph/AdjacencyList.cpp \
    99        Graph/ConnectedSubgraph.cpp \
    1010        Graph/CyclicStructureAnalysis.cpp \
    … …  
    1515        Graph/BreadthFirstSearchAdd.hpp \
    1616        Graph/BuildInducedSubgraph.hpp \
    17         Graph/CheckAgainstAdjacencyFile.hpp \
     17        Graph/AdjacencyList.hpp \
    1818        Graph/ConnectedSubgraph.hpp \
    1919        Graph/CyclicStructureAnalysis.hpp \
    20         Graph/DepthFirstSearchAnalysis.hpp
     20        Graph/DepthFirstSearchAnalysis.hpp \
     21        Graph/ListOfLocalAtoms.hpp
    2122
    2223

  • src/Graph/unittests/Makefile.am

    ra576eb r79ac03  
    33
    44GRAPHTESTSSOURCES = \
    5         ../Graph/unittests/BondGraphUnitTest.cpp \
    6         ../Graph/unittests/CheckAgainstAdjacencyFileUnitTest.cpp
     5        ../Graph/unittests/AdjacencyListUnitTest.cpp \
     6        ../Graph/unittests/BondGraphUnitTest.cpp
    77
    88GRAPHTESTSHEADERS = \
    9         ../Graph/unittests/BondGraphUnitTest.hpp \
    10         ../Graph/unittests/CheckAgainstAdjacencyFileUnitTest.hpp
     9        ../Graph/unittests/AdjacencyListUnitTest.hpp \
     10        ../Graph/unittests/BondGraphUnitTest.hpp
    1111
    1212GRAPHTESTS = \
    13         BondGraphUnitTest \
    14         CheckAgainstAdjacencyFileUnitTest
     13        AdjacencyListUnitTest \
     14        BondGraphUnitTest
    1515
    1616
    … …  
    3232
    3333
     34AdjacencyListUnitTest_SOURCES = $(top_srcdir)/src/unittests/UnitTestMain.cpp \
     35        ../Graph/unittests/AdjacencyListUnitTest.cpp \
     36        ../Graph/unittests/AdjacencyListUnitTest.hpp
     37AdjacencyListUnitTest_LDADD = ${ALLLIBS}
     38
    3439BondGraphUnitTest_SOURCES = $(top_srcdir)/src/unittests/UnitTestMain.cpp \
    3540        ../Graph/unittests/BondGraphUnitTest.cpp \
    … …  
    3742BondGraphUnitTest_LDADD = ${GRAPHLIBS}
    3843
    39 CheckAgainstAdjacencyFileUnitTest_SOURCES = $(top_srcdir)/src/unittests/UnitTestMain.cpp \
    40         ../Graph/unittests/CheckAgainstAdjacencyFileUnitTest.cpp \
    41         ../Graph/unittests/CheckAgainstAdjacencyFileUnitTest.hpp
    42 CheckAgainstAdjacencyFileUnitTest_LDADD = ${ALLLIBS}
    43 
    4444
    4545

  • src/MoleculeLeafClass.cpp

    ra576eb r79ac03  
    4141#include "Atom/atom.hpp"
    4242#include "Element/element.hpp"
     43#include "Fragmentation/AtomMask.hpp"
    4344#include "Fragmentation/Graph.hpp"
    4445#include "Fragmentation/KeySet.hpp"
     46#include "Graph/ListOfLocalAtoms.hpp"
    4547#include "molecule.hpp"
    4648
    … …  
    114116};
    115117
    116 /** Fills the root stack for sites to be used as root in fragmentation depending on order or adaptivity criteria
    117  * Again, as in \sa FillBondStructureFromReference steps recursively through each Leaf in this chain list of molecule's.
    118  * \param *out output stream for debugging
    119  * \param *&RootStack stack to be filled
    120  * \param *AtomMask defines true/false per global Atom::Nr to mask in/out each nuclear site
    121  * \param &FragmentCounter counts through the fragments in this MoleculeLeafClass
    122  * \param saturation whether to treat hydrogen special or not
    123  * \return true - stack is non-empty, fragmentation necessary, false - stack is empty, no more sites to update
    124  */
    125 bool MoleculeLeafClass::FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter, const enum HydrogenSaturation saturation)
    126 {
    127   if (RootStack != NULL) {
    128     // find first root candidates
    129     if (&(RootStack[FragmentCounter]) != NULL) {
    130       RootStack[FragmentCounter].clear();
    131       for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
    132         const atom * const Father = (*iter)->GetTrueFather();
    133         if (AtomMask[Father->getNr()]) // apply mask
    134           if ((saturation == DontSaturate) || ((*iter)->getType()->getAtomicNumber() != 1)) // skip hydrogen
    135             RootStack[FragmentCounter].push_front((*iter)->getNr());
    136       }
    137       if (next != NULL)
    138         next->FillRootStackForSubgraphs(RootStack, AtomMask, ++FragmentCounter, saturation);
    139     } else {
    140       LOG(1, "Rootstack[" << FragmentCounter << "] is NULL.");
    141       return false;
    142     }
    143     FragmentCounter--;
    144     return true;
    145   } else {
    146     LOG(1, "Rootstack is NULL.");
    147     return false;
    148   }
    149 };
    150118
    151 /** The indices per keyset are compared to the respective father's Atom::Nr in each subgraph and thus put into \a **&FragmentList.
    152  * \param *out output stream fro debugging
    153  * \param *reference reference molecule with the bond structure to be copied
    154  * \param *KeySetList list with all keysets
    155  * \param ***ListOfLocalAtoms Lookup table for each subgraph and index of each atom in global molecule, may be NULL on start, then it is filled
    156  * \param **&FragmentList list to be allocated and returned
    157  * \param &FragmentCounter counts the fragments as we move along the list
    158  * \param FreeList true - ***ListOfLocalAtoms is free'd before return, false - it is not
    159  * \retuen true - success, false - failure
    160  */
    161 bool MoleculeLeafClass::AssignKeySetsToFragment(molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList)
    162 {
    163   bool status = true;
    164   int KeySetCounter = 0;
    165 
    166   LOG(1, "Begin of AssignKeySetsToFragment.");
    167   // fill ListOfLocalAtoms if NULL was given
    168   if (!Leaf->FillListOfLocalAtoms(ListOfLocalAtoms[FragmentCounter], reference->getAtomCount())) {
    169     LOG(1, "Filling of ListOfLocalAtoms failed.");
    170     return false;
    171   }
    172 
    173   // allocate fragment list
    174   if (FragmentList == NULL) {
    175     KeySetCounter = Count();
    176     FragmentList = new Graph*[KeySetCounter];
    177     for (int i=0;i<KeySetCounter;i++)
    178       FragmentList[i] = NULL;
    179     KeySetCounter = 0;
    180   }
    181 
    182   if ((KeySetList != NULL) && (KeySetList->size() != 0)) { // if there are some scanned keysets at all
    183     // assign scanned keysets
    184     if (FragmentList[FragmentCounter] == NULL)
    185       FragmentList[FragmentCounter] = new Graph;
    186     KeySet *TempSet = new KeySet;
    187     for (Graph::iterator runner = KeySetList->begin(); runner != KeySetList->end(); runner++) { // key sets contain global numbers!
    188       if (ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*((*runner).first.begin()))->getNr()] != NULL) {// as we may assume that that bond structure is unchanged, we only test the first key in each set
    189         // translate keyset to local numbers
    190         for (KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
    191           TempSet->insert(ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*sprinter)->getNr()]->getNr());
    192         // insert into FragmentList
    193         FragmentList[FragmentCounter]->insert(GraphPair(*TempSet, pair<int, double> (KeySetCounter++, (*runner).second.second)));
    194       }
    195       TempSet->clear();
    196     }
    197     delete (TempSet);
    198     if (KeySetCounter == 0) {// if there are no keysets, delete the list
    199       LOG(1, "KeySetCounter is zero, deleting FragmentList.");
    200       delete (FragmentList[FragmentCounter]);
    201     } else
    202       LOG(1, KeySetCounter << " keysets were assigned to subgraph " << FragmentCounter << ".");
    203     FragmentCounter++;
    204     if (next != NULL)
    205       next->AssignKeySetsToFragment(reference, KeySetList, ListOfLocalAtoms, FragmentList, FragmentCounter, FreeList);
    206     FragmentCounter--;
    207   } else
    208     LOG(1, "KeySetList is NULL or empty.");
    209 
    210   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
    211     // free the index lookup list
    212     delete[](ListOfLocalAtoms[FragmentCounter]);
    213   }
    214   LOG(1, "End of AssignKeySetsToFragment.");
    215   return status;
    216 };
    217 
    218 /** Translate list into global numbers (i.e. ones that are valid in "this" molecule, not in MolecularWalker->Leaf)
    219  * \param *out output stream for debugging
    220  * \param **FragmentList Graph with local numbers per fragment
    221  * \param &FragmentCounter counts the fragments as we move along the list
    222  * \param &TotalNumberOfKeySets global key set counter
    223  * \param &TotalGraph Graph to be filled with global numbers
    224  */
    225 void MoleculeLeafClass::TranslateIndicesToGlobalIDs(Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets, Graph &TotalGraph)
    226 {
    227   LOG(1, "Begin of TranslateIndicesToGlobalIDs.");
    228   KeySet *TempSet = new KeySet;
    229   if (FragmentList[FragmentCounter] != NULL) {
    230     for (Graph::iterator runner = FragmentList[FragmentCounter]->begin(); runner != FragmentList[FragmentCounter]->end(); runner++) {
    231       for (KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
    232         TempSet->insert((Leaf->FindAtom(*sprinter))->GetTrueFather()->getNr());
    233       TotalGraph.insert(GraphPair(*TempSet, pair<int, double> (TotalNumberOfKeySets++, (*runner).second.second)));
    234       TempSet->clear();
    235     }
    236     delete (TempSet);
    237   } else {
    238     LOG(1, "FragmentList is NULL.");
    239   }
    240   if (next != NULL)
    241     next->TranslateIndicesToGlobalIDs(FragmentList, ++FragmentCounter, TotalNumberOfKeySets, TotalGraph);
    242   FragmentCounter--;
    243   LOG(1, "End of TranslateIndicesToGlobalIDs.");
    244 };
    245119
    246120/** Simply counts the number of items in the list, from given MoleculeLeafClass.

  • src/MoleculeLeafClass.hpp

    ra576eb r79ac03  
    1717
    1818class atom;
     19class AtomMask_t;
    1920class Graph;
     21class ListOfLocalAtoms_t;
    2022class molecule;
    2123
    … …  
    3840
    3941  bool AddLeaf(molecule *ptr, MoleculeLeafClass *Previous);
    40   bool FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter, const enum HydrogenSaturation saturation);
    41   bool AssignKeySetsToFragment(molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList = false);
    42   void TranslateIndicesToGlobalIDs(Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets, Graph &TotalGraph);
    4342  int Count() const;
    4443};

  • src/MoleculeListClass.hpp

    ra576eb r79ac03  
    1515#include <iosfwd>
    1616#include <list>
     17#include <map>
    1718#include <string>
    1819
    … …  
    2223
    2324#include "Parser/ParserTypes.hpp"
     25#include "types.hpp"
    2426
    2527class molecule;
    2628class periodentafel;
     29class SortIndex_t;
    2730class World;
    2831
    … …  
    4346
    4447  bool AddHydrogenCorrection(std::string &path);
    45   bool StoreForcesFile(std::string &path, int *SortIndex);
     48  bool StoreForcesFile(std::string &path, const SortIndex_t &SortIndex);
    4649  void insert(molecule *mol);
    4750  void erase(molecule *mol);
    4851  molecule * ReturnIndex(int index);
    49   bool OutputConfigForListOfFragments(std::string &prefix, int *SortIndex, ParserTypes type);
     52  bool OutputConfigForListOfFragments(std::string &prefix, ParserTypes type);
    5053  int NumberOfActiveMolecules();
    5154  void Enumerate(std::ostream *out);

  • src/molecule.cpp

    ra576eb r79ac03  
    820820    return (*iter);
    821821  } else {
    822     ELOG(1, "Atom not found in molecule " << getName() << "'s list.");
     822    ELOG(1, "Atom with Nr " << Nr << " not found in molecule " << getName() << "'s list.");
    823823    return NULL;
    824824  }

  • src/molecule.hpp

    ra576eb r79ac03  
    4747class Graph;
    4848class LinkedCell_deprecated;
     49class ListOfLocalAtoms_t;
    4950class molecule;
    5051class MoleculeLeafClass;
    … …  
    291292  /// Fragment molecule by two different approaches:
    292293  bool StoreBondsToFile(std::string filename, std::string path = "");
    293   bool StoreAdjacencyToFile(std::string filename, std::string path = "");
    294   bool CreateFatherLookupTable(atom **&LookupTable, int count = 0);
     294  bool CreateFatherLookupTable(ListOfLocalAtoms_t &LookupTable, int count = 0);
    295295
    296296  // Recognize doubly appearing molecules in a list of them
    297297  int * GetFatherSonAtomicMap(molecule *OtherMolecule);
    298   bool FillBondStructureFromReference(const molecule * const reference, atom **&ListOfLocalAtoms, bool FreeList = false);
    299   bool FillListOfLocalAtoms(atom **&ListOfLocalAtoms, const int GlobalAtomCount);
     298  bool FillBondStructureFromReference(const molecule * const reference, ListOfLocalAtoms_t &ListOfLocalAtoms, bool FreeList = false);
     299  bool FillListOfLocalAtoms(ListOfLocalAtoms_t &ListOfLocalAtoms, const int GlobalAtomCount);
    300300
    301301  // Output routines.

  • src/molecule_graph.cpp

    ra576eb r79ac03  
    4848#include "Element/element.hpp"
    4949#include "Graph/BondGraph.hpp"
     50#include "Graph/ListOfLocalAtoms.hpp"
    5051#include "Helpers/defs.hpp"
    5152#include "Helpers/helpers.hpp"
    … …  
    6162 * Calls this routine in each MoleculeLeafClass::next subgraph if it's not NULL.
    6263 * \param *reference reference molecule with the bond structure to be copied
    63  * \param **&ListOfLocalAtoms Lookup table for this subgraph and index of each atom in \a *reference, may be NULL on start, then it is filled
    64  * \param FreeList true - ***ListOfLocalAtoms is free'd before return, false - it is not
     64 * \param ListOfLocalAtoms Lookup table for this subgraph and index of each atom in \a *reference, may be NULL on start, then it is filled
     65 * \param FreeList true - ListOfLocalAtoms is free'd before return, false - it is not
    6566 * \return true - success, false - failure
    6667 */
    67 bool molecule::FillBondStructureFromReference(const molecule * const reference, atom **&ListOfLocalAtoms, bool FreeList)
     68bool molecule::FillBondStructureFromReference(const molecule * const reference, ListOfLocalAtoms_t &ListOfLocalAtoms, bool FreeList)
    6869{
    6970  bool status = true;
    … …  
    9192          ++Runner) {
    9293        atom * const OtherAtom = (*Runner)->GetOtherAtom((*iter)->GetTrueFather());
    93         atom * const OtherWalker = ListOfLocalAtoms[OtherAtom->getNr()]; // local copy of current bond partner of walker
     94        const ListOfLocalAtoms_t::const_iterator localiter = ListOfLocalAtoms.find(OtherAtom->getNr());
     95        ASSERT( localiter != ListOfLocalAtoms.end(),
     96            "molecule::FillBondStructureFromReference() - could not find id"
     97            +toString(OtherAtom->getNr())+" in ListOfLocalAtoms.");
     98        atom * const OtherWalker = localiter->second; // local copy of current bond partner of walker
    9499        if (OtherWalker != NULL) {
    95100          if (OtherWalker->getNr() > (*iter)->getNr())
    … …  
    103108  }
    104109
    105   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
     110  if ((FreeList) && (!ListOfLocalAtoms.empty())) {
    106111    // free the index lookup list
    107     delete[](ListOfLocalAtoms);
     112    ListOfLocalAtoms.clear();
    108113  }
    109114  LOG(1, "End of FillBondStructureFromReference.");
    … …  
    146151}
    147152
    148 
    149 /** Storing the bond structure of a molecule to file.
    150  * Simply stores Atom::Nr and then the Atom::Nr of all bond partners per line.
    151  * \param &filename name of file
    152  * \param path path to file, defaults to empty
    153  * \return true - file written successfully, false - writing failed
    154  */
    155 bool molecule::StoreAdjacencyToFile(std::string filename, std::string path)
    156 {
    157   ofstream AdjacencyFile;
    158   string line;
    159   bool status = true;
    160 
    161   if (path != "")
    162     line = path + "/" + filename;
    163   else
    164     line = filename;
    165   AdjacencyFile.open(line.c_str(), ios::out);
    166   LOG(1, "Saving adjacency list ... ");
    167   if (AdjacencyFile.good()) {
    168     AdjacencyFile << "m\tn" << endl;
    169     for_each(begin(),end(),bind2nd(mem_fun(&atom::OutputAdjacency),&AdjacencyFile));
    170     AdjacencyFile.close();
    171     LOG(1, "\t... done.");
    172   } else {
    173     LOG(1, "\t... failed to open file " << line << ".");
    174     status = false;
    175   }
    176 
    177   return status;
    178 }
    179 ;
    180153
    181154/** Storing the bond structure of a molecule to file.
    … …  
    227200
    228201/** Fills a lookup list of father's Atom::nr -> atom for each subgraph.
    229  * \param **&ListOfLocalAtoms Lookup table for each subgraph and index of each atom in global molecule, may be NULL on start, then it is filled
     202 * \param ListOfLocalAtoms Lookup table for each subgraph and index of each atom in global molecule, may be NULL on start, then it is filled
    230203 * \param GlobalAtomCount number of atoms in the complete molecule
    231204 * \return true - success, false - failure (ListOfLocalAtoms != NULL)
    232205 */
    233 bool molecule::FillListOfLocalAtoms(atom **&ListOfLocalAtoms, const int GlobalAtomCount)
     206bool molecule::FillListOfLocalAtoms(ListOfLocalAtoms_t &ListOfLocalAtoms, const int GlobalAtomCount)
    234207{
    235208  bool status = true;
    236209
    237   if (ListOfLocalAtoms == NULL) { // allocate and fill list of this fragment/subgraph
     210  if (ListOfLocalAtoms.empty()) { // allocate and fill list of this fragment/subgraph
    238211    status = status && CreateFatherLookupTable(ListOfLocalAtoms, GlobalAtomCount);
    239212  } else
    … …  
    251224 * \return true - success, false - failure
    252225 */
    253 bool molecule::CreateFatherLookupTable(atom **&LookupTable, int count)
     226bool molecule::CreateFatherLookupTable(ListOfLocalAtoms_t &LookupTable, int count)
    254227{
    255228  bool status = true;
    256229  int AtomNo;
    257230
    258   if (LookupTable != NULL) {
    259     ELOG(1, "Pointer for Lookup table is not NULL! Aborting ...");
     231  if (!LookupTable.empty()) {
     232    ELOG(1, "Pointer for Lookup table is not empty! Aborting ...");
    260233    return false;
    261234  }
    … …  
    273246
    274247  // allocate and fill
    275   LookupTable = new atom *[count+1];
    276   if (LookupTable == NULL) {
    277     ELOG(0, "LookupTable memory allocation failed!");
    278     performCriticalExit();
    279     status = false;
    280   } else {
    281     for (int i=0;i<=count;i++)
    282       LookupTable[i] = NULL;
    283     for (molecule::iterator iter = begin(); iter != end(); ++iter) {
    284       AtomNo = (*iter)->GetTrueFather()->getNr();
    285       if ((AtomNo >= 0) && (AtomNo <= count)) {
    286         LOG(3, "DEBUG: Setting LookupTable[" << AtomNo << "] to " << *(*iter));
    287         LookupTable[AtomNo] = (*iter);
    288       } else {
    289         ELOG(1, "Walker " << *(*iter) << " exceeded range of nuclear ids [0, " << count << "].");
    290         status = false;
    291         break;
    292       }
     248  for (int i=0;i<=count;i++)
     249    LookupTable[i] = NULL;
     250  for (molecule::iterator iter = begin(); iter != end(); ++iter) {
     251    AtomNo = (*iter)->GetTrueFather()->getNr();
     252    if ((AtomNo >= 0) && (AtomNo <= count)) {
     253      LOG(3, "DEBUG: Setting LookupTable[" << AtomNo << "] to " << *(*iter));
     254      LookupTable[AtomNo] = (*iter);
     255    } else {
     256      ELOG(1, "Walker " << *(*iter) << " exceeded range of nuclear ids [0, " << count << "].");
     257      status = false;
     258      break;
    293259    }
    294260  }

  • src/moleculelist.cpp

    ra576eb r79ac03  
    5151#include "Fragmentation/Graph.hpp"
    5252#include "Fragmentation/KeySet.hpp"
     53#include "Fragmentation/SortIndex.hpp"
    5354#include "Graph/BondGraph.hpp"
    5455#include "Helpers/helpers.hpp"
    … …  
    489490/** Store force indices, i.e. the connection between the nuclear index in the total molecule config and the respective atom in fragment config.
    490491 * \param &path path to file
    491  * \param *SortIndex Index to map from the BFS labeling to the sequence how of Ion_Type in the config
     492 * \param SortIndex Index to map from the BFS labeling to the sequence how of Ion_Type in the config
    492493 * \return true - file written successfully, false - writing failed
    493494 */
    494 bool MoleculeListClass::StoreForcesFile(std::string &path, int *SortIndex)
     495bool MoleculeListClass::StoreForcesFile(std::string &path, const SortIndex_t &SortIndex)
    495496{
    496497  bool status = true;
    … …  
    511512            if ((*atomIter)->getType()->getAtomicNumber() == (*elemIter).first) {
    512513              if (((*atomIter)->GetTrueFather() != NULL) && ((*atomIter)->GetTrueFather() != (*atomIter))) {// if there is a rea
    513                 ForcesFile << SortIndex[(*atomIter)->GetTrueFather()->getNr()] << "\t";
     514                const atomId_t fatherid = (*atomIter)->GetTrueFather()->getNr();
     515                ForcesFile << SortIndex.find(fatherid) << "\t";
    514516              } else
    515517                // otherwise a -1 to indicate an added saturation hydrogen
    … …  
    535537 * \param *out output stream for debugging
    536538 * \param &prefix path and prefix to the fragment config files
    537  * \param *SortIndex Index to map from the BFS labeling to the sequence how of Ion_Type in the config
     539 * \param SortIndex Index to map from the BFS labeling to the sequence how of Ion_Type in the config
    538540 * \param type desired type to store
    539541 * \return true - success (each file was written), false - something went wrong.
    540542 */
    541 bool MoleculeListClass::OutputConfigForListOfFragments(std::string &prefix, int *SortIndex, ParserTypes type)
     543bool MoleculeListClass::OutputConfigForListOfFragments(std::string &prefix, ParserTypes type)
    542544{
    543545  ofstream outputFragment;

  • src/unittests/Makefile.am

    ra576eb r79ac03  
    1414include ../../src/Filling/unittests/Makefile.am
    1515include ../../src/Fragmentation/unittests/Makefile.am
     16include ../../src/Fragmentation/Homology/unittests/Makefile.am
    1617include ../../src/Fragmentation/Summation/unittests/Makefile.am
    1718include ../../src/Fragmentation/SetValues/unittests/Makefile.am

  • tests/CodeChecks/testsuite-header-dist.at

    ra576eb r79ac03  
    1919AT_KEYWORDS([CodeCheck header])
    2020
    21 ok=""
     21ok="ExportGraph.hpp ExportGraph_ToFiles.hpp ExportGraph_ToJobs.hpp"
    2222echo "${#ok[*]} are ok not to get distributed: ${ok[*]}."
    2323Makefiles=`find ${abs_top_srcdir}/src -name Makefile.am`

  • tests/Fragmentations/Fragmenting/1_2-dimethoxyethane/testsuite-fragmenting-1_2-dimethoxyethane-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/1_2-dimethoxyethane/testsuite-fragmenting-1_2-dimethoxyethane-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/1_2-dimethoxyethane/testsuite-fragmenting-1_2-dimethoxyethane-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/1_2-dimethoxyethane/testsuite-fragmenting-1_2-dimethoxyethane-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/1_2-dimethylbenzene/testsuite-fragmenting-1_2-dimethylbenzene-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/1_2-dimethylbenzene/testsuite-fragmenting-1_2-dimethylbenzene-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/1_2-dimethylbenzene/testsuite-fragmenting-1_2-dimethylbenzene-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/1_2-dimethylbenzene/testsuite-fragmenting-1_2-dimethylbenzene-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/2-methylcyclohexanone/testsuite-fragmenting-2-methylcyclohexanone-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/2-methylcyclohexanone/testsuite-fragmenting-2-methylcyclohexanone-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/2-methylcyclohexanone/testsuite-fragmenting-2-methylcyclohexanone-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/2-methylcyclohexanone/testsuite-fragmenting-2-methylcyclohexanone-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/2-methylcyclohexanone/testsuite-fragmenting-2-methylcyclohexanone-order5.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/2-methylcyclohexanone/testsuite-fragmenting-2-methylcyclohexanone-order6.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/N_N-dimethylacetamide/testsuite-fragmenting-N_N-dimethylacetamide-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/N_N-dimethylacetamide/testsuite-fragmenting-N_N-dimethylacetamide-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/N_N-dimethylacetamide/testsuite-fragmenting-N_N-dimethylacetamide-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/N_N-dimethylacetamide/testsuite-fragmenting-N_N-dimethylacetamide-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/N_N-dimethylacetamide/testsuite-fragmenting-N_N-dimethylacetamide-order5.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/N_N-dimethylacetamide/testsuite-fragmenting-N_N-dimethylacetamide-order6.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/benzene/testsuite-fragmenting-benzene-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/benzene/testsuite-fragmenting-benzene-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/benzene/testsuite-fragmenting-benzene-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/benzene/testsuite-fragmenting-benzene-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/benzene/testsuite-fragmenting-benzene-order5.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/benzene/testsuite-fragmenting-benzene-order6.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/cholesterol/testsuite-fragmenting-cholesterol-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/cholesterol/testsuite-fragmenting-cholesterol-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/cholesterol/testsuite-fragmenting-cholesterol-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/cholesterol/testsuite-fragmenting-cholesterol-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/cholesterol/testsuite-fragmenting-cholesterol-order5.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/cholesterol/testsuite-fragmenting-cholesterol-order6.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/cycloheptane/testsuite-fragmenting-cycloheptane-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/cycloheptane/testsuite-fragmenting-cycloheptane-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/cycloheptane/testsuite-fragmenting-cycloheptane-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/cycloheptane/testsuite-fragmenting-cycloheptane-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/cycloheptane/testsuite-fragmenting-cycloheptane-order5.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/cycloheptane/testsuite-fragmenting-cycloheptane-order6.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/dimethyl_bromomalonate/testsuite-fragmenting-dimethyl_bromomalonate-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/dimethyl_bromomalonate/testsuite-fragmenting-dimethyl_bromomalonate-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/dimethyl_bromomalonate/testsuite-fragmenting-dimethyl_bromomalonate-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/dimethyl_bromomalonate/testsuite-fragmenting-dimethyl_bromomalonate-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/dimethyl_bromomalonate/testsuite-fragmenting-dimethyl_bromomalonate-order5.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/dimethyl_bromomalonate/testsuite-fragmenting-dimethyl_bromomalonate-order6.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/glucose/testsuite-fragmenting-glucose-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/glucose/testsuite-fragmenting-glucose-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/glucose/testsuite-fragmenting-glucose-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/glucose/testsuite-fragmenting-glucose-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/glucose/testsuite-fragmenting-glucose-order5.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/glucose/testsuite-fragmenting-glucose-order6.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/heptan/testsuite-fragmenting-heptan-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/heptan/testsuite-fragmenting-heptan-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/heptan/testsuite-fragmenting-heptan-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/heptan/testsuite-fragmenting-heptan-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/heptan/testsuite-fragmenting-heptan-order5.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/heptan/testsuite-fragmenting-heptan-order6.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/isoleucine/testsuite-fragmenting-isoleucine-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/isoleucine/testsuite-fragmenting-isoleucine-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/isoleucine/testsuite-fragmenting-isoleucine-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/isoleucine/testsuite-fragmenting-isoleucine-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/isoleucine/testsuite-fragmenting-isoleucine-order5.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/isoleucine/testsuite-fragmenting-isoleucine-order6.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/neohexane/testsuite-fragmenting-neohexane-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/neohexane/testsuite-fragmenting-neohexane-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/neohexane/testsuite-fragmenting-neohexane-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/neohexane/testsuite-fragmenting-neohexane-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/neohexane/testsuite-fragmenting-neohexane-order5.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/neohexane/testsuite-fragmenting-neohexane-order6.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/proline/testsuite-fragmenting-proline-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/proline/testsuite-fragmenting-proline-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/proline/testsuite-fragmenting-proline-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/proline/testsuite-fragmenting-proline-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/proline/testsuite-fragmenting-proline-order5.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/proline/testsuite-fragmenting-proline-order6.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/putrescine/testsuite-fragmenting-putrescine-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/putrescine/testsuite-fragmenting-putrescine-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/putrescine/testsuite-fragmenting-putrescine-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/putrescine/testsuite-fragmenting-putrescine-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/putrescine/testsuite-fragmenting-putrescine-order5.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/putrescine/testsuite-fragmenting-putrescine-order6.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/tartaric_acid/testsuite-fragmenting-tartaric_acid-order1.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 1 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/tartaric_acid/testsuite-fragmenting-tartaric_acid-order2.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 2 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/tartaric_acid/testsuite-fragmenting-tartaric_acid-order3.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 3 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/tartaric_acid/testsuite-fragmenting-tartaric_acid-order4.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 4 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/tartaric_acid/testsuite-fragmenting-tartaric_acid-order5.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 5 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/Fragmentations/Fragmenting/tartaric_acid/testsuite-fragmenting-tartaric_acid-order6.at

    ra576eb r79ac03  
    4848AT_CHECK([chmod u+w $file], 0)
    4949
    50 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
     50AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 --select-molecules-atoms -f $FILENAME --order 6 --distance $DISTANCE  --output-types mpqc pcp xyz], 0, [stdout], [stderr])
    5151AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
    5252AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])

  • tests/regression/Fragmentation/FragmentMolecule-MaxOrder/testsuite-fragmentation-fragment-molecule-maxorder.at

    ra576eb r79ac03  
    3737# NOTE: Result code of 2 is not returned if "-v 1" is missing, then sequence of atoms is changed all the time and Adjacency files never match.
    3838AT_SETUP([Fragmentation - Fragmentation is at MaxOrder])
    39 AT_XFAIL_IF([/bin/true])
    4039
    4140file=test.conf
    4241AT_CHECK([/bin/cp -f ${abs_top_srcdir}/tests/regression/Fragmentation/FragmentMolecule-MaxOrder/pre/test.conf $file], 0)
    4342AT_CHECK([chmod u+w $file], 0, [ignore], [ignore])
    44 AT_CHECK([../../molecuilder -i $file  -v 1 --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2 --output-types "pcp"], 0, [ignore], [ignore])
    45 AT_CHECK([../../molecuilder -i $file  -v 1 --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2 --output-types "pcp"], 2, [ignore], [ignore])
     43AT_CHECK([../../molecuilder -i $file -I -v 1 --select-molecule-by-id 0 --select-molecules-atoms -f ./BondFragment --distance 1.55 --order 2 --output-types "pcp"], 0, [ignore], [ignore])
     44AT_CHECK([../../molecuilder -i $file -I -v 1 --select-molecule-by-id 0 --select-molecules-atoms -f ./BondFragment --distance 1.55 --order 2 --output-types "pcp"], 2, [ignore], [ignore])
    4645
    4746AT_CLEANUP

  • tests/regression/Fragmentation/FragmentMolecule/testsuite-fragmentation-fragment-molecule.at

    ra576eb r79ac03  
    4141AT_CHECK([/bin/cp -f ${abs_top_srcdir}/tests/regression/Fragmentation/FragmentMolecule/pre/test.conf $file], 0)
    4242AT_CHECK([chmod u+w $file], 0, [ignore], [ignore])
    43 AT_CHECK([../../molecuilder -i $file  -v 1 -I --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2 --output-types "pcp"], 0, [ignore], [ignore])
     43AT_CHECK([../../molecuilder -i $file -I -v 1 --select-molecule-by-id 0 --select-molecules-atoms -f ./BondFragment --distance 1.55 --order 2 --output-types "pcp"], 0, [ignore], [ignore])
    4444#AT_CHECK([diff BondFragment0.conf ${abs_top_srcdir}/tests/regression/Fragmentation/FragmentMolecule/post/BondFragment0.conf], 0, [ignore], [ignore])
    4545#AT_CHECK([diff BondFragment1.conf ${abs_top_srcdir}/tests/regression/Fragmentation/FragmentMolecule/post/BondFragment1.conf], 0, [ignore], [ignore])

  • tests/regression/Molecules/SaveAdjacency/post/test.adj

    ra576eb r79ac03  
    1 m       n
    2 1       9       
    3 2       9       
    4 3       9       
    5 4       10     
    6 5       10     
    7 6       11     
    8 7       11     
    9 8       11     
    10 9       1       2       3       10     
    11 10      4       5       9       11     
    12 11      6       7       8       10     
     11 9
     22 9
     33 9
     44 10
     55 10
     66 11
     77 11
     88 11
     99 1 2 3 10
     1010 4 5 9 11
     1111 6 7 8 10
Note: See TracChangeset for help on using the changeset viewer.