doxygen/rmsd_8h_source.html

// -*-c++-*-

#ifndef STORMM_STRUCTURE_RMSD_H

#define STORMM_STRUCTURE_RMSD_H


#include "copyright.h"

#include "Analysis/comparison_guide.h"

#include "Constants/behavior.h"

#include "DataTypes/common_types.h"

#include "Math/matrix_ops.h"

#include "Math/rounding.h"

#include "Math/summation.h"

#include "Synthesis/condensate.h"

#include "Synthesis/phasespace_synthesis.h"

#include "Synthesis/synthesis_abstracts.h"

#include "Synthesis/synthesis_cache_map.h"

#include "Synthesis/synthesis_enumerators.h"

#include "Topology/atomgraph.h"

#include "Topology/atomgraph_abstracts.h"

#include "Trajectory/coordinateframe.h"

#include "Trajectory/coordinate_series.h"

#include "Trajectory/phasespace.h"

#include "rmsd_plan.h"

#include "structure_enumerators.h"


namespace stormm {

namespace structure {


using analysis::ComparisonGuide;

using constants::PrecisionModel;

using data_types::isSignedIntegralScalarType;

using stmath::EigenWork;

using stmath::jacobiEigensolver;

using stmath::realSymmEigensolver;

using stmath::roundUp;

using stmath::sum;

using topology::AtomGraph;

using topology::ChemicalDetailsKit;

using synthesis::Condensate;

using synthesis::CondensateReader;

using synthesis::PhaseSpaceSynthesis;

using synthesis::PsSynthesisReader;

using synthesis::SyNonbondedKit;

using synthesis::SynthesisCacheMap;

using synthesis::SynthesisMapReader;

using synthesis::SystemGrouping;

using trajectory::CoordinateFrame;

using trajectory::CoordinateFrameReader;

using trajectory::CoordinateFrameWriter;

using trajectory::CoordinateSeries;

using trajectory::CoordinateSeriesReader;

using trajectory::CoordinateSeriesWriter;

using trajectory::PhaseSpace;

using trajectory::PhaseSpaceReader;

using trajectory::PhaseSpaceWriter;


template <typename T>

void checkCompatibility(const ComparisonGuide &cg, const RMSDPlan &rplan,

                        const PhaseSpaceSynthesis &poly_ps, const Hybrid<T> *result,

                        RMSDTask process, SystemGrouping organization);


template <typename T>

void checkCompatibility(const ComparisonGuide &cg, const RMSDPlan &rplan,

                        const PhaseSpaceSynthesis &poly_ps, const Condensate &cdns,

                        const Hybrid<T> *result, RMSDTask process, SystemGrouping organization);


template <typename Tcoord, typename Tcalc>

Tcalc rmsd(const Tcoord* xcrd_a, const Tcoord* ycrd_a, const Tcoord* zcrd_a, const Tcoord* xcrd_b,

           const Tcoord* ycrd_b, const Tcoord* zcrd_b, const Tcalc* masses, RMSDMethod method,

           int lower_limit, int upper_limit, Tcalc inv_gpos_scale_factor = 1.0);


double rmsd(const double* xcrd_a, const double* ycrd_a, const double* zcrd_a, const double* xcrd_b,

            const double* ycrd_b, const double* zcrd_b, const double* masses, RMSDMethod method,

            int lower_limit, int upper_limit);


double rmsd(const PhaseSpaceReader &psr_a, const PhaseSpaceReader &psr_b,

            const ChemicalDetailsKit &cdk, RMSDMethod method, int lower_limit = 0,

            int upper_limit = 0);


double rmsd(const PhaseSpaceWriter &psw_a, const PhaseSpaceWriter &psw_b,

            const ChemicalDetailsKit &cdk, RMSDMethod method, int lower_limit = 0,

            int upper_limit = 0);


double rmsd(const PhaseSpace &ps_a, const PhaseSpace &ps_b, const AtomGraph &ag, RMSDMethod method,

            int lower_limit = 0, int upper_limit = 0);


double rmsd(const CoordinateFrameReader &cfr_a, const CoordinateFrameReader &cfr_b,

            const ChemicalDetailsKit &cdk, RMSDMethod method, int lower_limit = 0,

            int upper_limit = 0);


double rmsd(const CoordinateFrameWriter &cfw_a, const CoordinateFrameWriter &cfw_b,

            const ChemicalDetailsKit &cdk, RMSDMethod method, int lower_limit = 0,

            int upper_limit = 0);


double rmsd(const CoordinateFrame &cf_a, const CoordinateFrame &cf_b, const AtomGraph &ag,

            RMSDMethod method, int lower_limit = 0, int upper_limit = 0);


template <typename Tcoord, typename Tcalc>

Tcalc rmsd(const CoordinateSeriesReader<Tcoord> &csr, const size_t frame_a, const size_t frame_b,

           const ChemicalDetailsKit &cdk, const RMSDMethod method, const int lower_limit,

           const int upper_limit);


template <typename Tcoord, typename Tcalc>

Tcalc rmsd(const CoordinateSeriesWriter<Tcoord> &csw, const size_t frame_a, const size_t frame_b,

           const ChemicalDetailsKit &cdk, const RMSDMethod method, const int lower_limit,

           const int upper_limit);


template <typename Tcoord, typename Tcalc>

Tcalc rmsd(const CoordinateSeries<Tcoord> &cs, const size_t frame_a, const size_t frame_b,

           const AtomGraph &ag, const RMSDMethod method, const int lower_limit,

           const int upper_limit);


double rmsd(const RMSDPlan &rplan, const PhaseSpaceReader &reference,

            const PhaseSpaceReader &snapshot);


double rmsd(const RMSDPlan &rplan, const PhaseSpace &reference, const PhaseSpace &snapshot);


double rmsd(const RMSDPlan &rplan,

            const CoordinateFrameReader &reference, const CoordinateFrameReader &snapshot);


double rmsd(const RMSDPlan &rplan, const CoordinateFrame &reference,

            const CoordinateFrame &snapshot);


template <typename T>

std::vector<double> rmsd(const ComparisonGuide &cg, const RMSDPlan &rplan,

                         const CoordinateFrame &reference, const CoordinateSeries<T> &snapshots);


template <typename T>

std::vector<double> rmsd(const ComparisonGuide &cg, const RMSDPlan &rplan,

                         const CoordinateSeries<T> &snapshots, int reference_frame);


template <typename T>

void rmsd(const ComparisonGuide &cg, const RMSDPlan &rplan, const CoordinateFrame &reference,

          const CoordinateSeries<T> &snapshots, Hybrid<T> *result);


template <typename T>

void rmsd(const ComparisonGuide &cg, const RMSDPlan &rplan, const CoordinateSeries<T> &snapshots,

          int reference_frame, Hybrid<T> *result);


template <typename T>

void rmsd(const ComparisonGuide &cg, const RMSDPlan &rplan, const CoordinateSeries<T> &snapshots,

          Hybrid<T> *result);


template <typename T>

void rmsd(const ComparisonGuide &cg, const RMSDPlan &rplan, const PhaseSpaceSynthesis &snapshots,

          const Hybrid<int> &reference_frames, Hybrid<T> *result,

          SystemGrouping organization = SystemGrouping::TOPOLOGY);


template <typename T>

void rmsd(const ComparisonGuide &cg, const RMSDPlan &rplan, const PhaseSpaceSynthesis &snapshots,

          Hybrid<T> *result, SystemGrouping organization = SystemGrouping::TOPOLOGY);


template <typename T>

void rmsd(const ComparisonGuide &cg, const RMSDPlan &rplan, const PhaseSpaceSynthesis &snapshots,

          const Condensate &cdns, const Hybrid<int> &reference_frames, Hybrid<T> *result,

          SystemGrouping organization = SystemGrouping::TOPOLOGY);


template <typename T>

void rmsd(const ComparisonGuide &cg, const RMSDPlan &rplan, const PhaseSpaceSynthesis &snapshots,

          const Condensate &cdns, Hybrid<T> *result,

          SystemGrouping organization = SystemGrouping::TOPOLOGY);


} // namespace structure

} // namespace stormm


