tfBond.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_TFBOND_H_
#define _MDCORE_INCLUDE_TFBOND_H_
 
#include <mdcore_config.h>
#include <tfParticleList.h>
 
 
namespace TissueForge {
 
 
    namespace rendering {
        struct Style;
    }
 
 
    typedef enum BondFlags {
 
        // none type bonds are initial state, and can be
        // re-assigned if ref count is 1 (only owned by engine).
        BOND_NONE                   = 0,
        // a non-active and will be over-written in the
        // next bond_alloc call.
        BOND_ACTIVE                 = 1 << 0,
    } BondFlags;
 
    // list of pairs...
    struct Pair {
        int32_t i;
        int32_t j;
    };
 
    typedef std::vector<Pair> PairList;
    struct BondHandle;
    struct ParticleHandle;

    typedef struct CAPI_EXPORT Bond {
 
        uint32_t flags;
 
        /* id of particles involved */
        int32_t i, j;
        
        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;
 
        struct Potential *potential;
        
        struct rendering::Style *style;

        static rendering::Style *styleDef();

        static BondHandle *create(
            struct Potential *potential, 
            ParticleHandle *i, 
            ParticleHandle *j, 
            FPTYPE *half_life=NULL, 
            FPTYPE *dissociation_energy=NULL, 
            uint32_t flags=0
        );

        std::string toString();

        static Bond *fromString(const std::string &str);
 
    } Bond;
 
    struct ParticleType;
    struct ParticleList;

    struct CAPI_EXPORT BondHandle {
        int32_t id;
        
        TissueForge::Bond *get();

        BondHandle() : id(-1) {};

        BondHandle(int id);

        BondHandle(
            struct TissueForge::Potential *potential, 
            int32_t i, 
            int32_t j, 
            FPTYPE half_life, 
            FPTYPE bond_energy, 
            uint32_t flags
        );

        HRESULT init(
            TissueForge::Potential *pot, 
            TissueForge::ParticleHandle *p1, 
            TissueForge::ParticleHandle *p2, 
            const FPTYPE &half_life=-FPTYPE_ONE, 
            const FPTYPE &bond_energy=-FPTYPE_ONE, 
            uint32_t flags=0
        );
        
        std::string str() const;

        bool check();
        
        static std::vector<BondHandle> pairwise(
            TissueForge::Potential* pot,
            TissueForge::ParticleList &parts,
            const FPTYPE &cutoff,
            std::vector<std::pair<TissueForge::ParticleType*, TissueForge::ParticleType*>* > *ppairs,
            const FPTYPE &half_life,
            const FPTYPE &bond_energy,
            uint32_t flags
        );
        
        HRESULT destroy();

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

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

        bool has(const int32_t &pid);

        bool has(ParticleHandle *part);

        FloatP_t getLength();
        
        FPTYPE getEnergy();

        std::vector<int32_t> getParts();

        ParticleList getPartList();

        TissueForge::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();
 
    private:
 
        HRESULT _init(
            uint32_t flags, 
            int32_t i, 
            int32_t j, 
            FPTYPE half_life, 
            FPTYPE bond_energy, 
            struct Potential *potential
        );
    };
 
    bool contains_bond(const std::vector<BondHandle> &bonds, int a, int b);

    CAPI_FUNC(HRESULT) Bond_Destroy(Bond *b);

    CAPI_FUNC(HRESULT) Bond_DestroyAll();
 
    HRESULT Bond_Energy (Bond *b, FPTYPE *epot_out);
 
    /* associated functions */

    CAPI_FUNC(HRESULT) bond_eval (Bond *b, int N, struct engine *e, FPTYPE *epot_out);

    CAPI_FUNC(HRESULT) bond_evalf (Bond *b, int N, struct engine *e, FPTYPE *f, FPTYPE *epot_out);
 

    std::vector<int32_t> Bond_IdsForParticle(int32_t pid);
 
    int insert_bond(
        std::vector<BondHandle> &bonds, 
        int a, 
        int b,
        Potential *pot, 
        ParticleList *parts
    );
 
    inline bool operator< (const TissueForge::BondHandle& lhs, const TissueForge::BondHandle& rhs) { return lhs.id < rhs.id; }
    inline bool operator> (const TissueForge::BondHandle& lhs, const TissueForge::BondHandle& rhs) { return rhs < lhs; }
    inline bool operator<=(const TissueForge::BondHandle& lhs, const TissueForge::BondHandle& rhs) { return !(lhs > rhs); }
    inline bool operator>=(const TissueForge::BondHandle& lhs, const TissueForge::BondHandle& rhs) { return !(lhs < rhs); }
    inline bool operator==(const TissueForge::BondHandle& lhs, const TissueForge::BondHandle& rhs) { return lhs.id == rhs.id; }
    inline bool operator!=(const TissueForge::BondHandle& lhs, const TissueForge::BondHandle& rhs) { return !(lhs == rhs); }
 
 
};
 
 
inline std::ostream &operator<<(std::ostream& os, const TissueForge::BondHandle &h)
{
    os << h.str().c_str();
    return os;
}
 
#endif // _MDCORE_INCLUDE_TFBOND_H_