tfAngle.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_TFANGLE_H_
#define _MDCORE_INCLUDE_TFANGLE_H_
 
#include <mdcore_config.h>
#include "tfPotential.h"
#include <tfParticleList.h>
 
 
namespace TissueForge {
 
 
    namespace rendering {
        struct Style;
    }
 
 
    typedef enum AngleFlags {
 
        // none type angles are initial state, and can be
        // re-assigned if ref count is 1 (only owned by engine).
        ANGLE_NONE                   = 0,
        ANGLE_ACTIVE                 = 1 << 0
    } AngleFlags;
 
    struct AngleHandle;
    struct ParticleHandle;
 
    typedef struct CAPI_EXPORT Angle {
 
        uint32_t flags;
 
        /* id of particles involved */
        int i, j, k;
        
        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;
 
        /* id of the potential. */
        struct Potential *potential;
 
        struct rendering::Style *style;
 
        static rendering::Style *styleDef();
 
        void init(Potential *potential, 
                  struct ParticleHandle *p1, 
                  struct ParticleHandle *p2, 
                  struct ParticleHandle *p3, 
                  uint32_t flags=0);
 
        static AngleHandle *create(Potential *potential, 
                                   struct ParticleHandle *p1, 
                                   struct ParticleHandle *p2, 
                                   struct ParticleHandle *p3, 
                                   uint32_t flags=0);
 
        std::string toString();
 
        static Angle *fromString(const std::string &str);
 
    } Angle;
 
    struct CAPI_EXPORT AngleHandle {
        int id;
 
        Angle *get();
 
        std::string str() const;
 
        bool check();
 
        HRESULT destroy();
 
        static std::vector<AngleHandle> items();
 
        bool decays();
 
        struct 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();
 
        AngleHandle() : id(-1) {}
 
        AngleHandle(const int &_id);
    };
 
    CAPI_FUNC(HRESULT) Angle_Destroy(Angle *a);
 
    CAPI_FUNC(HRESULT) Angle_DestroyAll();
 
    /* associated functions */
    
    HRESULT angle_eval(struct Angle *a, int N, struct engine *e, FPTYPE *epot_out);
 
    HRESULT angle_evalf(struct Angle *a, int N, struct engine *e, FPTYPE *f, FPTYPE *epot_out);
 
    std::vector<int32_t> Angle_IdsForParticle(int32_t pid);
 
    inline bool operator< (const TissueForge::AngleHandle& lhs, const TissueForge::AngleHandle& rhs) { return lhs.id < rhs.id; }
    inline bool operator> (const TissueForge::AngleHandle& lhs, const TissueForge::AngleHandle& rhs) { return rhs < lhs; }
    inline bool operator<=(const TissueForge::AngleHandle& lhs, const TissueForge::AngleHandle& rhs) { return !(lhs > rhs); }
    inline bool operator>=(const TissueForge::AngleHandle& lhs, const TissueForge::AngleHandle& rhs) { return !(lhs < rhs); }
    inline bool operator==(const TissueForge::AngleHandle& lhs, const TissueForge::AngleHandle& rhs) { return lhs.id == rhs.id; }
    inline bool operator!=(const TissueForge::AngleHandle& lhs, const TissueForge::AngleHandle& rhs) { return !(lhs == rhs); }
 
 
};
 
 
inline std::ostream &operator<<(std::ostream& os, const TissueForge::AngleHandle &h)
{
    os << h.str().c_str();
    return os;
}
 
#endif // _MDCORE_INCLUDE_TFANGLE_H_