#include "rmsd.tpp"


#endif


stormm::card::Hybrid
An evolution of GpuBuffer in pmemd.cuda, the Composite array has elements that are accessible from ei...
Definition hybrid.h:202

stormm::structure::RMSDPlan
Collect instructions for one or more systems (intend to work with any coordinate object,...
Definition rmsd_plan.h:89

stormm::synthesis::Condensate
Condense the data format, and possibly offer a reduced representation of coordinates,...
Definition condensate.h:146

stormm::synthesis::PhaseSpaceSynthesis
A fixed-precision representation of coordinates, velocities, and forces to manage a set of simulation...
Definition phasespace_synthesis.h:325

stormm::topology::AtomGraph
A struct to hold information relating to an Amber topology. This struct's member functions are limite...
Definition atomgraph.h:50

stormm::trajectory::CoordinateFrame
Store the coordinates and box information for a frame, only. This abridged struct can serve when the ...
Definition coordinateframe.h:111

stormm::trajectory::CoordinateSeries
Store the coordinates and box information for a series of frames, in one of several levels of precisi...
Definition coordinate_series.h:137

stormm::trajectory::PhaseSpace
An object to complement a topology and hold positions, velocities, and forces of all particles in a s...
Definition phasespace.h:141

stormm::topology::ChemicalDetailsKit
Information on atoms and residues which may be useful for applying atom masks or identifying specific...
Definition atomgraph_abstracts.h:382

stormm::trajectory::CoordinateFrameReader
Collect C-style pointers for the elements of a read-only CoordinateFrame object.
Definition coordinateframe.h:65

stormm::trajectory::CoordinateFrameWriter
Collect C-style pointers for the elements of a writable CoordinateFrame object.
Definition coordinateframe.h:30

stormm::trajectory::CoordinateSeriesReader
Collect C-style pointers and critical constants for a read-only CoordinateSeries object.
Definition coordinate_series.h:96

stormm::trajectory::CoordinateSeriesWriter
Collect C-style pointers and critical constants for a writeable CoordinateSeries object.
Definition coordinate_series.h:66

stormm::trajectory::PhaseSpaceReader
Collect constants and pointers to the components of a read-only PhaseSpace object.
Definition phasespace.h:81

stormm::trajectory::PhaseSpaceWriter
Collect constants and pointers to the components of a modifiable PhaseSpace object.
Definition phasespace.h:31