Changes in / [5837dd:7ba268]


Ignore:
Files:
35 added
13 deleted
144 edited

Legend:

Unmodified
Added
Removed

  • configure.ac

    r5837dd r7ba268  
    164164AC_CHECK_LIB(gsl, gsl_blas_dnrm2, , [AC_MSG_ERROR(["No working BLAS found for GSL, stopping."])])
    165165
    166 # add replacement/saturation hydrogen or not
    167 AC_ARG_ENABLE([hydrogen],AS_HELP_STRING([--enable-hydrogen],[Adding saturation hydrogen (default is yes)]),
    168               [enable_hydrogen=$enableval], [enable_hydrogen=yes])
    169 if test x"$enable_hydrogen" = xyes; then
    170   AC_DEFINE(ADDHYDROGEN,1, ["Adding saturation hydrogen"])
    171   AC_SUBST(ADDHYDROGEN)
    172 fi
    173 
    174166# use CppUnit TestRunner or not
    175167AC_ARG_ENABLE([ecut],AS_HELP_STRING([--enable-ecut],[Use ECut TestRunnerClient (default is no)]),

  • src/Actions/FragmentationAction/FragmentationAction.cpp

    r5837dd r7ba268  
    2525#include "CodePatterns/Log.hpp"
    2626#include "CodePatterns/Verbose.hpp"
     27#include "Fragmentation/Fragmentation.hpp"
     28#include "Fragmentation/HydrogenSaturation_enum.hpp"
    2729#include "Graph/DepthFirstSearchAnalysis.hpp"
    2830#include "molecule.hpp"
    … …  
    4951  getParametersfromValueStorage();
    5052
     53  LOG(0, "STATUS: Fragmenting molecular system with current connection matrix maximum bond distance "
     54      << params.distance << " up to "
     55      << params.order << " order. Fragment files begin with "
     56      << params.prefix << " and are stored as: "
     57      << params.types << "." << std::endl);
     58
    5159  DepthFirstSearchAnalysis DFS;
    5260  for (World::MoleculeSelectionConstIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
    … …  
    5664    start = clock();
    5765    if (mol->hasBondStructure()) {
    58       LOG(1, "STAUS: Fragmenting molecule with current connection matrix ...");
    59       ExitFlag = mol->FragmentMolecule(params.order, params.path, DFS);
     66      Fragmentation Fragmenter(mol, params.DoSaturation ? DoSaturate : DontSaturate);
     67      Fragmenter.setOutputTypes(params.types);
     68      ExitFlag = Fragmenter.FragmentMolecule(params.order, params.prefix, DFS);
    6069    }
    6170    World::getInstance().setExitFlag(ExitFlag);

  • src/Actions/FragmentationAction/FragmentationAction.def

    r5837dd r7ba268  
    77
    88// all includes and forward declarations necessary for non-integral types below
    9 
     9#include <string>
     10#include <vector>
    1011
    1112// i.e. there is an integer with variable name Z that can be found in
    1213// ValueStorage by the token "Z" -> first column: int, Z, "Z"
    1314// "undefine" if no parameters are required, use (NODEFAULT) for each (undefined) default value
    14 #define paramtypes (std::string)(double)(int)
    15 #define paramtokens ("fragment-molecule")("distance")("order")
    16 #define paramdescriptions ("path to where the fragment configurations shall be stored")("distance in space")("order of a discretization, dissection, ...")
    17 #undef paramdefaults
    18 #define paramreferences (path)(distance)(order)
     15#define paramtypes (std::string)(double)(int)(bool)(std::vector<std::string>)
     16#define paramtokens ("fragment-molecule")("distance")("order")("DoSaturate")("output-types")
     17#define paramdescriptions ("prefix of each fragment file")("distance in space")("order of a discretization, dissection, ...")("do saturate dangling bonds with hydrogen")("type(s) of parsers that output fragment config files")
     18#define paramdefaults (NODEFAULT)(NODEFAULT)(NODEFAULT)("1")("pcp tremolo xyz")
     19#define paramreferences (prefix)(distance)(order)(DoSaturation)(types)
    1920
    2021#undef statetypes

  • src/Actions/GraphAction/DepthFirstSearchAction.cpp

    r5837dd r7ba268  
    2525#include "CodePatterns/Log.hpp"
    2626#include "CodePatterns/Verbose.hpp"
     27#include "Fragmentation/HydrogenSaturation_enum.hpp"
    2728#include "Graph/CyclicStructureAnalysis.hpp"
    2829#include "Graph/DepthFirstSearchAnalysis.hpp"
    2930#include "molecule.hpp"
     31#include "MoleculeLeafClass.hpp"
    3032#include "Descriptors/MoleculeDescriptor.hpp"
    3133#include "Descriptors/MoleculeIdDescriptor.hpp"
    … …  
    6264      LocalBackEdgeStack = new std::deque<bond *>; // no need to have it Subgraphs->Leaf->BondCount size
    6365      DFS.PickLocalBackEdges(ListOfAtoms, LocalBackEdgeStack);
    64       CyclicStructureAnalysis CycleAnalysis;
     66      CyclicStructureAnalysis CycleAnalysis(params.DoSaturation ? DoSaturate : DontSaturate);
    6567      CycleAnalysis(LocalBackEdgeStack);
    6668      delete(LocalBackEdgeStack);

  • src/Actions/GraphAction/DepthFirstSearchAction.def

    r5837dd r7ba268  
    1212// ValueStorage by the token "Z" -> first column: int, Z, "Z"
    1313// "undefine" if no parameters are required, use (NODEFAULT) for each (undefined) default value
    14 #define paramtypes (double)
    15 #define paramtokens ("depth-first-search")
    16 #define paramdescriptions ("maximum distance to look for neighbors")
    17 #undef paramdefaults
    18 #define paramreferences (distance)
     14#define paramtypes (double)(bool)
     15#define paramtokens ("depth-first-search")("DoSaturate")
     16#define paramdescriptions ("maximum distance to look for neighbors")("whether to treat hydrogen special or not")
     17#define paramdefaults (NODEFAULT)("1")
     18#define paramreferences (distance)(DoSaturation)
    1919
    2020#undef statetypes

  • src/Actions/GraphAction/SubgraphDissectionAction.cpp

    r5837dd r7ba268  
    3131#include "Graph/DepthFirstSearchAnalysis.hpp"
    3232#include "molecule.hpp"
     33#include "MoleculeListClass.hpp"
    3334#include "World.hpp"
    3435

  • src/Actions/Makefile.am

    r5837dd r7ba268  
    232232PARSERACTIONSOURCE = \
    233233  Actions/ParserAction/ParseTremoloPotentialsAction.cpp \
    234   Actions/ParserAction/SetMpqcParametersAction.cpp \
     234  Actions/ParserAction/SetParserParametersAction.cpp \
    235235  Actions/ParserAction/SetOutputFormatsAction.cpp \
    236236  Actions/ParserAction/SetTremoloAtomdataAction.cpp
    237237PARSERACTIONHEADER = \
    238238  Actions/ParserAction/ParseTremoloPotentialsAction.hpp \
    239   Actions/ParserAction/SetMpqcParametersAction.hpp \
     239  Actions/ParserAction/SetParserParametersAction.hpp \
    240240  Actions/ParserAction/SetOutputFormatsAction.hpp \
    241241  Actions/ParserAction/SetTremoloAtomdataAction.hpp
    242242PARSERACTIONDEFS = \
    243243  Actions/ParserAction/ParseTremoloPotentialsAction.def \
    244   Actions/ParserAction/SetMpqcParametersAction.def \
     244  Actions/ParserAction/SetParserParametersAction.def \
    245245  Actions/ParserAction/SetOutputFormatsAction.def \
    246246  Actions/ParserAction/SetTremoloAtomdataAction.def

  • src/Actions/MoleculeAction/CreateMicelleAction.cpp

    r5837dd r7ba268  
    3333#include "LinearAlgebra/Line.hpp"
    3434#include "molecule.hpp"
     35#include "MoleculeListClass.hpp"
    3536#include "World.hpp"
    3637

  • src/Actions/MoleculeAction/FillVoidWithMoleculeAction.cpp

    r5837dd r7ba268  
    2828#include "Descriptors/MoleculeOrderDescriptor.hpp"
    2929#include "molecule.hpp"
     30#include "MoleculeListClass.hpp"
    3031#include "Parser/FormatParserInterface.hpp"
    3132#include "Parser/FormatParserStorage.hpp"

  • src/Actions/MoleculeAction/FillWithMoleculeAction.cpp

    r5837dd r7ba268  
    2828#include "Descriptors/MoleculeOrderDescriptor.hpp"
    2929#include "molecule.hpp"
     30#include "MoleculeListClass.hpp"
    3031#include "Parser/FormatParserInterface.hpp"
    3132#include "Parser/FormatParserStorage.hpp"

  • src/Actions/MoleculeAction/LoadAction.cpp

    r5837dd r7ba268  
    2727#include "Parser/FormatParser_Parameters.hpp"
    2828#include "molecule.hpp"
     29#include "MoleculeListClass.hpp"
    2930#include "World.hpp"
    3031

  • src/Actions/ParserAction/SetOutputFormatsAction.cpp

    r5837dd r7ba268  
    4545    if (!FormatParserStorage::getInstance().add(*iter)) {
    4646      DoeLog(1) && (eLog() << Verbose(1) << "Unknown parser format in ParserSetOutputFormatsAction: '" << *iter << "'" << endl);
     47    } else {
     48      FormatParserStorage::getInstance().setOutputFormat(*iter);
    4749    }
    4850  }

  • src/Actions/ValueStorage.cpp

    r5837dd r7ba268  
    2121
    2222#include "CodePatterns/Singleton_impl.hpp"
     23
     24#include <iostream>
    2325
    2426#include "Actions/OptionTrait.hpp"
    … …  
    467469}
    468470
     471std::ostream & operator<<(std::ostream &ost, const ValueStorage &value)
     472{
     473  ost << "ValueStorage currently contains " << value.CurrentValueMap.size() << " elements:" << std::endl;
     474  for (std::map<std::string, std::string>::const_iterator iter = value.CurrentValueMap.begin();
     475      iter != value.CurrentValueMap.end();
     476      ++iter)
     477    ost << iter->first << "->" << iter->second << ", ";
     478  return ost;
     479}
     480
     481
    469482CONSTRUCT_SINGLETON(ValueStorage)

  • src/Actions/ValueStorage.hpp

    r5837dd r7ba268  
    1919#include <boost/program_options.hpp>
    2020
     21#include <iosfwd>
    2122#include <map>
    2223#include <set>
    … …  
    101102class ValueStorage : public Singleton<ValueStorage> {
    102103  friend class Singleton<ValueStorage>;
    103 
     104  friend std::ostream & operator<<(std::ostream &ost, const ValueStorage &value);
    104105public:
    105106
    … …  
    210211  const std::string getCurrentValue(std::string actionname);
    211212
     213
    212214protected:
    213215  ValueStorage();
    … …  
    219221};
    220222
     223std::ostream & operator<<(std::ostream &ost, const ValueStorage &value);
     224
     225
    221226#endif /* VALUESTORAGE_HPP_ */

  • src/Actions/WorldAction/InputAction.cpp

    r5837dd r7ba268  
    2222#include "CodePatterns/Log.hpp"
    2323#include "molecule.hpp"
     24#include "MoleculeListClass.hpp"
    2425#include "Parser/FormatParserStorage.hpp"
    2526#include "CodePatterns/Verbose.hpp"
    … …  
    4344//  molecule *mol = NULL;
    4445  boost::filesystem::ifstream test;
     46  FormatParserStorage &parsers = FormatParserStorage::getInstance();
    4547
    4648  // obtain information
    … …  
    6163#endif
    6264    DoLog(1) && (Log() << Verbose(1) << "Setting config file name prefix to " << FilenamePrefix << "." << endl);
    63     FormatParserStorage::getInstance().SetOutputPrefixForAll(FilenamePrefix);
     65    parsers.SetOutputPrefixForAll(FilenamePrefix);
    6466  } else {
    6567    DoeLog(1) && (eLog() << Verbose(1) << "Input file does not have a suffix, cannot recognize format." << endl);
    … …  
    7173    DoLog(1) && (Log() << Verbose(1) << "Specified config file " << params.filename << " not found." << endl);
    7274    // DONT FAIL: it's just empty and we use the name. // return Action::failure;
     75    // nonetheless, add to output formats
     76    parsers.setOutputFormat( parsers.getTypeFromSuffix(FilenameSuffix) );
    7377  } else {
    7478    DoLog(1) && (Log() << Verbose(1) << "Specified config file found, parsing ... ");
    … …  
    7680    // parse the file
    7781    test.open(params.filename);
    78     FormatParserStorage::getInstance().load(test, FilenameSuffix);
     82    parsers.load(test, FilenameSuffix);
     83    parsers.setOutputFormat( parsers.getTypeFromSuffix(FilenameSuffix) );
    7984    test.close();
    8085

  • src/Actions/WorldAction/RepeatBoxAction.cpp

    r5837dd r7ba268  
    2424#include "CodePatterns/Log.hpp"
    2525#include "molecule.hpp"
     26#include "MoleculeListClass.hpp"
    2627#include "LinearAlgebra/Vector.hpp"
    2728#include "LinearAlgebra/RealSpaceMatrix.hpp"

  • src/Analysis/analysis_bonds.cpp

    r5837dd r7ba268  
    2828#include "CodePatterns/Log.hpp"
    2929#include "molecule.hpp"
     30#include "MoleculeListClass.hpp"
    3031
    3132/** Calculates the min, mean and maximum bond counts for the given molecule.

  • src/Analysis/unittests/AnalysisCorrelationToPointUnitTest.cpp

    r5837dd r7ba268  
    3333#include "Element/element.hpp"
    3434#include "molecule.hpp"
     35#include "MoleculeListClass.hpp"
    3536#include "linkedcell.hpp"
    3637#include "Element/periodentafel.hpp"

  • src/Analysis/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

    r5837dd r7ba268  
    3333#include "Element/element.hpp"
    3434#include "molecule.hpp"
     35#include "MoleculeListClass.hpp"
    3536#include "linkedcell.hpp"
    3637#include "Element/periodentafel.hpp"

  • src/Analysis/unittests/AnalysisPairCorrelationUnitTest.cpp

    r5837dd r7ba268  
    3131#include "World.hpp"
    3232#include "atom.hpp"
     33#include "Element/element.hpp"
     34#include "Element/periodentafel.hpp"
     35#include "molecule.hpp"
     36#include "MoleculeListClass.hpp"
     37#include "linkedcell.hpp"
    3338#include "Tesselation/boundary.hpp"
    34 #include "Element/element.hpp"
    35 #include "molecule.hpp"
    36 #include "linkedcell.hpp"
    37 #include "Element/periodentafel.hpp"
    3839#include "Tesselation/tesselation.hpp"
    3940#include "World.hpp"

  • src/Analysis/unittests/CountBondsUnitTest.cpp

    r5837dd r7ba268  
    3434#include "Bond/bond.hpp"
    3535#include "Element/element.hpp"
     36#include "Element/periodentafel.hpp"
    3637#include "Graph/BondGraph.hpp"
    3738#include "molecule.hpp"
    38 #include "Element/periodentafel.hpp"
     39#include "MoleculeListClass.hpp"
    3940#include "World.hpp"
    4041

  • src/Fragmentation/Makefile.am

    r5837dd r7ba268  
    33
    44FRAGMENTATIONSOURCE = \
     5        Fragmentation/AdaptivityMap.cpp \
     6        Fragmentation/BondsPerShortestPath.cpp \
    57        Fragmentation/EnergyMatrix.cpp \
    68        Fragmentation/ForceMatrix.cpp \
     9        Fragmentation/Fragmentation.cpp \
     10        Fragmentation/fragmentation_helpers.cpp \
     11        Fragmentation/Graph.cpp \
    712        Fragmentation/helpers.cpp \
    813        Fragmentation/HessianMatrix.cpp \
     14        Fragmentation/KeySet.cpp \
    915        Fragmentation/KeySetsContainer.cpp \
    10         Fragmentation/MatrixContainer.cpp
     16        Fragmentation/MatrixContainer.cpp \
     17        Fragmentation/PowerSetGenerator.cpp \
     18        Fragmentation/UniqueFragments.cpp
    1119
    1220FRAGMENTATIONHEADER = \
     21        Fragmentation/AdaptivityMap.hpp \
     22        Fragmentation/BondsPerShortestPath.hpp \
    1323        Fragmentation/defs.hpp \
    1424        Fragmentation/EnergyMatrix.hpp \
    1525        Fragmentation/ForceMatrix.hpp \
     26        Fragmentation/Fragmentation.hpp \
     27        Fragmentation/fragmentation_helpers.hpp \
     28        Fragmentation/Graph.hpp \
     29        Fragmentation/helpers.cpp \
    1630        Fragmentation/helpers.hpp \
    1731        Fragmentation/HessianMatrix.hpp \
     32        Fragmentation/KeySet.hpp \
    1833        Fragmentation/KeySetsContainer.hpp \
    19         Fragmentation/MatrixContainer.hpp
     34        Fragmentation/MatrixContainer.hpp \
     35        Fragmentation/PowerSetGenerator.hpp \
     36        Fragmentation/UniqueFragments.hpp
    2037
    2138
    … …  
    3855## library file (.so).  The library ABI version is defined in configure.ac, so
    3956## that all version information is kept in one place.
    40 libMolecuilderFragmentation_la_LDFLAGS = -version-info $(MOLECUILDER_SO_VERSION)
     57#libMolecuilderFragmentation_la_LDFLAGS = -version-info $(MOLECUILDER_SO_VERSION)
    4158
    4259## The generated configuration header is installed in its own subdirectory of

  • src/Graph/BreadthFirstSearchAdd.cpp

    r5837dd r7ba268  
    3232
    3333
    34 BreadthFirstSearchAdd::BreadthFirstSearchAdd(atom *&_Root, int _BondOrder, bool _IsAngstroem) :
     34BreadthFirstSearchAdd::BreadthFirstSearchAdd(atom *&_Root, int _BondOrder, bool _IsAngstroem, const enum HydrogenSaturation _saturation) :
    3535  BondOrder(_BondOrder),
    3636  Root(_Root),
     37  saturation(_saturation),
    3738  IsAngstroem(_IsAngstroem)
    3839{
    … …  
    100101        AddedBondList[Binder] = Mol->CopyBond(AddedAtomList[Walker->getNr()], AddedAtomList[OtherAtom->getNr()], Binder);
    101102      } else {
    102 #ifdef ADDHYDROGEN
    103         if (!Mol->AddHydrogenReplacementAtom(Binder, AddedAtomList[Walker->getNr()], Walker, OtherAtom, IsAngstroem))
    104         exit(1);
    105 #endif
     103        if (saturation == DoSaturate)
     104          if (!Mol->AddHydrogenReplacementAtom(Binder, AddedAtomList[Walker->getNr()], Walker, OtherAtom, IsAngstroem))
     105            exit(1);
    106106      }
    107107    }
    … …  
    118118      AddedBondList[Binder] = Mol->CopyBond(AddedAtomList[Walker->getNr()], AddedAtomList[OtherAtom->getNr()], Binder);
    119119    } else { // if it's root bond it has to broken (otherwise we would not create the fragments)
    120 #ifdef ADDHYDROGEN
    121       if(!Mol->AddHydrogenReplacementAtom(Binder, AddedAtomList[Walker->getNr()], Walker, OtherAtom, IsAngstroem))
    122       exit(1);
    123 #endif
     120      if (saturation == DoSaturate)
     121        if(!Mol->AddHydrogenReplacementAtom(Binder, AddedAtomList[Walker->getNr()], Walker, OtherAtom, IsAngstroem))
     122          exit(1);
    124123    }
    125124  }

  • src/Graph/BreadthFirstSearchAdd.hpp

    r5837dd r7ba268  
    1818
    1919#include "Bond/GraphEdge.hpp"
     20#include "Fragmentation/HydrogenSaturation_enum.hpp"
    2021#include "Helpers/defs.hpp"
    2122#include "types.hpp"
    … …  
    2829{
    2930public:
    30   BreadthFirstSearchAdd(atom *&_Root, int _BondOrder, bool _IsAngstroem);
     31  BreadthFirstSearchAdd(atom *&_Root, int _BondOrder, bool _IsAngstroem, const enum HydrogenSaturation _saturation);
    3132  ~BreadthFirstSearchAdd();
    3233
    … …  
    7172  std::map<bond *, bond *> AddedBondList; //!< maps from father bond to son
    7273
     74  //!> whether to treat hydrogen special or not
     75  const enum HydrogenSaturation saturation;
     76
     77  //!> is angstroem our unit of length
    7378  bool IsAngstroem;
    7479};

  • src/Graph/CheckAgainstAdjacencyFile.cpp

    r5837dd r7ba268  
    2828#include "CodePatterns/Assert.hpp"
    2929#include "CodePatterns/Log.hpp"
    30 #include "CodePatterns/Verbose.hpp"
     30#include "CodePatterns/Range.hpp"
     31#include "Descriptors/AtomIdDescriptor.hpp"
    3132#include "Helpers/defs.hpp"
    32 
    33 CheckAgainstAdjacencyFile::CheckAgainstAdjacencyFile() :
    34   CurrentBonds(new int[MAXBONDS]),
     33#include "World.hpp"
     34
     35CheckAgainstAdjacencyFile::CheckAgainstAdjacencyFile(World::AtomSet::const_iterator AtomMapBegin, World::AtomSet::const_iterator AtomMapEnd) :
    3536  status(true),
    3637  NonMatchNumber(0)
    3738{
    38   for(int i=0;i<MAXBONDS;i++)
    39     CurrentBonds[i] = 0;
     39  CreateInternalMap(AtomMapBegin, AtomMapEnd);
    4040}
    4141
    4242CheckAgainstAdjacencyFile::~CheckAgainstAdjacencyFile()
    4343{
    44   delete[](CurrentBonds);
    45 }
    46 
    47 void CheckAgainstAdjacencyFile::CompareBonds(const atom *&Walker, size_t &CurrentBondsOfAtom, int AtomNr, std::map<int, atom*> &ListOfAtoms)
    48 {
    49   size_t j = 0;
    50   int id = -1;
    51 
    52   //Log() << Verbose(2) << "Walker is " << *Walker << ", bond partners: ";
    53   const BondList& ListOfBonds = Walker->getListOfBonds();
    54   if (CurrentBondsOfAtom == ListOfBonds.size()) {
    55     for (BondList::const_iterator Runner = ListOfBonds.begin();
    56         Runner != ListOfBonds.end();
    57         ++Runner) {
    58       id = (*Runner)->GetOtherAtom(Walker)->getNr();
    59       j = 0;
    60       for (; (j < CurrentBondsOfAtom) && (CurrentBonds[j++] != id);)
    61         ; // check against all parsed bonds
    62       if (CurrentBonds[j - 1] != id) { // no match ? Then mark in ListOfAtoms
    63         ListOfAtoms[AtomNr] = NULL;
    64         NonMatchNumber++;
    65         status = false;
    66         ELOG(2, id << " can not be found in list." << endl);
    67       } else {
    68         //Log() << Verbose(0) << "[" << id << "]\t";
    69       }
    70     }
    71     //Log() << Verbose(0) << endl;
    72   } else {
    73     LOG(0, "STATUS: Number of bonds for Atom " << *Walker << " does not match, parsed " << CurrentBondsOfAtom << " against " << ListOfBonds.size() << ".");
    74     status = false;
    75   }
    76 }
    77 ;
    78 
    79 /** Checks contents of adjacency file against bond structure in structure molecule.
    80  * \param File file to parser
    81  * \param ListOfAtoms map from int (index in file) to atom
    82  * \return true - structure is equal, false - not equivalence
    83  */
    84 bool CheckAgainstAdjacencyFile::operator()(std::ifstream &File, std::map<int, atom*> ListOfAtoms)
    85 {
    86   LOG(0, "STATUS: Looking at bond structure stored in adjacency file and comparing to present one ... ");
     44  ExternalAtomBondMap.clear();
     45  InternalAtomBondMap.clear();
     46}
     47
     48/** Parses the bond partners of each atom from an external file into \a AtomBondMap.
     49 *
     50 * @param File file to parse
     51 * @return true - everything ok, false - error while parsing
     52 */
     53bool CheckAgainstAdjacencyFile::ParseInExternalMap(std::istream &File)
     54{
    8755  if (File.fail()) {
    8856    LOG(1, "STATUS: Adjacency file not found." << endl);
    … …  
    9058  }
    9159
     60  ExternalAtomBondMap.clear();
    9261  char buffer[MAXSTRINGSIZE];
    9362  int tmp;
    … …  
    9968    int AtomNr = -1;
    10069    line >> AtomNr;
    101     size_t CurrentBondsOfAtom = -1; // we count one too far due to line end
    10270    // parse into structure
    10371    if (AtomNr >= 0) {
    104       ASSERT(ListOfAtoms.count(AtomNr),
    105           "CheckAgainstAdjacencyFile::operator() - index "
    106           +toString(AtomNr)+" not present in ListOfAtoms.");
    107       const atom *Walker = ListOfAtoms[AtomNr];
     72      const atom *Walker = World::getInstance().getAtom(AtomById(AtomNr));
     73      ASSERT(Walker != NULL,
     74          "CheckAgainstAdjacencyFile::ParseInExternalMap() - there is no atom with id "+toString(AtomNr)+".");
     75      if (Walker == NULL)
     76        return false;
     77      // parse bond partner ids associated to AtomNr
    10878      while (line >> ws >> tmp) {
    10979        LOG(3, "INFO: Recognized bond partner " << tmp);
    110         CurrentBonds[++CurrentBondsOfAtom] = tmp;
    111         ASSERT(CurrentBondsOfAtom < MAXBONDS,
    112             "molecule::CheckAdjacencyFileAgainstMolecule() - encountered more bonds than allowed: "
    113             +toString(CurrentBondsOfAtom)+" >= "+toString(int(MAXBONDS))+"!");
     80        ExternalAtomBondMap.insert( std::make_pair(AtomNr, tmp) );
    11481      }
    115       // compare against present bonds
    116       CompareBonds(Walker, CurrentBondsOfAtom, AtomNr, ListOfAtoms);
    11782    } else {
    118       if (AtomNr != -1)
     83      if (AtomNr != -1) {
    11984        ELOG(2, AtomNr << " is negative.");
     85        return false;
     86      }
    12087    }
    12188  }
     89  return true;
     90}
     91
     92/** Fills the InternalAtomBondMap from the atoms given by the two iterators.
     93 *
     94 * @param AtomMapBegin iterator pointing to begin of map (think of World's SelectionIterator)
     95 * @param AtomMapEnd iterator pointing past end of map (think of World's SelectionIterator)
     96 */
     97void CheckAgainstAdjacencyFile::CreateInternalMap(World::AtomSet::const_iterator &AtomMapBegin, World::AtomSet::const_iterator &AtomMapEnd)
     98{
     99  InternalAtomBondMap.clear();
     100  // go through each atom in the list
     101  for (World::AtomSet::const_iterator iter = AtomMapBegin; iter != AtomMapEnd; ++iter) {
     102    const atom *Walker = iter->second;
     103    const atomId_t WalkerId = Walker->getId();
     104    ASSERT(WalkerId != (size_t)-1,
     105        "CheckAgainstAdjacencyFile::CreateInternalMap() - Walker has no id.");
     106    const BondList& ListOfBonds = Walker->getListOfBonds();
     107    // go through each of its bonds
     108    for (BondList::const_iterator Runner = ListOfBonds.begin();
     109        Runner != ListOfBonds.end();
     110        ++Runner) {
     111      const atomId_t id = (*Runner)->GetOtherAtom(Walker)->getId();
     112      ASSERT(id != (size_t)-1,
     113          "CheckAgainstAdjacencyFile::CreateInternalMap() - OtherAtom has not id.");
     114      InternalAtomBondMap.insert( std::make_pair(WalkerId, id) );
     115    }
     116  }
     117}
     118
     119/** Checks contents of adjacency file against bond structure in structure molecule.
     120 * \param File file to parser
     121 * \return true - structure is equal, false - not equivalence
     122 */
     123bool CheckAgainstAdjacencyFile::operator()(std::istream &File)
     124{
     125  LOG(0, "STATUS: Looking at bond structure stored in adjacency file and comparing to present one ... ");
     126
     127  bool status = true;
     128
     129  status = status && ParseInExternalMap(File);
     130  status = status && CompareInternalExternalMap();
    122131
    123132  if (status) { // if equal we parse the KeySetFile
    … …  
    127136  return status;
    128137}
    129 ;
     138
     139template <class T>
     140CheckAgainstAdjacencyFile::KeysSet getKeys(const CheckAgainstAdjacencyFile::AtomBondRange &_range)
     141{
     142  CheckAgainstAdjacencyFile::KeysSet Keys;
     143  for (typename T::const_iterator iter = _range.first;
     144      iter != _range.second;
     145      ++iter) {
     146    Keys.insert( iter->first );
     147  }
     148  return Keys;
     149}
     150
     151template <class T>
     152CheckAgainstAdjacencyFile::ValuesSet getValues(const CheckAgainstAdjacencyFile::AtomBondRange&_range)
     153{
     154  CheckAgainstAdjacencyFile::ValuesSet Values;
     155  for (typename T::const_iterator iter = _range.first;
     156      iter != _range.second;
     157      ++iter) {
     158    Values.insert( iter->second );
     159  }
     160  return Values;
     161}
     162
     163/** Counts the number of mismatching items in each set.
     164 *
     165 * @param firstset first set
     166 * @param secondset second set
     167 * @return number of items that don't match between first and second set
     168 */
     169template <class T>
     170size_t getMismatchingItems(const T &firstset, const T &secondset)
     171{
     172  size_t Mismatch = 0;
     173  typename T::const_iterator firstiter = firstset.begin();
     174  typename T::const_iterator seconditer = secondset.begin();
     175  for (; (firstiter != firstset.end()) && (seconditer != secondset.end());
     176      ++firstiter, ++seconditer) {
     177    if (*firstiter != *seconditer)
     178      ++Mismatch;
     179  }
     180  return Mismatch;
     181}
     182
     183/** Compares InternalAtomBondMap and ExternalAtomBondMap and sets NonMatchNumber.
     184 *
     185 * @return true - both maps are the same, false - both maps diverge by NonMatchNumber counts.
     186 */
     187bool CheckAgainstAdjacencyFile::CompareInternalExternalMap()
     188{
     189  NonMatchNumber = 0;
     190  // check whether sizes match
     191  if (ExternalAtomBondMap.size() != InternalAtomBondMap.size()) {
     192    NonMatchNumber = abs((int)ExternalAtomBondMap.size() - (int)InternalAtomBondMap.size());
     193    LOG(2, "INFO: " << NonMatchNumber << " entries don't match.");
     194    return false;
     195  }
     196  // extract keys and check whether they match
     197  const AtomBondRange Intrange(InternalAtomBondMap.begin(), InternalAtomBondMap.end());
     198  const AtomBondRange Extrange(ExternalAtomBondMap.begin(), ExternalAtomBondMap.end());
     199  KeysSet InternalKeys( getKeys<AtomBondMap>(Intrange) );
     200  KeysSet ExternalKeys( getKeys<AtomBondMap>(Extrange) );
     201
     202//  std::cout << "InternalKeys: " << InternalKeys << std::endl;
     203//  std::cout << "ExternalKeys: " << ExternalKeys << std::endl;
     204
     205  // check for same amount of keys
     206  if (InternalKeys.size() != ExternalKeys.size()) {
     207    NonMatchNumber = abs((int)ExternalKeys.size() - (int)InternalKeys.size());
     208    LOG(2, "INFO: Number of keys don't match: "
     209        << InternalKeys.size() << " != " << ExternalKeys.size());
     210    return false;
     211  }
     212
     213  // check items against one another
     214  NonMatchNumber = getMismatchingItems(InternalKeys, ExternalKeys);
     215
     216  if (NonMatchNumber != 0) {
     217    LOG(2, "INFO: " << NonMatchNumber << " keys are not the same.");
     218    return false;
     219  }
     220
     221  // now check each map per key
     222  for (KeysSet::const_iterator keyIter = InternalKeys.begin();
     223      keyIter != InternalKeys.end();
     224      ++keyIter) {
     225//    std::cout << "Current key is " << *keyIter << std::endl;
     226    const AtomBondRange IntRange( InternalAtomBondMap.equal_range(*keyIter) );
     227    const AtomBondRange ExtRange( ExternalAtomBondMap.equal_range(*keyIter) );
     228    ValuesSet InternalValues( getValues<AtomBondMap>(IntRange) );
     229    ValuesSet ExternalValues( getValues<AtomBondMap>(ExtRange) );
     230//    std::cout << "InternalValues: " << InternalValues << std::endl;
     231//    std::cout << "ExternalValues: " << ExternalValues << std::endl;
     232    NonMatchNumber += getMismatchingItems(InternalValues, ExternalValues);
     233  }
     234  if (NonMatchNumber != 0) {
     235    LOG(2, "INFO: " << NonMatchNumber << " keys are not the same.");
     236    return false;
     237  } else {
     238    LOG(2, "INFO: All keys are the same.");
     239    return true;
     240  }
     241}

  • src/Graph/CheckAgainstAdjacencyFile.hpp

    r5837dd r7ba268  
    1616#include <iosfwd>
    1717#include <map>
     18#include <set>
     19
     20#include "types.hpp"
     21#include "World.hpp"
    1822
    1923class atom;
    … …  
    2125class CheckAgainstAdjacencyFile
    2226{
     27  //!> Unit test is granted access to internal data
     28  friend class CheckAgainstAdjacencyFileTest;
    2329public:
    24   CheckAgainstAdjacencyFile();
     30  CheckAgainstAdjacencyFile(World::AtomSet::const_iterator AtomMapBegin, World::AtomSet::const_iterator AtomMapEnd);
    2531  ~CheckAgainstAdjacencyFile();
    2632
    27   bool operator()(std::ifstream &File, std::map<int, atom*> ListOfAtoms);
     33  bool operator()(std::istream &File);
    2834
    2935private:
    30   enum {MAXBONDS=8};
    31 
    32   int *CurrentBonds;
     36  typedef std::set<atomId_t> KeysSet;
     37  typedef std::set<atomId_t> ValuesSet;
     38  typedef std::pair<atomId_t, atomId_t> AtomBondPair;
     39  typedef std::multimap< atomId_t, atomId_t > AtomBondMap;
     40  typedef std::pair<AtomBondMap::const_iterator, AtomBondMap::const_iterator> AtomBondRange;
     41  AtomBondMap InternalAtomBondMap;
     42  AtomBondMap ExternalAtomBondMap;
    3343  bool status;
    3444  int NonMatchNumber;
    3545
    36   void CompareBonds(const atom *&Walker, size_t &CurrentBondsOfAtom, int AtomNr, std::map<int, atom*> &ListOfAtoms);
     46  void CreateInternalMap(World::AtomSet::const_iterator &AtomMapBegin, World::AtomSet::const_iterator &AtomMapEnd);
     47  bool ParseInExternalMap(std::istream &File);
     48  bool CompareInternalExternalMap();
    3749};
    3850

  • src/Graph/ConnectedSubgraph.cpp

    r5837dd r7ba268  
    2929#include "CodePatterns/Verbose.hpp"
    3030#include "molecule.hpp"
     31#include "MoleculeListClass.hpp"
    3132#include "World.hpp"
    3233

  • src/Graph/CyclicStructureAnalysis.cpp

    r5837dd r7ba268  
    3131#include "molecule.hpp"
    3232
    33 CyclicStructureAnalysis::CyclicStructureAnalysis()
     33CyclicStructureAnalysis::CyclicStructureAnalysis(const enum HydrogenSaturation _saturation) :
     34  saturation(_saturation)
    3435{}
    3536
    … …  
    101102      if ((*Runner) != BackEdge) { // only walk along DFS spanning tree (otherwise we always find SP of one being backedge Binder)
    102103        OtherAtom = (*Runner)->GetOtherAtom(Walker);
    103 #ifdef ADDHYDROGEN
    104         if (OtherAtom->getType()->getAtomicNumber() != 1) {
    105 #endif
    106         LOG(2, "INFO: Current OtherAtom is: " << OtherAtom->getName() << " for bond " << *(*Runner) << "." << endl);
    107         if (ColorList[OtherAtom->getNr()] == GraphEdge::white) {
    108           TouchedStack.push_front(OtherAtom);
    109           ColorList[OtherAtom->getNr()] = GraphEdge::lightgray;
    110           PredecessorList[OtherAtom->getNr()] = Walker; // Walker is the predecessor
    111           ShortestPathList[OtherAtom->getNr()] = ShortestPathList[Walker->getNr()] + 1;
    112           LOG(2, "INFO: Coloring OtherAtom " << OtherAtom->getName() << " lightgray, its predecessor is " << Walker->getName() << " and its Shortest Path is " << ShortestPathList[OtherAtom->getNr()] << " egde(s) long." << endl);
    113           //if (ShortestPathList[OtherAtom->getNr()] < MinimumRingSize[Walker->GetTrueFather()->getNr()]) { // Check for maximum distance
    114           LOG(3, "ACCEPT: Putting OtherAtom into queue." << endl);
    115           BFSStack.push_front(OtherAtom);
    116           //}
     104        if ((saturation == DontSaturate) || (OtherAtom->getType()->getAtomicNumber() != 1)) {
     105          LOG(2, "INFO: Current OtherAtom is: " << OtherAtom->getName() << " for bond " << *(*Runner) << "." << endl);
     106          if (ColorList[OtherAtom->getNr()] == GraphEdge::white) {
     107            TouchedStack.push_front(OtherAtom);
     108            ColorList[OtherAtom->getNr()] = GraphEdge::lightgray;
     109            PredecessorList[OtherAtom->getNr()] = Walker; // Walker is the predecessor
     110            ShortestPathList[OtherAtom->getNr()] = ShortestPathList[Walker->getNr()] + 1;
     111            LOG(2, "INFO: Coloring OtherAtom " << OtherAtom->getName() << " lightgray, its predecessor is " << Walker->getName() << " and its Shortest Path is " << ShortestPathList[OtherAtom->getNr()] << " egde(s) long." << endl);
     112            //if (ShortestPathList[OtherAtom->getNr()] < MinimumRingSize[Walker->GetTrueFather()->getNr()]) { // Check for maximum distance
     113            LOG(3, "ACCEPT: Putting OtherAtom into queue." << endl);
     114            BFSStack.push_front(OtherAtom);
     115            //}
     116          } else {
     117            LOG(3, "REJECT: Not Adding, has already been visited." << endl);
     118          }
     119          if (OtherAtom == Root)
     120            break;
    117121        } else {
    118           LOG(3, "REJECT: Not Adding, has already been visited." << endl);
     122          LOG(2, "INFO: Skipping hydrogen atom " << *OtherAtom << "." << endl);
     123          ColorList[OtherAtom->getNr()] = GraphEdge::black;
    119124        }
    120         if (OtherAtom == Root)
    121           break;
    122 #ifdef ADDHYDROGEN
    123       } else {
    124         LOG(2, "INFO: Skipping hydrogen atom " << *OtherAtom << "." << endl);
    125         ColorList[OtherAtom->getNr()] = GraphEdge::black;
    126       }
    127 #endif
    128125      } else {
    129126        LOG(2, "REJECT: Bond " << *(*Runner) << " not Visiting, is the back edge." << endl);

  • src/Graph/CyclicStructureAnalysis.hpp

    r5837dd r7ba268  
    1818
    1919#include "Bond/GraphEdge.hpp"
     20#include "Fragmentation/HydrogenSaturation_enum.hpp"
    2021#include "Helpers/defs.hpp"
    2122#include "types.hpp"
    … …  
    2829{
    2930public:
    30   CyclicStructureAnalysis();
     31  explicit CyclicStructureAnalysis(const enum HydrogenSaturation _saturation);
    3132  ~CyclicStructureAnalysis();
    3233
    … …  
    5859  atom *Root;
    5960
     61  //!> whether to treat hydrogen special or not
     62  const enum HydrogenSaturation saturation;
     63
    6064  bool BackStepping;
    6165  int CurrentGraphNr;

  • src/Graph/DepthFirstSearchAnalysis.cpp

    r5837dd r7ba268  
    3333#include "Descriptors/AtomDescriptor.hpp"
    3434#include "molecule.hpp"
     35#include "MoleculeLeafClass.hpp"
     36#include "MoleculeListClass.hpp"
    3537#include "World.hpp"
    3638

  • src/Graph/Makefile.am

    r5837dd r7ba268  
    3939## library file (.so).  The library ABI version is defined in configure.ac, so
    4040## that all version information is kept in one place.
    41 libMolecuilderGraph_la_LDFLAGS = -version-info $(MOLECUILDER_SO_VERSION)
     41#libMolecuilderGraph_la_LDFLAGS = -version-info $(MOLECUILDER_SO_VERSION)
    4242
    4343## The generated configuration header is installed in its own subdirectory of

  • src/Graph/unittests/Makefile.am

    r5837dd r7ba268  
    33
    44GRAPHTESTSSOURCES = \
    5         ../Graph/unittests/BondGraphUnitTest.cpp
     5        ../Graph/unittests/BondGraphUnitTest.cpp \
     6        ../Graph/unittests/CheckAgainstAdjacencyFileUnitTest.cpp
    67
    78GRAPHTESTSHEADERS = \
    8         ../Graph/unittests/BondGraphUnitTest.hpp
     9        ../Graph/unittests/BondGraphUnitTest.hpp \
     10        ../Graph/unittests/CheckAgainstAdjacencyFileUnitTest.hpp
    911
    1012GRAPHTESTS = \
    11   BondGraphUnitTest
     13        BondGraphUnitTest \
     14        CheckAgainstAdjacencyFileUnitTest
     15
    1216
    1317TESTS += $(GRAPHTESTS)
    … …  
    2832BondGraphUnitTest_LDADD = ${GRAPHLIBS}
    2933
     34CheckAgainstAdjacencyFileUnitTest_SOURCES = $(top_srcdir)/src/unittests/UnitTestMain.cpp \
     35        ../Graph/unittests/CheckAgainstAdjacencyFileUnitTest.cpp \
     36        ../Graph/unittests/CheckAgainstAdjacencyFileUnitTest.hpp
     37CheckAgainstAdjacencyFileUnitTest_LDADD = ${ALLLIBS}
     38
    3039
    3140

  • src/Makefile.am

    r5837dd r7ba268  
    1010include Analysis/Makefile.am
    1111include Element/Makefile.am
     12include Fragmentation/Makefile.am
    1213include Graph/Makefile.am
    1314include Helpers/Makefile.am
    14 include Fragmentation/Makefile.am
    1515include Parser/Makefile.am
    1616include RandomNumbers/Makefile.am
    … …  
    171171  ConfigFileBuffer.cpp \
    172172  Formula.cpp \
    173   graph.cpp \
    174173  linkedcell.cpp \
     174  MoleculeLeafClass.cpp \
    175175  moleculelist.cpp \
    176176  molecule.cpp \
    177   molecule_fragmentation.cpp \
    178177  molecule_geometry.cpp \
    179178  molecule_graph.cpp \
    … …  
    196195  ConfigFileBuffer.hpp \
    197196  Formula.hpp \
    198   graph.hpp \
    199197  linkedcell.hpp \
     198  MoleculeLeafClass.hpp \
    200199  molecule.hpp \
    201200  ThermoStatContainer.hpp \

  • src/Parser/FormatParserStorage.cpp

    r5837dd r7ba268  
    4141#include "CodePatterns/Singleton_impl.hpp"
    4242
     43const std::string FormatParserStorage::unknownTypeString("unknown");
    4344
    4445/** Constructor of class FormatParserStorage.
    … …  
    4950  ParserStream.resize(ParserTypes_end, NULL);
    5051  ParserPresent.resize(ParserTypes_end, false);
     52  ParserDesiredOutputFormat.resize(ParserTypes_end, false);
    5153
    5254#include "ParserTypes.def"
    … …  
    122124  for (ParserTypes iter = ParserTypes_begin; iter < ParserTypes_end; ++iter)
    123125    if (ParserPresent[iter]) {
    124       if (ParserStream[iter]->is_open())
    125         ParserStream[iter]->close();
    126       delete ParserStream[iter];
     126      if (ParserStream[iter] != NULL) {
     127        if (ParserStream[iter]->is_open())
     128          ParserStream[iter]->close();
     129        delete ParserStream[iter];
     130      }
    127131      delete ParserList[iter];
    128132    }
    … …  
    137141};
    138142
    139 
     143/** Sets \a type as a format to be stored on call of SaveAll.
     144 *
     145 * @param type type to add to desired output formats
     146 */
     147void FormatParserStorage::setOutputFormat(ParserTypes type)
     148{
     149  LOG(0, "STATUS: Adding " << ParserNames[type] << " type to output.");
     150  ParserDesiredOutputFormat[type] = true;
     151}
     152
     153/** Sets \a type as a format to be stored on call of SaveAll.
     154 *
     155 * @param type type to add to desired output formats
     156 */
     157void FormatParserStorage::setOutputFormat(std::string type)
     158{
     159  std::map<std::string, ParserTypes>::const_iterator iter = ParserLookupNames.find(type);
     160  ASSERT(iter != ParserLookupNames.end(),
     161      "FormatParserStorage::setOutputFormat() - output format "+type+" is unknown.");
     162  setOutputFormat(iter->second);
     163}
     164
     165/** Saves the world in the desired output formats.
     166 *
     167 */
    140168void FormatParserStorage::SaveAll()
    141169{
    142170  std::string filename;
    143171  for (ParserTypes iter = ParserTypes_begin; iter < ParserTypes_end; ++iter)
    144     if (ParserPresent[iter]) {
     172    if (ParserPresent[iter] && ParserDesiredOutputFormat[iter]) {
    145173      filename = prefix;
    146174      filename += ".";
    … …  
    170198}
    171199
     200const std::string &FormatParserStorage::getNameFromType(ParserTypes type)
     201{
     202  if (ParserNames.find(type) == ParserNames.end()) {
     203    DoeLog(1) && (eLog() << Verbose(1) << "Unknown type " << type << "." << endl);
     204    return unknownTypeString;
     205  } else
     206    return ParserNames[type];
     207}
     208
     209const std::string &FormatParserStorage::getSuffixFromType(ParserTypes type)
     210{
     211  if (ParserSuffixes.find(type) == ParserSuffixes.end()) {
     212    DoeLog(1) && (eLog() << Verbose(1) << "Unknown type " << type << "." << endl);
     213    return unknownTypeString;
     214  } else
     215    return ParserSuffixes[type];
     216}
     217
    172218bool FormatParserStorage::add(ParserTypes ptype)
    173219{
    174220  if (ptype != ParserTypes_end) {
    175221    if (ParserAddFunction.find(ptype) != ParserAddFunction.end()) {
    176       LOG(0, "STATUS: Adding " << ParserNames[ptype] << " type to output.");
    177222      (getInstance().*(ParserAddFunction[ptype]))(); // we still need an object to work on ...
    178223      return true;

  • src/Parser/FormatParserStorage.hpp

    r5837dd r7ba268  
    4141  bool saveSelectedMolecules(std::ostream &output, std::string suffix);
    4242  bool saveWorld(std::ostream &output, std::string suffix);
     43
     44  void setOutputFormat(ParserTypes type);
     45  void setOutputFormat(std::string type);
    4346 
    4447  FormatParserInterface &get(ParserTypes _type);
    … …  
    4649  ParserTypes getTypeFromName(std::string type);
    4750  ParserTypes getTypeFromSuffix(std::string type);
     51
     52  const std::string &getSuffixFromType(ParserTypes type);
     53  const std::string &getNameFromType(ParserTypes type);
    4854
    4955  void SetOutputPrefixForAll(std::string &_prefix);
    … …  
    6470  std::vector<bool> ParserPresent;
    6571
     72  // which parser is already present
     73  std::vector<bool> ParserDesiredOutputFormat;
     74
    6675  // default suffix of each parser type
    6776  std::map<ParserTypes, std::string> ParserSuffixes;
    … …  
    7786  // prefix of the filenames to use on save
    7887  std::string prefix;
     88
     89  static const std::string unknownTypeString;
    7990
    8091public:

  • src/Parser/FormatParser_Parameters.cpp

    r5837dd r7ba268  
    129129      iter != params.storage->getEndIter();
    130130      ++iter)
    131     output << iter->first
    132           <<  "=" << iter->second->get() << ";";
     131    if (!iter->second->get().empty())
     132      output << iter->first <<  "=" << iter->second->get() << ";";
    133133  ost << output.str();
    134134  return ost;
    … …  
    160160    if (paramtokens.begin() != paramtokens.end()) {
    161161      tokenizer::iterator tok_paramiter = paramtokens.begin();
     162      ASSERT(tok_paramiter != paramtokens.end(),
     163          "operator<< on FormatParser_Parameters - missing value before ' =' in token "+*tok_iter+"!");
    162164      tokenizer::iterator tok_valueiter = tok_paramiter;
    163165      tokenizer::iterator tok_checkiter = ++tok_valueiter;
    164       ++tok_checkiter;
    165       LOG(3, "INFO: key is '" << *tok_paramiter << "', value is '" << *tok_valueiter << "'.");
    166       // TODO: throw exception instead of ASSERT
    167       ASSERT(tok_paramiter != paramtokens.end(),
    168           "operator<< on FormatParser_Parameters - missing value before ' =' in token "+*tok_iter+"!");
    169166      ASSERT(tok_valueiter != paramtokens.end(),
    170167          "operator<< on FormatParser_Parameters - missing value after ' =' in token "+*tok_iter+"!");
     168      ++tok_checkiter;
    171169      ASSERT(tok_checkiter == paramtokens.end(),
    172170          "operator<< on FormatParser_Parameters - still more tokens after ' =' in token "+*tok_iter+":"
    173171          +*tok_checkiter+"!");
     172      LOG(3, "INFO: key is '" << *tok_paramiter << "', value is '" << *tok_valueiter << "'.");
     173      // TODO: throw exception instead of ASSERT
    174174      std::string key(*tok_paramiter);
    175175      std::string value(*tok_valueiter);

  • src/Parser/FormatParser_common.cpp

    r5837dd r7ba268  
    3333 */
    3434FormatParser_common::FormatParser_common(FormatParser_Parameters *_parameters) :
    35   Observer("FormatParser_common")
     35  Observer("FormatParser_common"),
     36  saveStream(NULL)
    3637{
    3738  parameters = _parameters;
    … …  
    5859 */
    5960void FormatParser_common::update(Observable *publisher) {
    60   if (!saveStream) {
    61     cerr << "Please invoke setOstream() so the parser knows where to save the World's data." << endl;
    62     return;
     61  if (saveStream != NULL) { // only store when a saveStream is given
     62    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
     63    save(saveStream, atoms);
    6364  }
    64 
    65   std::vector<atom *> atoms = World::getInstance().getAllAtoms();
    66   save(saveStream, atoms);
    6765}
    6866

  • src/Parser/MpqcParser.cpp

    r5837dd r7ba268  
    3131#include "Element/element.hpp"
    3232#include "molecule.hpp"
     33#include "MoleculeListClass.hpp"
    3334#include "CodePatterns/Log.hpp"
    3435#include "CodePatterns/toString.hpp"

  • src/Parser/PcpParser.cpp

    r5837dd r7ba268  
    3333#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3434#include "molecule.hpp"
     35#include "MoleculeListClass.hpp"
    3536#include "PcpParser.hpp"
    3637#include "Element/periodentafel.hpp"

  • src/Parser/PdbParser.cpp

    r5837dd r7ba268  
    2424#include "CodePatterns/toString.hpp"
    2525#include "CodePatterns/Verbose.hpp"
    26 #include "Descriptors/AtomIdDescriptor.hpp"
    27 #include "World.hpp"
     26
    2827#include "atom.hpp"
    2928#include "Bond/bond.hpp"
     29#include "Descriptors/AtomIdDescriptor.hpp"
    3030#include "Element/element.hpp"
     31#include "Element/periodentafel.hpp"
    3132#include "molecule.hpp"
    32 #include "Element/periodentafel.hpp"
    33 #include "Descriptors/AtomIdDescriptor.hpp"
     33#include "MoleculeListClass.hpp"
    3434#include "Parser/PdbParser.hpp"
    3535#include "World.hpp"

  • src/Parser/Psi3Parser.cpp

    r5837dd r7ba268  
    3232#include "Element/periodentafel.hpp"
    3333#include "molecule.hpp"
     34#include "MoleculeListClass.hpp"
    3435#include "CodePatterns/Log.hpp"
    3536#include "CodePatterns/toString.hpp"

  • src/Parser/TremoloParser.cpp

    r5837dd r7ba268  
    2424#include "CodePatterns/toString.hpp"
    2525#include "CodePatterns/Verbose.hpp"
     26
    2627#include "TremoloParser.hpp"
     28
     29#include "atom.hpp"
     30#include "Bond/bond.hpp"
     31#include "Descriptors/AtomIdDescriptor.hpp"
     32#include "Element/element.hpp"
     33#include "Element/periodentafel.hpp"
     34#include "molecule.hpp"
     35#include "MoleculeListClass.hpp"
    2736#include "World.hpp"
    2837#include "WorldTime.hpp"
    29 #include "atom.hpp"
    30 #include "Bond/bond.hpp"
    31 #include "Element/element.hpp"
    32 #include "molecule.hpp"
    33 #include "Element/periodentafel.hpp"
    34 #include "Descriptors/AtomIdDescriptor.hpp"
     38
    3539#include <map>
    3640#include <vector>

  • src/Parser/XyzParser.cpp

    r5837dd r7ba268  
    2424#include "CodePatterns/Log.hpp"
    2525#include "CodePatterns/Verbose.hpp"
     26
    2627#include "XyzParser.hpp"
    27 #include "World.hpp"
     28
    2829#include "atom.hpp"
    29 #include "molecule.hpp"
    3030#include "Element/element.hpp"
    3131#include "Element/periodentafel.hpp"
     32#include "molecule.hpp"
     33#include "MoleculeListClass.hpp"
     34#include "World.hpp"
    3235
    3336using namespace std;

  • src/Tesselation/boundary.cpp

    r5837dd r7ba268  
    3535#include "linkedcell.hpp"
    3636#include "molecule.hpp"
     37#include "MoleculeListClass.hpp"
    3738#include "PointCloudAdaptor.hpp"
    3839#include "RandomNumbers/RandomNumberGeneratorFactory.hpp"

  • src/UIElements/MainWindow.hpp

    r5837dd r7ba268  
    1515
    1616
    17 class MoleculeListClass;
    18 class config;
    19 class periodentafel;
    20 
    21 class Menu;
    22 
    2317class MainWindow
    2418{

  • src/UIElements/TextUI/TextWindow.cpp

    r5837dd r7ba268  
    4747#include "Element/periodentafel.hpp"
    4848
    49 // config::SaveAll() and enumerate()
    50 #include "molecule.hpp"
     49// needed due to Enumerate()
     50#include "MoleculeListClass.hpp"
    5151
    5252#include <iostream>

  • src/UIElements/Views/Qt4/QtWorldView.cpp

    r5837dd r7ba268  
    2727#include "Formula.hpp"
    2828#include "molecule.hpp"
     29#include "MoleculeListClass.hpp"
    2930
    3031using namespace std;

  • src/World.cpp

    r5837dd r7ba268  
    3636#include "Descriptors/MoleculeDescriptor_impl.hpp"
    3737#include "Descriptors/SelectiveIterator_impl.hpp"
     38#include "Element/periodentafel.hpp"
    3839#include "Graph/DepthFirstSearchAnalysis.hpp"
    3940#include "Helpers/defs.hpp"
    4041#include "LinearAlgebra/RealSpaceMatrix.hpp"
    4142#include "molecule.hpp"
    42 #include "Element/periodentafel.hpp"
     43#include "MoleculeListClass.hpp"
    4344#include "ThermoStatContainer.hpp"
    4445#include "WorldTime.hpp"

  • src/config.cpp

    r5837dd r7ba268  
    3535#include "ConfigFileBuffer.hpp"
    3636#include "Element/element.hpp"
     37#include "Element/periodentafel.hpp"
    3738#include "Graph/BondGraph.hpp"
    3839#include "Helpers/helpers.hpp"
    3940#include "LinearAlgebra/RealSpaceMatrix.hpp"
    4041#include "molecule.hpp"
    41 #include "molecule.hpp"
    42 #include "Element/periodentafel.hpp"
     42#include "MoleculeListClass.hpp"
    4343#include "ThermoStatContainer.hpp"
    4444#include "World.hpp"

  • src/molecule.cpp

    r5837dd r7ba268  
    3333#include "config.hpp"
    3434#include "Element/element.hpp"
    35 #include "graph.hpp"
    3635#include "Graph/BondGraph.hpp"
    3736#include "LinearAlgebra/Exceptions.hpp"

  • src/molecule.hpp

    r5837dd r7ba268  
    2424
    2525#include "types.hpp"
    26 #include "graph.hpp"
    2726#include "CodePatterns/Observer.hpp"
    2827#include "CodePatterns/ObservedIterator.hpp"
    2928#include "CodePatterns/Cacheable.hpp"
     29#include "Fragmentation/HydrogenSaturation_enum.hpp"
    3030#include "Helpers/defs.hpp"
    3131#include "Formula.hpp"
    … …  
    4343class element;
    4444class ForceMatrix;
     45class Graph;
    4546class LinkedCell;
    4647class molecule;
    … …  
    5354
    5455/******************************** Some definitions for easier reading **********************************/
    55 
    56 #define MoleculeList list <molecule *>
    57 #define MoleculeListTest pair <MoleculeList::iterator, bool>
    5856
    5957/************************************* Class definitions ****************************************/
    … …  
    189187  void Align(Vector *n);
    190188  void Scale(const double ** const factor);
    191   void DeterminePeriodicCenter(Vector &center);
     189  void DeterminePeriodicCenter(Vector &center, const enum HydrogenSaturation _saturation = DoSaturate);
    192190  Vector * DetermineCenterOfGravity() const;
    193191  Vector * DetermineCenterOfAll() const;
    … …  
    212210
    213211  /// Fragment molecule by two different approaches:
    214   int FragmentMolecule(int Order, std::string &prefix, DepthFirstSearchAnalysis &DFS);
    215   bool CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, std::string path = "");
    216212  bool StoreBondsToFile(std::string filename, std::string path = "");
    217213  bool StoreAdjacencyToFile(std::string filename, std::string path = "");
    218   bool ParseOrderAtSiteFromFile(std::string &path);
    219   bool StoreOrderAtSiteFile(std::string &path);
    220   bool StoreForcesFile(MoleculeListClass *BondFragments, std::string &path, int *SortIndex);
    221   bool CreateMappingLabelsToConfigSequence(int *&SortIndex);
    222214  bool CreateFatherLookupTable(atom **&LookupTable, int count = 0);
    223 
    224   /// -# BOSSANOVA
    225   void FragmentBOSSANOVA(Graph *&FragmentList, KeyStack &RootStack);
    226   int PowerSetGenerator(int Order, struct UniqueFragments &FragmentSearch, KeySet RestrictedKeySet);
    227   molecule * StoreFragmentFromKeySet(KeySet &Leaflet, bool IsAngstroem);
    228   void SPFragmentGenerator(struct UniqueFragments *FragmentSearch, int RootDistance, std::vector<bond *> &BondsSet, int SetDimension, int SubOrder);
    229   int LookForRemovalCandidate(KeySet *&Leaf, int *&ShortestPathList);
    230   int GuesstimateFragmentCount(int order);
    231215
    232216  // Recognize doubly appearing molecules in a list of them
    … …  
    253237void DeleteMolecule(molecule* mol);
    254238
    255 /** A list of \a molecule classes.
    256  */
    257 class MoleculeListClass : public Observable
    258 {
    259 public:
    260   MoleculeList ListOfMolecules; //!< List of the contained molecules
    261   int MaxIndex;
    262 
    263   MoleculeListClass(World *world);
    264   ~MoleculeListClass();
    265 
    266   bool AddHydrogenCorrection(std::string &path);
    267   bool StoreForcesFile(std::string &path, int *SortIndex);
    268   void insert(molecule *mol);
    269   void erase(molecule *mol);
    270   molecule * ReturnIndex(int index);
    271   bool OutputConfigForListOfFragments(std::string &prefix, int *SortIndex);
    272   int NumberOfActiveMolecules();
    273   void Enumerate(ostream *out);
    274   void Output(ofstream *out);
    275   int CountAllAtoms() const;
    276 
    277   // Methods moved here from the menus
    278   // TODO: more refactoring needed on these methods
    279   void createNewMolecule(periodentafel *periode);
    280   void loadFromXYZ(periodentafel *periode);
    281   void setMoleculeFilename();
    282   void parseXYZIntoMolecule();
    283   void eraseMolecule();
    284 
    285 private:
    286   World *world; //!< The world this List belongs to. Needed to avoid deadlocks in the destructor
    287 };
    288 
    289 /** A leaf for a tree of \a molecule class
    290  * Wraps molecules in a tree structure
    291  */
    292 class MoleculeLeafClass
    293 {
    294 public:
    295   molecule *Leaf; //!< molecule of this leaf
    296   //MoleculeLeafClass *UpLeaf;        //!< Leaf one level up
    297   //MoleculeLeafClass *DownLeaf;      //!< First leaf one level down
    298   MoleculeLeafClass *previous; //!< Previous leaf on this level
    299   MoleculeLeafClass *next; //!< Next leaf on this level
    300 
    301   //MoleculeLeafClass(MoleculeLeafClass *Up, MoleculeLeafClass *Previous);
    302   MoleculeLeafClass(MoleculeLeafClass *PreviousLeaf);
    303   ~MoleculeLeafClass();
    304 
    305   bool AddLeaf(molecule *ptr, MoleculeLeafClass *Previous);
    306   bool FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter);
    307   bool AssignKeySetsToFragment(molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList = false);
    308   void TranslateIndicesToGlobalIDs(Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets, Graph &TotalGraph);
    309   int Count() const;
    310 };
     239
    311240
    312241#endif /*MOLECULES_HPP_*/

  • src/molecule_geometry.cpp

    r5837dd r7ba268  
    363363/** Determines center of molecule (yet not considering atom masses).
    364364 * \param center reference to return vector
    365  */
    366 void molecule::DeterminePeriodicCenter(Vector &center)
     365 * \param saturation whether to treat hydrogen special or not
     366 */
     367void molecule::DeterminePeriodicCenter(Vector &center, const enum HydrogenSaturation saturation)
    367368{
    368369  const RealSpaceMatrix &matrix = World::getInstance().getDomain().getM();
    … …  
    378379    flag = true;
    379380    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    380 #ifdef ADDHYDROGEN
    381       if ((*iter)->getType()->getAtomicNumber() != 1) {
    382 #endif
     381      if ((saturation == DontSaturate) || ((*iter)->getType()->getAtomicNumber() != 1)) {
    383382        Testvector = inversematrix * (*iter)->getPosition();
    384383        Translationvector.Zero();
    … …  
    406405        Center += Testvector;
    407406        Log() << Verbose(1) << "vector is: " << Testvector << endl;
    408 #ifdef ADDHYDROGEN
    409         // now also change all hydrogens
    410         for (BondList::const_iterator Runner = ListOfBonds.begin();
    411             Runner != ListOfBonds.end();
    412             ++Runner) {
    413           if ((*Runner)->GetOtherAtom((*iter))->getType()->getAtomicNumber() == 1) {
    414             Testvector = inversematrix * (*Runner)->GetOtherAtom((*iter))->getPosition();
    415             Testvector += Translationvector;
    416             Testvector *= matrix;
    417             Center += Testvector;
    418             Log() << Verbose(1) << "Hydrogen vector is: " << Testvector << endl;
     407        if (saturation == DoSaturate) {
     408          // now also change all hydrogens
     409          for (BondList::const_iterator Runner = ListOfBonds.begin();
     410              Runner != ListOfBonds.end();
     411              ++Runner) {
     412            if ((*Runner)->GetOtherAtom((*iter))->getType()->getAtomicNumber() == 1) {
     413              Testvector = inversematrix * (*Runner)->GetOtherAtom((*iter))->getPosition();
     414              Testvector += Translationvector;
     415              Testvector *= matrix;
     416              Center += Testvector;
     417              Log() << Verbose(1) << "Hydrogen vector is: " << Testvector << endl;
     418            }
    419419          }
    420420        }
    421421      }
    422 #endif
    423422    }
    424423  } while (!flag);

  • src/molecule_graph.cpp

    r5837dd r7ba268  
    3434#include "Graph/BondGraph.hpp"
    3535#include "Helpers/defs.hpp"
     36#include "Helpers/helpers.hpp"
    3637#include "LinearAlgebra/RealSpaceMatrix.hpp"
    3738#include "linkedcell.hpp"
    … …  
    227228}
    228229
     230
     231/** Creates a lookup table for true father's Atom::Nr -> atom ptr.
     232 * \param *start begin of list (STL iterator, i.e. first item)
     233 * \paran *end end of list (STL iterator, i.e. one past last item)
     234 * \param **Lookuptable pointer to return allocated lookup table (should be NULL on start)
     235 * \param count optional predetermined size for table (otherwise we set the count to highest true father id)
     236 * \return true - success, false - failure
     237 */
     238bool molecule::CreateFatherLookupTable(atom **&LookupTable, int count)
     239{
     240  bool status = true;
     241  int AtomNo;
     242
     243  if (LookupTable != NULL) {
     244    Log() << Verbose(0) << "Pointer for Lookup table is not NULL! Aborting ..." <<endl;
     245    return false;
     246  }
     247
     248  // count them
     249  if (count == 0) {
     250    for (molecule::iterator iter = begin(); iter != end(); ++iter) { // create a lookup table (Atom::Nr -> atom) used as a marker table lateron
     251      count = (count < (*iter)->GetTrueFather()->getNr()) ? (*iter)->GetTrueFather()->getNr() : count;
     252    }
     253  }
     254  if (count <= 0) {
     255    Log() << Verbose(0) << "Count of lookup list is 0 or less." << endl;
     256    return false;
     257  }
     258
     259  // allocate and fill
     260  LookupTable = new atom *[count];
     261  if (LookupTable == NULL) {
     262    eLog() << Verbose(0) << "LookupTable memory allocation failed!" << endl;
     263    performCriticalExit();
     264    status = false;
     265  } else {
     266    for (int i=0;i<count;i++)
     267      LookupTable[i] = NULL;
     268    for (molecule::iterator iter = begin(); iter != end(); ++iter) {
     269      AtomNo = (*iter)->GetTrueFather()->getNr();
     270      if ((AtomNo >= 0) && (AtomNo < count)) {
     271        //*out << "Setting LookupTable[" << AtomNo << "] to " << *(*iter) << endl;
     272        LookupTable[AtomNo] = (*iter);
     273      } else {
     274        Log() << Verbose(0) << "Walker " << *(*iter) << " exceeded range of nuclear ids [0, " << count << ")." << endl;
     275        status = false;
     276        break;
     277      }
     278    }
     279  }
     280
     281  return status;
     282};
     283
     284
     285
     286/** Corrects the nuclei position if the fragment was created over the cell borders.
     287 * Scans all bonds, checks the distance, if greater than typical, we have a candidate for the correction.
     288 * We remove the bond whereafter the graph probably separates. Then, we translate the one component periodically
     289 * and re-add the bond. Looping on the distance check.
     290 * \param *out ofstream for debugging messages
     291 */
     292bool molecule::ScanForPeriodicCorrection()
     293{
     294  bond *Binder = NULL;
     295  //bond *OtherBinder = NULL;
     296  atom *Walker = NULL;
     297  atom *OtherWalker = NULL;
     298  RealSpaceMatrix matrix = World::getInstance().getDomain().getM();
     299  enum GraphEdge::Shading *ColorList = NULL;
     300  double tmp;
     301  //bool LastBond = true; // only needed to due list construct
     302  Vector Translationvector;
     303  //std::deque<atom *> *CompStack = NULL;
     304  std::deque<atom *> *AtomStack = new std::deque<atom *>; // (getAtomCount());
     305  bool flag = true;
     306  BondGraph *BG = World::getInstance().getBondGraph();
     307
     308  DoLog(2) && (Log() << Verbose(2) << "Begin of ScanForPeriodicCorrection." << endl);
     309
     310  ColorList = new enum GraphEdge::Shading[getAtomCount()];
     311  for (int i=0;i<getAtomCount();i++)
     312    ColorList[i] = (enum GraphEdge::Shading)0;
     313  if (flag) {
     314    // remove bonds that are beyond bonddistance
     315    Translationvector.Zero();
     316    // scan all bonds
     317    flag = false;
     318    for(molecule::iterator AtomRunner = begin(); (!flag) && (AtomRunner != end()); ++AtomRunner) {
     319      const BondList& ListOfBonds = (*AtomRunner)->getListOfBonds();
     320      for(BondList::const_iterator BondRunner = ListOfBonds.begin();
     321          (!flag) && (BondRunner != ListOfBonds.end());
     322          ++BondRunner) {
     323        Binder = (*BondRunner);
     324        for (int i=NDIM;i--;) {
     325          tmp = fabs(Binder->leftatom->at(i) - Binder->rightatom->at(i));
     326          //Log() << Verbose(3) << "Checking " << i << "th distance of " << *Binder->leftatom << " to " << *Binder->rightatom << ": " << tmp << "." << endl;
     327          const range<double> MinMaxDistance(
     328              BG->getMinMaxDistance(Binder->leftatom, Binder->rightatom));
     329          if (!MinMaxDistance.isInRange(tmp)) {
     330            DoLog(2) && (Log() << Verbose(2) << "Correcting at bond " << *Binder << "." << endl);
     331            flag = true;
     332            break;
     333          }
     334        }
     335      }
     336    }
     337    //if (flag) {
     338    if (0) {
     339      // create translation vector from their periodically modified distance
     340      for (int i=NDIM;i--;) {
     341        tmp = Binder->leftatom->at(i) - Binder->rightatom->at(i);
     342        const range<double> MinMaxDistance(
     343            BG->getMinMaxDistance(Binder->leftatom, Binder->rightatom));
     344        if (fabs(tmp) > MinMaxDistance.last)  // check against Min is not useful for components
     345          Translationvector[i] = (tmp < 0) ? +1. : -1.;
     346      }
     347      Translationvector *= matrix;
     348      //Log() << Verbose(3) << "Translation vector is ";
     349      Log() << Verbose(0) << Translationvector <<  endl;
     350      // apply to all atoms of first component via BFS
     351      for (int i=getAtomCount();i--;)
     352        ColorList[i] = GraphEdge::white;
     353      AtomStack->push_front(Binder->leftatom);
     354      while (!AtomStack->empty()) {
     355        Walker = AtomStack->front();
     356        AtomStack->pop_front();
     357        //Log() << Verbose (3) << "Current Walker is: " << *Walker << "." << endl;
     358        ColorList[Walker->getNr()] = GraphEdge::black;    // mark as explored
     359        *Walker += Translationvector; // translate
     360        const BondList& ListOfBonds = Walker->getListOfBonds();
     361        for (BondList::const_iterator Runner = ListOfBonds.begin();
     362            Runner != ListOfBonds.end();
     363            ++Runner) {
     364          if ((*Runner) != Binder) {
     365            OtherWalker = (*Runner)->GetOtherAtom(Walker);
     366            if (ColorList[OtherWalker->getNr()] == GraphEdge::white) {
     367              AtomStack->push_front(OtherWalker); // push if yet unexplored
     368            }
     369          }
     370        }
     371      }
     372//      // re-add bond
     373//      if (OtherBinder == NULL) { // is the only bond?
     374//        //Do nothing
     375//      } else {
     376//        if (!LastBond) {
     377//          link(Binder, OtherBinder); // no more implemented bond::previous ...
     378//        } else {
     379//          link(OtherBinder, Binder); // no more implemented bond::previous ...
     380//        }
     381//      }
     382    } else {
     383      DoLog(3) && (Log() << Verbose(3) << "No corrections for this fragment." << endl);
     384    }
     385    //delete(CompStack);
     386  }
     387  // free allocated space from ReturnFullMatrixforSymmetric()
     388  delete(AtomStack);
     389  delete[](ColorList);
     390  DoLog(2) && (Log() << Verbose(2) << "End of ScanForPeriodicCorrection." << endl);
     391
     392  return flag;
     393};

  • src/moleculelist.cpp

    r5837dd r7ba268  
    1919#include "CodePatterns/MemDebug.hpp"
    2020
    21 #include <cstring>
    22 
    23 #include <gsl/gsl_inline.h>
     21#include <iostream>
     22
     23//#include <gsl/gsl_inline.h>
    2424#include <gsl/gsl_heapsort.h>
     25
     26#include "MoleculeListClass.hpp"
     27
     28#include "CodePatterns/Log.hpp"
    2529
    2630#include "atom.hpp"
    2731#include "Bond/bond.hpp"
    28 #include "Tesselation/boundary.hpp"
    2932#include "Box.hpp"
    30 #include "CodePatterns/Assert.hpp"
    31 #include "CodePatterns/Log.hpp"
    32 #include "CodePatterns/Verbose.hpp"
    3333#include "config.hpp"
    3434#include "Element/element.hpp"
     35#include "Element/periodentafel.hpp"
     36#include "Fragmentation/Graph.hpp"
     37#include "Fragmentation/KeySet.hpp"
    3538#include "Graph/BondGraph.hpp"
    3639#include "Helpers/helpers.hpp"
     40#include "molecule.hpp"
    3741#include "LinearAlgebra/RealSpaceMatrix.hpp"
    38 #include "linkedcell.hpp"
    39 #include "molecule.hpp"
    40 #include "Parser/MpqcParser.hpp"
    4142#include "Parser/FormatParserStorage.hpp"
    42 #include "Element/periodentafel.hpp"
    43 #include "Tesselation/tesselation.hpp"
    4443#include "World.hpp"
    45 #include "WorldTime.hpp"
    46 
    47 /*********************************** Functions for class MoleculeListClass *************************/
     44
    4845
    4946/** Constructor for MoleculeListClass.
    … …  
    185182 * \param *out output stream
    186183 */
    187 void MoleculeListClass::Enumerate(ostream *out)
     184void MoleculeListClass::Enumerate(std::ostream *out)
    188185{
    189186  periodentafel *periode = World::getInstance().getPeriode();
    … …  
    239236 * \param *out output stream
    240237 */
    241 void MoleculeListClass::Output(ofstream *out)
     238void MoleculeListClass::Output(std::ostream *out)
    242239{
    243240  DoLog(1) && (Log() << Verbose(1) << "MoleculeList: ");
    … …  
    517514 * \param &prefix path and prefix to the fragment config files
    518515 * \param *SortIndex Index to map from the BFS labeling to the sequence how of Ion_Type in the config
     516 * \param type desired type to store
    519517 * \return true - success (each file was written), false - something went wrong.
    520518 */
    521 bool MoleculeListClass::OutputConfigForListOfFragments(std::string &prefix, int *SortIndex)
     519bool MoleculeListClass::OutputConfigForListOfFragments(std::string &prefix, int *SortIndex, ParserTypes type)
    522520{
    523521  ofstream outputFragment;
    524522  std::string FragmentName;
    525   char PathBackup[MAXSTRINGSIZE];
    526523  bool result = true;
    527524  bool intermediateResult = true;
    528525  Vector BoxDimension;
    529526  char *FragmentNumber = NULL;
    530   char *path = NULL;
    531527  int FragmentCounter = 0;
    532528  ofstream output;
    … …  
    537533  // store the fragments as config and as xyz
    538534  for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
    539     // save default path as it is changed for each fragment
    540     path = World::getInstance().getConfig()->GetDefaultPath();
    541     if (path != NULL)
    542       strcpy(PathBackup, path);
    543     else {
    544       ELOG(0, "OutputConfigForListOfFragments: NULL default path obtained from config!");
    545       performCriticalExit();
    546     }
    547 
    548535    // correct periodic
    549536    if ((*ListRunner)->ScanForPeriodicCorrection()) {
    … …  
    562549
    563550    {
    564       // output xyz file
     551      // center on edge
     552      (*ListRunner)->CenterEdge(&BoxDimension);
     553      for (int k = 0; k < NDIM; k++)  // if one edge is to small, set at least to 1 angstroem
     554        if (BoxDimension[k] < 1.)
     555          BoxDimension[k] += 1.;
     556      (*ListRunner)->SetBoxDimension(&BoxDimension); // update Box of atoms by boundary
     557      for (int k = 0; k < NDIM; k++) {
     558        BoxDimension[k] = 2.5 * (World::getInstance().getConfig()->GetIsAngstroem() ? 1. : 1. / AtomicLengthToAngstroem);
     559        cell_size.at(k,k) = BoxDimension[k] * 2.;
     560      }
     561      World::getInstance().setDomain(cell_size);
     562      (*ListRunner)->Translate(&BoxDimension);
     563
     564      // output file
     565      std::vector<atom *> atoms;
     566      for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
     567        atoms.push_back(*iter);
     568      }
    565569      FragmentNumber = FixedDigitNumber(ListOfMolecules.size(), FragmentCounter++);
    566       FragmentName = prefix + FragmentNumber + ".conf.xyz";
     570      FragmentName = prefix + FragmentNumber + "." + FormatParserStorage::getInstance().getSuffixFromType(type);
    567571      outputFragment.open(FragmentName.c_str(), ios::out);
    568572      std::stringstream output;
    569573      output << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter - 1 << " as XYZ ... ";
    570       if ((intermediateResult = (*ListRunner)->OutputXYZ(&outputFragment)))
     574      if ((intermediateResult = FormatParserStorage::getInstance().save(
     575          outputFragment,
     576          FormatParserStorage::getInstance().getSuffixFromType(type),
     577          atoms)))
    571578        output << " done.";
    572579      else
    573580        output << " failed.";
    574581      LOG(3, output.str());
     582      delete[](FragmentNumber);
     583
    575584      result = result && intermediateResult;
    576585      outputFragment.close();
    577586      outputFragment.clear();
    578587    }
    579 
    580     // center on edge
    581     (*ListRunner)->CenterEdge(&BoxDimension);
    582     for (int k = 0; k < NDIM; k++)  // if one edge is to small, set at least to 1 angstroem
    583       if (BoxDimension[k] < 1.)
    584         BoxDimension[k] += 1.;
    585     (*ListRunner)->SetBoxDimension(&BoxDimension); // update Box of atoms by boundary
    586     for (int k = 0; k < NDIM; k++) {
    587       BoxDimension[k] = 2.5 * (World::getInstance().getConfig()->GetIsAngstroem() ? 1. : 1. / AtomicLengthToAngstroem);
    588       cell_size.at(k,k) = BoxDimension[k] * 2.;
    589     }
    590     World::getInstance().setDomain(cell_size);
    591     (*ListRunner)->Translate(&BoxDimension);
    592 
    593     // change path in config
    594     FragmentName = PathBackup;
    595     FragmentName += "/";
    596     FragmentName += FRAGMENTPREFIX;
    597     FragmentName += FragmentNumber;
    598     FragmentName += "/";
    599     World::getInstance().getConfig()->SetDefaultPath(FragmentName.c_str());
    600 
    601     {
    602       // and save as config
    603       FragmentName = prefix + FragmentNumber + ".conf";
    604       std::stringstream output;
    605       output << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter - 1 << " as config ... ";
    606       if ((intermediateResult = World::getInstance().getConfig()->Save(FragmentName.c_str(), (*ListRunner)->elemente, (*ListRunner))))
    607         output << " done.";
    608       else
    609         output << " failed.";
    610       LOG(3, output.str());
    611       result = result && intermediateResult;
    612     }
    613 
    614     // restore old config
    615     World::getInstance().getConfig()->SetDefaultPath(PathBackup);
    616 
    617     {
    618       // and save as mpqc input file
    619       stringstream output;
    620       FragmentName = prefix + FragmentNumber + ".conf.in";
    621       output << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter - 1 << " as mpqc input ... ";
    622       std::ofstream outfile(FragmentName.c_str());
    623       std::vector<atom *> atoms;
    624       for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter)
    625         atoms.push_back(*iter);
    626 //      atoms.resize((*ListRunner)->getAtomCount());
    627 //      std::copy((*ListRunner)->begin(), (*ListRunner)->end(), atoms.begin());
    628       FormatParserStorage::getInstance().get(mpqc).save(&outfile, atoms);
    629 //      if ((intermediateResult = World::getInstance().getConfig()->SaveMPQC(FragmentName.c_str(), (*ListRunner))))
    630         output << " done.";
    631 //      else
    632 //        output << " failed.";
    633       LOG(3, output.str());
    634     }
    635 
    636     result = result && intermediateResult;
    637     //outputFragment.close();
    638     //outputFragment.clear();
    639     delete[](FragmentNumber);
    640588  }
    641589  LOG(0, "STATUS: done.");
    … …  
    753701    }
    754702};
    755 
    756 
    757 /******************************************* Class MoleculeLeafClass ************************************************/
    758 
    759 /** Constructor for MoleculeLeafClass root leaf.
    760  * \param *Up Leaf on upper level
    761  * \param *PreviousLeaf NULL - We are the first leaf on this level, otherwise points to previous in list
    762  */
    763 //MoleculeLeafClass::MoleculeLeafClass(MoleculeLeafClass *Up = NULL, MoleculeLeafClass *Previous = NULL)
    764 MoleculeLeafClass::MoleculeLeafClass(MoleculeLeafClass *PreviousLeaf = NULL) :
    765   Leaf(NULL),
    766   previous(PreviousLeaf)
    767 {
    768   //  if (Up != NULL)
    769   //    if (Up->DownLeaf == NULL) // are we the first down leaf for the upper leaf?
    770   //      Up->DownLeaf = this;
    771   //  UpLeaf = Up;
    772   //  DownLeaf = NULL;
    773   if (previous != NULL) {
    774     MoleculeLeafClass *Walker = previous->next;
    775     previous->next = this;
    776     next = Walker;
    777   } else {
    778     next = NULL;
    779   }
    780 };
    781 
    782 /** Destructor for MoleculeLeafClass.
    783  */
    784 MoleculeLeafClass::~MoleculeLeafClass()
    785 {
    786   //  if (DownLeaf != NULL) {// drop leaves further down
    787   //    MoleculeLeafClass *Walker = DownLeaf;
    788   //    MoleculeLeafClass *Next;
    789   //    do {
    790   //      Next = Walker->NextLeaf;
    791   //      delete(Walker);
    792   //      Walker = Next;
    793   //    } while (Walker != NULL);
    794   //    // Last Walker sets DownLeaf automatically to NULL
    795   //  }
    796   // remove the leaf itself
    797   if (Leaf != NULL) {
    798     Leaf->removeAtomsinMolecule();
    799     World::getInstance().destroyMolecule(Leaf);
    800     Leaf = NULL;
    801   }
    802   // remove this Leaf from level list
    803   if (previous != NULL)
    804     previous->next = next;
    805   //  } else { // we are first in list (connects to UpLeaf->DownLeaf)
    806   //    if ((NextLeaf != NULL) && (NextLeaf->UpLeaf == NULL))
    807   //      NextLeaf->UpLeaf = UpLeaf;  // either null as we are top level or the upleaf of the first node
    808   //    if (UpLeaf != NULL)
    809   //      UpLeaf->DownLeaf = NextLeaf;  // either null as we are only leaf or NextLeaf if we are just the first
    810   //  }
    811   //  UpLeaf = NULL;
    812   if (next != NULL) // are we last in list
    813     next->previous = previous;
    814   next = NULL;
    815   previous = NULL;
    816 };
    817 
    818 /** Adds \a molecule leaf to the tree.
    819  * \param *ptr ptr to molecule to be added
    820  * \param *Previous previous MoleculeLeafClass referencing level and which on the level
    821  * \return true - success, false - something went wrong
    822  */
    823 bool MoleculeLeafClass::AddLeaf(molecule *ptr, MoleculeLeafClass *Previous)
    824 {
    825   return false;
    826 };
    827 
    828 /** Fills the root stack for sites to be used as root in fragmentation depending on order or adaptivity criteria
    829  * Again, as in \sa FillBondStructureFromReference steps recursively through each Leaf in this chain list of molecule's.
    830  * \param *out output stream for debugging
    831  * \param *&RootStack stack to be filled
    832  * \param *AtomMask defines true/false per global Atom::Nr to mask in/out each nuclear site
    833  * \param &FragmentCounter counts through the fragments in this MoleculeLeafClass
    834  * \return true - stack is non-empty, fragmentation necessary, false - stack is empty, no more sites to update
    835  */
    836 bool MoleculeLeafClass::FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter)
    837 {
    838   atom *Father = NULL;
    839 
    840   if (RootStack != NULL) {
    841     // find first root candidates
    842     if (&(RootStack[FragmentCounter]) != NULL) {
    843       RootStack[FragmentCounter].clear();
    844       for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
    845         Father = (*iter)->GetTrueFather();
    846         if (AtomMask[Father->getNr()]) // apply mask
    847 #ifdef ADDHYDROGEN
    848           if ((*iter)->getType()->getAtomicNumber() != 1) // skip hydrogen
    849 #endif
    850           RootStack[FragmentCounter].push_front((*iter)->getNr());
    851       }
    852       if (next != NULL)
    853         next->FillRootStackForSubgraphs(RootStack, AtomMask, ++FragmentCounter);
    854     } else {
    855       DoLog(1) && (Log() << Verbose(1) << "Rootstack[" << FragmentCounter << "] is NULL." << endl);
    856       return false;
    857     }
    858     FragmentCounter--;
    859     return true;
    860   } else {
    861     DoLog(1) && (Log() << Verbose(1) << "Rootstack is NULL." << endl);
    862     return false;
    863   }
    864 };
    865 
    866 /** The indices per keyset are compared to the respective father's Atom::Nr in each subgraph and thus put into \a **&FragmentList.
    867  * \param *out output stream fro debugging
    868  * \param *reference reference molecule with the bond structure to be copied
    869  * \param *KeySetList list with all keysets
    870  * \param ***ListOfLocalAtoms Lookup table for each subgraph and index of each atom in global molecule, may be NULL on start, then it is filled
    871  * \param **&FragmentList list to be allocated and returned
    872  * \param &FragmentCounter counts the fragments as we move along the list
    873  * \param FreeList true - ***ListOfLocalAtoms is free'd before return, false - it is not
    874  * \retuen true - success, false - failure
    875  */
    876 bool MoleculeLeafClass::AssignKeySetsToFragment(molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList)
    877 {
    878   bool status = true;
    879   int KeySetCounter = 0;
    880 
    881   DoLog(1) && (Log() << Verbose(1) << "Begin of AssignKeySetsToFragment." << endl);
    882   // fill ListOfLocalAtoms if NULL was given
    883   if (!Leaf->FillListOfLocalAtoms(ListOfLocalAtoms[FragmentCounter], reference->getAtomCount())) {
    884     DoLog(1) && (Log() << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl);
    885     return false;
    886   }
    887 
    888   // allocate fragment list
    889   if (FragmentList == NULL) {
    890     KeySetCounter = Count();
    891     FragmentList = new Graph*[KeySetCounter];
    892     for (int i=0;i<KeySetCounter;i++)
    893       FragmentList[i] = NULL;
    894     KeySetCounter = 0;
    895   }
    896 
    897   if ((KeySetList != NULL) && (KeySetList->size() != 0)) { // if there are some scanned keysets at all
    898     // assign scanned keysets
    899     if (FragmentList[FragmentCounter] == NULL)
    900       FragmentList[FragmentCounter] = new Graph;
    901     KeySet *TempSet = new KeySet;
    902     for (Graph::iterator runner = KeySetList->begin(); runner != KeySetList->end(); runner++) { // key sets contain global numbers!
    903       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
    904         // translate keyset to local numbers
    905         for (KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
    906           TempSet->insert(ListOfLocalAtoms[FragmentCounter][reference->FindAtom(*sprinter)->getNr()]->getNr());
    907         // insert into FragmentList
    908         FragmentList[FragmentCounter]->insert(GraphPair(*TempSet, pair<int, double> (KeySetCounter++, (*runner).second.second)));
    909       }
    910       TempSet->clear();
    911     }
    912     delete (TempSet);
    913     if (KeySetCounter == 0) {// if there are no keysets, delete the list
    914       DoLog(1) && (Log() << Verbose(1) << "KeySetCounter is zero, deleting FragmentList." << endl);
    915       delete (FragmentList[FragmentCounter]);
    916     } else
    917       DoLog(1) && (Log() << Verbose(1) << KeySetCounter << " keysets were assigned to subgraph " << FragmentCounter << "." << endl);
    918     FragmentCounter++;
    919     if (next != NULL)
    920       next->AssignKeySetsToFragment(reference, KeySetList, ListOfLocalAtoms, FragmentList, FragmentCounter, FreeList);
    921     FragmentCounter--;
    922   } else
    923     DoLog(1) && (Log() << Verbose(1) << "KeySetList is NULL or empty." << endl);
    924 
    925   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
    926     // free the index lookup list
    927     delete[](ListOfLocalAtoms[FragmentCounter]);
    928   }
    929   DoLog(1) && (Log() << Verbose(1) << "End of AssignKeySetsToFragment." << endl);
    930   return status;
    931 };
    932 
    933 /** Translate list into global numbers (i.e. ones that are valid in "this" molecule, not in MolecularWalker->Leaf)
    934  * \param *out output stream for debugging
    935  * \param **FragmentList Graph with local numbers per fragment
    936  * \param &FragmentCounter counts the fragments as we move along the list
    937  * \param &TotalNumberOfKeySets global key set counter
    938  * \param &TotalGraph Graph to be filled with global numbers
    939  */
    940 void MoleculeLeafClass::TranslateIndicesToGlobalIDs(Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets, Graph &TotalGraph)
    941 {
    942   DoLog(1) && (Log() << Verbose(1) << "Begin of TranslateIndicesToGlobalIDs." << endl);
    943   KeySet *TempSet = new KeySet;
    944   if (FragmentList[FragmentCounter] != NULL) {
    945     for (Graph::iterator runner = FragmentList[FragmentCounter]->begin(); runner != FragmentList[FragmentCounter]->end(); runner++) {
    946       for (KeySet::iterator sprinter = (*runner).first.begin(); sprinter != (*runner).first.end(); sprinter++)
    947         TempSet->insert((Leaf->FindAtom(*sprinter))->GetTrueFather()->getNr());
    948       TotalGraph.insert(GraphPair(*TempSet, pair<int, double> (TotalNumberOfKeySets++, (*runner).second.second)));
    949       TempSet->clear();
    950     }
    951     delete (TempSet);
    952   } else {
    953     DoLog(1) && (Log() << Verbose(1) << "FragmentList is NULL." << endl);
    954   }
    955   if (next != NULL)
    956     next->TranslateIndicesToGlobalIDs(FragmentList, ++FragmentCounter, TotalNumberOfKeySets, TotalGraph);
    957   FragmentCounter--;
    958   DoLog(1) && (Log() << Verbose(1) << "End of TranslateIndicesToGlobalIDs." << endl);
    959 };
    960 
    961 /** Simply counts the number of items in the list, from given MoleculeLeafClass.
    962  * \return number of items
    963  */
    964 int MoleculeLeafClass::Count() const
    965 {
    966   if (next != NULL)
    967     return next->Count() + 1;
    968   else
    969     return 1;
    970 };
    971 

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz" --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 1 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 2 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 3 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 4 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 5 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    1414AT_CHECK([chmod u+w $file], 0)
    1515
    16 AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE], 0, [stdout], [stderr])
    17 AT_CHECK([ls ${FRAGMENTPREFIX}*.conf | wc -l], 0, [stdout], [stderr])
    18 AT_CHECK([grep $FragNo stdout], 0, [stdout], [stderr])
     16AT_CHECK([../../molecuilder -i $file -I --select-molecule-by-id 0 -f $FILENAME --order 6 --distance $DISTANCE  --output-types "mpqc pcp xyz"], 0, [stdout], [stderr])
     17AT_CHECK([ls ${FILENAME}*.conf | wc -l | grep $FragNo], 0, [ignore], [ignore])
     18AT_CHECK([ls ${FILENAME}*.xyz | wc -l | grep $FragNo], 0, [ignore], [ignore])
     19AT_CHECK([ls ${FILENAME}*.in | wc -l | grep $FragNo], 0, [ignore], [ignore])
    1920
    2021AT_CLEANUP

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

    r5837dd r7ba268  
    88AT_CHECK([/bin/cp -f ${abs_top_srcdir}/tests/regression/Fragmentation/FragmentMolecule-MaxOrder/pre/test.conf $file], 0)
    99AT_CHECK([chmod u+w $file], 0, [ignore], [ignore])
    10 AT_CHECK([../../molecuilder -i $file  -v 1 --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2], 0, [ignore], [ignore])
    11 AT_CHECK([../../molecuilder -i $file  -v 1 --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2], 2, [ignore], [ignore])
     10AT_CHECK([../../molecuilder -i $file  -v 1 --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2 --output-types "pcp"], 0, [ignore], [ignore])
     11AT_CHECK([../../molecuilder -i $file  -v 1 --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2 --output-types "pcp"], 2, [ignore], [ignore])
    1212
    1313AT_CLEANUP

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

    r5837dd r7ba268  
    77AT_CHECK([/bin/cp -f ${abs_top_srcdir}/tests/regression/Fragmentation/FragmentMolecule/pre/test.conf $file], 0)
    88AT_CHECK([chmod u+w $file], 0, [ignore], [ignore])
    9 AT_CHECK([../../molecuilder -i $file  -v 1 -I --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2], 0, [ignore], [ignore])
     9AT_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])
    1010#AT_CHECK([diff BondFragment0.conf ${abs_top_srcdir}/tests/regression/Fragmentation/FragmentMolecule/post/BondFragment0.conf], 0, [ignore], [ignore])
    1111#AT_CHECK([diff BondFragment1.conf ${abs_top_srcdir}/tests/regression/Fragmentation/FragmentMolecule/post/BondFragment1.conf], 0, [ignore], [ignore])

  • tests/regression/Makefile.am

    r5837dd r7ba268  
    9191        $(srcdir)/Parser/Mpqc/testsuite-parser-mpqc-load.at \
    9292        $(srcdir)/Parser/Mpqc/testsuite-parser-mpqc-save.at \
    93         $(srcdir)/Parser/Mpqc-SetParameters/testsuite-parser-mpqc-set-parameters.at \
    94         $(srcdir)/Parser/Mpqc-SetParameters/testsuite-parser-mpqc-set-parameters-basis.at \
    95         $(srcdir)/Parser/Mpqc-SetParameters/testsuite-parser-mpqc-set-parameters-maxiterations.at \
    96         $(srcdir)/Parser/Mpqc-SetParameters/testsuite-parser-mpqc-set-parameters-theory.at \
    9793        $(srcdir)/Parser/Pcp/testsuite-parser-pcp-empty.at \
    9894        $(srcdir)/Parser/Pcp/testsuite-parser-pcp-load.at \
    … …  
    110106        $(srcdir)/Parser/Psi3/testsuite-parser-psi3-load.at \
    111107        $(srcdir)/Parser/Psi3/testsuite-parser-psi3-save.at \
     108        $(srcdir)/Parser/SetParameters/Mpqc/testsuite-parser-set-parameters-mpqc.at \
     109        $(srcdir)/Parser/SetParameters/Mpqc/testsuite-parser-set-parameters-mpqc-basis.at \
     110        $(srcdir)/Parser/SetParameters/Mpqc/testsuite-parser-set-parameters-mpqc-maxiterations.at \
     111        $(srcdir)/Parser/SetParameters/Mpqc/testsuite-parser-set-parameters-mpqc-theory.at \
     112        $(srcdir)/Parser/SetParameters/Psi3/testsuite-parser-set-parameters-psi3-reference.at \
     113        $(srcdir)/Parser/SetParameters/Psi3/testsuite-parser-set-parameters-psi3-wavefunction.at \
    112114        $(srcdir)/Parser/Tremolo/testsuite-parser-tremolo-empty.at \
    113115        $(srcdir)/Parser/Tremolo/testsuite-parser-tremolo-load.at \

  • tests/regression/Parser/testsuite-parser.at

    r5837dd r7ba268  
    11AT_BANNER([MoleCuilder - Parser])
    22
    3 # set MPQC basis, theory and maxiter
    4 m4_include([Parser/Mpqc-SetParameters/testsuite-parser-mpqc-set-parameters.at])
    5 m4_include([Parser/Mpqc-SetParameters/testsuite-parser-mpqc-set-parameters-basis.at])
    6 m4_include([Parser/Mpqc-SetParameters/testsuite-parser-mpqc-set-parameters-maxiterations.at])
    7 m4_include([Parser/Mpqc-SetParameters/testsuite-parser-mpqc-set-parameters-theory.at])
    83
    94# parsing mpqc
    … …  
    116m4_include([Parser/Mpqc/testsuite-parser-mpqc-load.at])
    127m4_include([Parser/Mpqc/testsuite-parser-mpqc-save.at])
     8
     9# set mpqc basis, theory and maxiter
     10m4_include([Parser/SetParameters/Mpqc/testsuite-parser-set-parameters-mpqc.at])
     11m4_include([Parser/SetParameters/Mpqc/testsuite-parser-set-parameters-mpqc-basis.at])
     12m4_include([Parser/SetParameters/Mpqc/testsuite-parser-set-parameters-mpqc-maxiterations.at])
     13m4_include([Parser/SetParameters/Mpqc/testsuite-parser-set-parameters-mpqc-theory.at])
    1314
    1415# parsing pcp
    … …  
    2425m4_include([Parser/Pdb/testsuite-parser-pdb-save.at])
    2526m4_include([Parser/Pdb/testsuite-parser-pdb-with-conects.at])
     27
     28# set psi3 wavefunction
     29m4_include([Parser/SetParameters/Psi3/testsuite-parser-set-parameters-psi3-reference.at])
     30m4_include([Parser/SetParameters/Psi3/testsuite-parser-set-parameters-psi3-wavefunction.at])
    2631
    2732# bugfix checks
Note: See TracChangeset for help on using the changeset viewer.