tfForce.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of mdcore.
 * 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_TFFORCE_H_
#define _MDCORE_INCLUDE_TFFORCE_H_
 
#include "tf_platform.h"
#include "tf_fptype.h"
#include <types/tf_types.h>
#include <io/tf_io.h>
 
#include <limits>
 
 
namespace TissueForge { 
 
 
    enum FORCE_KIND {
        FORCE_ONEBODY,
        FORCE_PAIRWISE
    };
 
    enum FORCE_TYPE {
        FORCE_FORCE         = 0, 
        FORCE_BERENDSEN     = 1 << 0, 
        FORCE_GAUSSIAN      = 1 << 1, 
        FORCE_FRICTION      = 1 << 2, 
        FORCE_SUM           = 1 << 3, 
        FORCE_CUSTOM        = 1 << 4
    };
 
    typedef void (*Force_EvalFcn)(struct Force*, struct Particle*, FPTYPE*);
 
    struct Berendsen;
    struct Gaussian;
    struct Friction;
 
    struct CAPI_EXPORT Force {
        FORCE_TYPE type = FORCE_FORCE;
 
        Force_EvalFcn func;
 
        int stateVectorIndex = -1;
 
        virtual bool isCustom() { return false; }
 
        HRESULT bind_species(struct ParticleType *a_type, const std::string &coupling_symbol);
 
        static Berendsen* berendsen_tstat(const FPTYPE &tau);
 
        static Gaussian* random(const FPTYPE &std, const FPTYPE &mean, const FPTYPE &duration=0.01);
 
        static Friction* friction(const FPTYPE &coef);
 
        Force& operator+(const Force& rhs);
 
        virtual std::string toString();
 
        static Force *fromString(const std::string &str);
    };
 
    struct CAPI_EXPORT ForceSum : Force {
        Force *f1, *f2;
 
        static ForceSum *fromForce(Force *f);
    };
 
    CAPI_FUNC(Force*) Force_add(Force *f1, Force *f2);
 
    struct CustomForce;
    using UserForceFuncType = FVector3(*)(CustomForce*);
 
    struct CAPI_EXPORT CustomForce : Force {
        UserForceFuncType *userFunc;
        FPTYPE updateInterval;
        FPTYPE lastUpdate;
        
        FVector3 force;
        
        virtual void onTime(FPTYPE time);
 
        virtual FVector3 getValue();
        
        void setValue(const FVector3 &f);
        
        void setValue(UserForceFuncType *_userFunc=NULL);
 
        FPTYPE getPeriod();
        void setPeriod(const FPTYPE &period);
 
        bool isCustom() { return true; }
 
        CustomForce();
        CustomForce(const FVector3 &f, const FPTYPE &period=std::numeric_limits<FPTYPE>::max());
        CustomForce(UserForceFuncType *f, const FPTYPE &period=std::numeric_limits<FPTYPE>::max());
        virtual ~CustomForce(){}
 
        static CustomForce *fromForce(Force *f);
    };
 
    struct CAPI_EXPORT Berendsen : Force {
        FPTYPE itau;
 
        static Berendsen *fromForce(Force *f);
    };
 
    struct CAPI_EXPORT Gaussian : Force {
        FPTYPE std;
 
        FPTYPE mean;
 
        unsigned durration_steps;
 
        static Gaussian *fromForce(Force *f);
    };
 
    struct CAPI_EXPORT Friction : Force {
        FPTYPE coef;
 
        static Friction *fromForce(Force *f);
    };
 
 
    CPPAPI_FUNC(ForceSum*) ForceSum_fromStr(const std::string &str);
    CPPAPI_FUNC(Berendsen*) Berendsen_fromStr(const std::string &str);
    CPPAPI_FUNC(Gaussian*) Gaussian_fromStr(const std::string &str);
    CPPAPI_FUNC(Friction*) Friction_fromStr(const std::string &str);
 
};
 
#endif // _MDCORE_INCLUDE_TFFORCE_H_