tfDihedral.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of mdcore.
 * Coypright (c) 2010 Pedro Gonnet (pedro.gonnet@durham.ac.uk)
 * Coypright (c) 2017 Andy Somogyi (somogyie at indiana dot edu)
 * Copyright (c) 2022-2024 T.J. Sego
 * 
 * This program 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 of the License, or
 * (at your option) any later version.
 * 
 * This program 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * 
 ******************************************************************************/

 
#ifndef _MDCORE_INCLUDE_TFDIHEDRAL_H_
#define _MDCORE_INCLUDE_TFDIHEDRAL_H_
 
#include <mdcore_config.h>
#include <tfParticleList.h>
 
 
namespace TissueForge { 
 
 
    namespace rendering {
        struct Style;
    }
 
 
    typedef enum DihedralFlags {
 
        // none type dihedral are initial state, and can be
        // re-assigned if ref count is 1 (only owned by engine).
        DIHEDRAL_NONE                   = 0,
        DIHEDRAL_ACTIVE                 = 1 << 0
    } DihedralFlags;
 
    struct DihedralHandle;
    struct ParticleHandle;

    typedef struct CAPI_EXPORT Dihedral {
 
        uint32_t flags;
 
        /* id of particles involved */
        int i, j, k, l;
        
        uint32_t id;
 
        uint64_t creation_time;

        FPTYPE half_life;
 
        /* potential energy required to break this bond */
        FPTYPE dissociation_energy;
 
        /* potential energy of this bond */
        FPTYPE potential_energy;
 
        /* dihedral potential. */
        struct Potential *potential;
 
        struct rendering::Style *style;

        static rendering::Style *styleDef();
 
        void init(Potential *potential, 
                  ParticleHandle *p1, 
                  ParticleHandle *p2, 
                  ParticleHandle *p3, 
                  ParticleHandle *p4);

        static DihedralHandle *create(Potential *potential, 
                                      ParticleHandle *p1, 
                                      ParticleHandle *p2, 
                                      ParticleHandle *p3, 
                                      ParticleHandle *p4);

        std::string toString();

        static Dihedral *fromString(const std::string &str);
 
    } Dihedral;

    struct CAPI_EXPORT DihedralHandle {
        int id;

        Dihedral *get();

        std::string str() const;

        bool check();

        HRESULT destroy();

        static std::vector<DihedralHandle> items();

        bool decays();
 
        ParticleHandle *operator[](unsigned int index);

        bool has(const int32_t &pid);

        bool has(ParticleHandle *part);

        FloatP_t getAngle();

        FPTYPE getEnergy();

        std::vector<int32_t> getParts();

        ParticleList getPartList();

        Potential *getPotential();

        uint32_t getId();

        FPTYPE getDissociationEnergy();

        void setDissociationEnergy(const FPTYPE &dissociation_energy);

        FPTYPE getHalfLife();

        void setHalfLife(const FPTYPE &half_life);

        rendering::Style *getStyle();

        void setStyle(rendering::Style *style);

        FPTYPE getAge();
 
        DihedralHandle() : id(-1) {}

        DihedralHandle(const int &_id);
    };

    CAPI_FUNC(HRESULT) Dihedral_Destroy(Dihedral *d);

    CAPI_FUNC(HRESULT) Dihedral_DestroyAll();
 
    /* associated functions */

    HRESULT dihedral_eval(struct Dihedral *d, int N, struct engine *e, FPTYPE *epot_out);

    HRESULT dihedral_evalf(struct Dihedral *d, int N, struct engine *e, FPTYPE *f, FPTYPE *epot_out);

    std::vector<int32_t> Dihedral_IdsForParticle(int32_t pid);
 
    inline bool operator< (const TissueForge::DihedralHandle& lhs, const TissueForge::DihedralHandle& rhs) { return lhs.id < rhs.id; }
    inline bool operator> (const TissueForge::DihedralHandle& lhs, const TissueForge::DihedralHandle& rhs) { return rhs < lhs; }
    inline bool operator<=(const TissueForge::DihedralHandle& lhs, const TissueForge::DihedralHandle& rhs) { return !(lhs > rhs); }
    inline bool operator>=(const TissueForge::DihedralHandle& lhs, const TissueForge::DihedralHandle& rhs) { return !(lhs < rhs); }
    inline bool operator==(const TissueForge::DihedralHandle& lhs, const TissueForge::DihedralHandle& rhs) { return lhs.id == rhs.id; }
    inline bool operator!=(const TissueForge::DihedralHandle& lhs, const TissueForge::DihedralHandle& rhs) { return !(lhs == rhs); }
 
 
};
 
 
inline std::ostream &operator<<(std::ostream& os, const TissueForge::DihedralHandle &h)
{
    os << h.str().c_str();
    return os;
}
 
#endif // _MDCORE_INCLUDE_TFDIHEDRAL_H_