local_dist_diff_test.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2011 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_MOL_ALG_LOCAL_DIST_TEST_HH
#define OST_MOL_ALG_LOCAL_DIST_TEST_HH

#include <ost/mol/alg/module_config.hh>
#include <ost/mol/entity_handle.hh>
#include <ost/seq/alignment_handle.hh>
#include <ost/mol/alg/distance_test_common.hh>
#include <ost/mol/alg/filter_clashes.hh>

namespace ost { namespace mol { namespace alg {

struct StereoChemicalProps
{
  bool is_valid;
  ost::mol::alg::StereoChemicalParams bond_table;
  ost::mol::alg::StereoChemicalParams angle_table;
  ost::mol::alg::ClashingDistances nonbonded_table;

  StereoChemicalProps();
  StereoChemicalProps(ost::mol::alg::StereoChemicalParams& init_bond_table,
                      ost::mol::alg::StereoChemicalParams& init_angle_table,
                      ost::mol::alg::ClashingDistances& init_nonbonded_table);
};

struct lDDTSettings {
  Real radius; 
  int sequence_separation;
  std::vector<Real> cutoffs;
  String label;

  lDDTSettings();
  lDDTSettings(Real init_radius, 
               int init_sequence_separation,
               std::vector<Real>& init_cutoffs,
               String init_label);
  void PrintParameters();
  std::string ToString();
};

struct lDDTLocalScore {
  String cname;
  String rname;
  int rnum;
  String is_assessed;
  String quality_problems;
  Real local_lddt;
  int conserved_dist;
  int total_dist;

  lDDTLocalScore();

  lDDTLocalScore(String init_cname,
                 String init_rname,
                 int init_rnum,
                 String init_is_assessed,
                 String init_quality_problems,
                 Real init_local_lddt,
                 int init_conserved_dist,
                 int init_total_dist);

  String ToString(bool structural_checks) const;
  String Repr() const;

  static String GetHeader(bool structural_checks, int cutoffs_length);
};

class lDDTScorer
{
  public:
    lDDTSettings settings;
    EntityView model_view;
    std::vector<EntityView> references_view;
    GlobalRDMap glob_dist_list;

    lDDTScorer(std::vector<EntityView>& init_references,
               ost::mol::EntityView& init_model,
               lDDTSettings& init_settings);
    Real GetGlobalScore();
    std::vector<lDDTLocalScore> GetLocalScores();
    int GetNumConservedContacts(); // number of conserved distances in the model
    int GetNumTotalContacts(); // the number of total distances in the reference structure
    std::vector<EntityView> GetReferences();
    void PrintPerResidueStats();
    bool IsValid();

  private:
    bool _score_calculated;
    bool _score_valid;
    bool _has_local_scores;
    // number of conserved distances in the model and
    // the number of total distances in the reference structure
    int _num_cons_con;
    int _num_tot_con;
    Real _global_score;
    std::vector<lDDTLocalScore> _local_scores;
    void _ComputelDDT();
    void _GetLocallDDT();
    void _PrepareGlobalRDMap();
};

std::pair<int,int> DLLEXPORT_OST_MOL_ALG ComputeCoverage(const EntityView& v,const GlobalRDMap& glob_dist_list);

bool DLLEXPORT_OST_MOL_ALG IsResnumInGlobalRDMap(const ResNum& resnum, const GlobalRDMap& glob_dist_list);
  
std::pair<long int,long int> DLLEXPORT_OST_MOL_ALG 
LocalDistDiffTest(const EntityView& mdl, const GlobalRDMap& dist_list,
                  std::vector<Real> cutoff_list, int sequence_separation = 0, 
                  const String& local_ldt_property_string="");

Real DLLEXPORT_OST_MOL_ALG LocalDistDiffTest(const EntityView& mdl,
                                         const EntityView& target,
                                         Real cutoff, 
                                         Real max_dist,
                                         const String& local_ldt_property_string="");
Real DLLEXPORT_OST_MOL_ALG LocalDistDiffTest(const EntityView& v,
                       std::vector<EntityView>& ref_list,
                       const GlobalRDMap& glob_dist_list,
                       lDDTSettings& settings);

Real DLLEXPORT_OST_MOL_ALG LocalDistDiffTest(const ost::seq::AlignmentHandle& aln,
                                         Real cutoff, Real max_dist,
                                         int ref_index=0, int mdl_index=1);

Real DLLEXPORT_OST_MOL_ALG LDDTHA(EntityView& v, const GlobalRDMap& global_dist_list, int sequence_separation=0);

GlobalRDMap DLLEXPORT_OST_MOL_ALG CreateDistanceList(const EntityView& ref,Real max_dist);

GlobalRDMap DLLEXPORT_OST_MOL_ALG CreateDistanceListFromMultipleReferences(const std::vector<EntityView>& ref_list,std::vector<Real>& cutoff_list, int sequence_separation, Real max_dist);

void DLLEXPORT_OST_MOL_ALG PrintGlobalRDMap(const GlobalRDMap& glob_dist_list);

void DLLEXPORT_OST_MOL_ALG PrintResidueRDMap(const ResidueRDMap& res_dist_list);

// required by some helper function. Cannot reuse similar functions in other modules without creating
// circular dependencies
bool DLLEXPORT_OST_MOL_ALG IsStandardResidue(String rn);

void DLLEXPORT_OST_MOL_ALG CleanlDDTReferences(std::vector<EntityView>& ref_list);

// Prepare GlobalRDMap from reference list
GlobalRDMap DLLEXPORT_OST_MOL_ALG PreparelDDTGlobalRDMap(
    const std::vector<EntityView>& ref_list,
    std::vector<Real>& cutoff_list,
    int sequence_separation,
    Real max_dist);

void DLLEXPORT_OST_MOL_ALG CheckStructure(EntityView& ent,
                                          StereoChemicalParams& bond_table,
                                          StereoChemicalParams& angle_table,
                                          ClashingDistances& nonbonded_table,
                                          Real bond_tolerance,
                                          Real angle_tolerance);

std::vector<lDDTLocalScore> DLLEXPORT_OST_MOL_ALG GetlDDTPerResidueStats(EntityView& model,
                                              GlobalRDMap& glob_dist_list,
                                              bool structural_checks,
                                              String label);

void DLLEXPORT_OST_MOL_ALG PrintlDDTPerResidueStats(std::vector<lDDTLocalScore>& scores,
                                                    bool structural_checks,
                                                    int cutoffs_length);

}}}

#endif