tfFlux.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_TFFLUX_H_
#define _MDCORE_INCLUDE_TFFLUX_H_
 
#include "tf_platform.h"
#include <mdcore_config.h>
#include <io/tf_io.h>
#include "tfSpace_cell.h"
 
#include <string>
 
 
namespace TissueForge { 
 
 
    enum FluxKind {
        FLUX_FICK = 0,
        FLUX_SECRETE = 1,
        FLUX_UPTAKE = 2
    };
 
 
    // keep track of the ids of the particle types, to determine
    // the reaction direction.
    struct TypeIdPair {
        int16_t a;
        int16_t b;
    };
 
    struct CAPI_EXPORT Flux {
        int32_t       size; // temporary size until we get SIMD instructions.
        int8_t        kinds[TF_SIMD_SIZE];
        TypeIdPair    type_ids[TF_SIMD_SIZE];
        int32_t       indices_a[TF_SIMD_SIZE];
        int32_t       indices_b[TF_SIMD_SIZE];
        FPTYPE        coef[TF_SIMD_SIZE];
        FPTYPE        decay_coef[TF_SIMD_SIZE];
        FPTYPE        target[TF_SIMD_SIZE];
        FPTYPE        cutoff[TF_SIMD_SIZE];
    };
 
    struct ParticleType;
 
    struct CAPI_EXPORT Fluxes
    {
        int32_t size;          // how many individual flux objects this has
        int32_t fluxes_size;   // how many fluxes (blocks) this has.
        // static int32_t init;
        Flux fluxes[];       // allocated in single block, this
 
        static Fluxes* newFluxes(int32_t init_size);
        static Fluxes *create(
            FluxKind kind, 
            ParticleType *a, 
            ParticleType *b,
            const std::string& name, 
            FPTYPE k, 
            FPTYPE decay, 
            FPTYPE target,
            FPTYPE cutoff=-FPTYPE_ONE
        );
        static Fluxes *addFlux(
            FluxKind kind, 
            Fluxes *fluxes,
            int16_t typeId_a, 
            int16_t typeId_b,
            int32_t index_a, 
            int32_t index_b,
            FPTYPE k, 
            FPTYPE decay, 
            FPTYPE target,
            FPTYPE cutoff
        );
 
        static Fluxes *fluxFick(
            ParticleType *A, 
            ParticleType *B, 
            const std::string &name, 
            const FPTYPE &k, 
            const FPTYPE &decay=FPTYPE_ZERO, 
            const FPTYPE &cutoff=-FPTYPE_ONE
        );
 
        static Fluxes *flux(
            ParticleType *A, 
            ParticleType *B, 
            const std::string &name, 
            const FPTYPE &k, 
            const FPTYPE &decay=FPTYPE_ZERO, 
            const FPTYPE &cutoff=-FPTYPE_ONE
        );
 
        static Fluxes *secrete(
            ParticleType *A, 
            ParticleType *B, 
            const std::string &name, 
            const FPTYPE &k, 
            const FPTYPE &target, 
            const FPTYPE &decay=FPTYPE_ZERO, 
            const FPTYPE &cutoff=-FPTYPE_ONE
        );
 
        static Fluxes *uptake(
            ParticleType *A, 
            ParticleType *B, 
            const std::string &name, 
            const FPTYPE &k, 
            const FPTYPE &target, 
            const FPTYPE &decay=FPTYPE_ZERO, 
            const FPTYPE &cutoff=-FPTYPE_ONE
        );
 
        std::string toString();
 
        static Fluxes *fromString(const std::string &str);
    };
 
    HRESULT Fluxes_integrate(space_cell *cell, FPTYPE dt=-1.0);
 
    HRESULT Fluxes_integrate(int cellId);
 
 
};
 
#endif // _MDCORE_INCLUDE_TFFLUX_H_