csg_fmatch.h

Go to the documentation of this file.

/*
 * Copyright 2009-2021 The VOTCA Development Team (http://www.votca.org)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
 
#ifndef VOTCA_CSG_CSG_FMATCH_H
#define VOTCA_CSG_CSG_FMATCH_H
 
// VOTCA includes
#include <votca/tools/cubicspline.h>
#include <votca/tools/property.h>
 
// Local VOTCA includes
#include "votca/csg/csgapplication.h"
#include "votca/csg/trajectoryreader.h"
 
using namespace votca::csg;
 
using namespace std;
 
class CGForceMatching : public CsgApplication {
 public:
  string ProgramName() override { return "csg_fmatch"; }
  void HelpText(ostream &out) override {
    out << "Perform force matching (also called multiscale coarse-graining)";
  }
 
  bool DoTrajectory() override { return true; }
  bool DoMapping() override { return true; }
 
  void Initialize(void) override;
  bool EvaluateOptions() override;
 
  void BeginEvaluate(Topology *top, Topology *top_atom) override;
  void EndEvaluate() override;
  void EvalConfiguration(Topology *conf,
                         Topology *conf_atom = nullptr) override;
  void LoadOptions(const string &file);
 
 protected:
  struct SplineInfo {
    SplineInfo(votca::Index index, bool bonded_interaction,
               votca::Index matr_pos_col, votca::tools::Property *options);
    votca::Index num_splinefun;
    votca::Index num_gridpoints;
    votca::Index num_outgrid;
    votca::Index splineIndex;
    bool bonded;
    bool periodic;
    bool threebody;
    double a;
    double sigma;
    double gamma;
    votca::tools::CubicSpline Spline;
    votca::Index matr_pos;
    double dx_out;
    pair<votca::Index, votca::Index> beadTypes;
 
    Eigen::VectorXd block_res_f;
    Eigen::VectorXd block_res_f2;
    Eigen::VectorXd result;
    Eigen::VectorXd error;
    Eigen::VectorXd resSum;
    Eigen::VectorXd resSum2;
 
    // only needed for 3body nonbonded interactions as here force and potential
    // are calculated simultaneously
    Eigen::VectorXd resultDer;
    Eigen::VectorXd errorDer;
    Eigen::VectorXd resSumDer;
    Eigen::VectorXd resSumDer2;
 
    string splineName;
    string type1, type2, type3;  //
 
    votca::tools::Property *options_;
  };
  votca::tools::Property options_;
  std::vector<votca::tools::Property *> bonded_;
  std::vector<votca::tools::Property *> nonbonded_;
 
  using SplineContainer = vector<SplineInfo>;
  SplineContainer splines_;
 
  Eigen::MatrixXd A_;
  Eigen::VectorXd b_;
  Eigen::VectorXd x_;  //
  Eigen::MatrixXd B_constr_;
 
  votca::Index frame_counter_;
  votca::Index nbeads_;
 
  double dist_;
 
  bool constr_least_sq_;
  votca::Index least_sq_offset_;
  votca::Index nframes_;
  votca::Index nblocks_;
 
  votca::Index line_cntr_, col_cntr_;
 
  bool has_existing_forces_;
 
  void FmatchAccumulateData();
  void FmatchAssignSmoothCondsToMatrix(Eigen::MatrixXd &Matrix);
  void EvalBonded(Topology *conf, SplineInfo *sinfo);
  void EvalNonbonded(Topology *conf, SplineInfo *sinfo);
  void EvalNonbonded_Threebody(Topology *conf, SplineInfo *sinfo);
  void WriteOutFiles();
 
  void OpenForcesTrajectory();
 
  Topology top_force_;
  std::unique_ptr<TrajectoryReader> trjreader_force_;
};
 
#endif  // VOTCA_CSG_CSG_FMATCH_H