ff_reader.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2020 by the OpenStructure authors
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 3.0 of the License, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//------------------------------------------------------------------------------

#ifndef OST_MM_FORCEFIELD_READER_HH
#define OST_MM_FORCEFIELD_READER_HH

#include <fstream>

#include <boost/filesystem.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/unordered_map.hpp>

#include <ost/base.hh>
#include <ost/io/io_exception.hh>
#include <ost/mol/mm/forcefield.hh>
#include <ost/mol/mm/interaction.hh>
#include <ost/mol/mm/gromacs_block_modifiers.hh>


namespace ost { namespace mol{ namespace mm{

class GromacsData;
class CHARMMData;
class FFReader;
typedef boost::shared_ptr<GromacsData> GromacsDataPtr;
typedef boost::shared_ptr<FFReader> FFReaderPtr;
typedef boost::shared_ptr<CHARMMData> CHARMMDataPtr;

class GromacsData{
public:
  static GromacsDataPtr Instance();
  int GetKeywordIndex(const String& keyword);
  String ConvertToStandard(const String& res_name, const String& atom_name);
  bool ConversionExists(const String& res_name);

private:
  GromacsData();
  GromacsData(const GromacsData&);
  GromacsDataPtr operator=(const GromacsDataPtr&);
  static GromacsDataPtr instance_;
  boost::unordered_map<String,int> keyword_map_;
  boost::unordered_map<String, std::vector<std::pair<String,String> > > renaming_to_standard_;

};

class CHARMMData{
public:
  static CHARMMDataPtr Instance();
  int GetKeywordIndex(const String& keyword);

private:
  CHARMMData();
  CHARMMData(const CHARMMData&);
  CHARMMDataPtr operator=(const CHARMMDataPtr&);
  static CHARMMDataPtr instance_;
  boost::unordered_map<String,int> keyword_map_;
};

class MMPreprocessor{

public:

  MMPreprocessor(const String& basepath): basepath_(basepath) { }

  std::vector<std::vector<String> > Process(const String& filename);

  void SetDefinition(const String& def) { defines_.insert(def); }

  boost::filesystem::path GetBasedir() { return basepath_; }

private:

  //function, that can recursively resolve ifdef / ifndef statements
  void ResolveIFDEF(std::vector<std::vector<String> >& file_content, int line_counter);

  //simply reads a file, cuts it into pieces and removes comments marked by '*' and ';'
  std::vector<std::vector<String> > ReadFile(const String& filename);

  std::map<String,std::vector<String> > definitions_;
  std::set<String> defines_;
  boost::filesystem::path basepath_;
};


class FFReader {
public:

  FFReader(const String& base_dir);

  void SetPreprocessorDefinition(const String& def) { preprocessor_.SetDefinition(def); }

  void ReadGromacsForcefield();

  ForcefieldPtr GetForcefield() { return ff_;}

  void SetForcefield(ForcefieldPtr ff) { ff_ = ff; }

  void ReadResidueDatabase(const String& basename);

  void ReadITP(const String& basename);

  void ReadCHARMMPRM(const String& basename);

  void ReadCHARMMRTF(const String& basename);

private:

  InteractionPtr ParseBond(const std::vector<String>& data, 
                             bool type_definition, 
                             FuncType functype = Invalid);

  InteractionPtr ParseAngle(const std::vector<String>& data, 
                              bool type_definition, 
                              FuncType functype = Invalid);

  InteractionPtr ParseDihedral(const std::vector<String>& data, 
                                 bool type_definition, 
                                 FuncType functype = Invalid);

  InteractionPtr ParseCMap(const std::vector<String>& data, 
                             bool type_definition, 
                             FuncType functype = Invalid);

  InteractionPtr ParseLJ(const std::vector<String>& data, 
                           bool type_definition, 
                           FuncType functype = Invalid);

  InteractionPtr ParseLJPair(const std::vector<String>& data, 
                               bool type_definition, 
                               FuncType functype = Invalid);

  InteractionPtr ParseConstraint(const std::vector<String>& data, 
                                   bool type_definition, 
                                   FuncType functype = Invalid);

  InteractionPtr ParseGenborn(const std::vector<String>& data, 
                                bool type_definition, 
                                FuncType functype = Invalid);

  InteractionPtr ParseExclusion(const std::vector<String>& data,
                                  bool type_definition,
                                  FuncType functype = Invalid);

  BuildingBlockPtr BlockFromRTP(const std::vector<std::vector<String> >& data);

  BuildingBlockPtr BlockFromITP(const std::vector<std::vector<String> >& data);

  TerminiConstructorPtr ParseTermini(const std::vector<std::vector<String> >& data);

  BlockModifierPtr ParseBlockModifier(const std::vector<std::vector<String> >& data);

  void ParseHydrogenRule(const std::vector<String>& data, GromacsHydrogenConstructor& constructor);

  void ParseTerminiReplaceRule(const std::vector<String>& data, GromacsBlockModifier& constructor);

  void ParseTerminiAddRule(const std::vector<String>& data1, const std::vector<String>& data2,
                           GromacsBlockModifier& constructor);

  //Reader functions for the mandatory forcefield files
  void ParseForcefield(std::vector<std::vector<String> >& content);
  void ParseAtomTypes(std::vector<std::vector<String> >& content);

  //Reader functions for CHARMM stuff
  void ParseCHARMMPRM(std::vector<std::vector<String> >& content);

  void ParseCHARMMRTF(std::vector<std::vector<String> >& content);

  //Reader functions for all different residue database files
  void ParseRTP(std::vector<std::vector<String> >& content);
  void ParseARN(std::vector<std::vector<String> >& content);
  void ParseHDB(std::vector<std::vector<String> >& content);
  void ParseNTDB(std::vector<std::vector<String> >& content);
  void ParseCTDB(std::vector<std::vector<String> >& content);
  void ParseVSD(std::vector<std::vector<String> >& content);
  void ParseRtoB(std::vector<std::vector<String> >& content);
  //Reader function for single molecule itp files
  void ParseITP(std::vector<std::vector<String> >& content);

  boost::unordered_map<String, std::vector<std::pair<String,String> > > atom_renaming_ff_specific_;
  boost::unordered_map<String, ResidueNamesPtr> res_renaming_ff_specific_;

  std::vector<FuncType> ff_bonded_types_;

  MMPreprocessor preprocessor_;
  ForcefieldPtr ff_;

  //following part is ugly...
  //data that is read during the residue datababase parsing process gets stored in there
  std::vector<FuncType> bonded_types_;
  std::vector<String> read_residues_;
};


}}}//ns

#endif