tfUniverse.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of Tissue Forge.
 * 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 _SOURCE_TFUNIVERSE_H_
#define _SOURCE_TFUNIVERSE_H_
 
#include "TissueForge_private.h"
#ifdef TF_FPTYPE_SINGLE
#include <mdcore_single.h>
#else
#include <mdcore_double.h>
#endif
#include "io/tf_io.h"
#include <unordered_map>
#include "event/tfEventList.h"
 
 
namespace TissueForge { 
 

    struct CAPI_EXPORT Universe  {
 
        enum Flags {
            RUNNING = 1 << 0,
 
            SHOW_PERF_STATS = 1 << 1,
 
            // in ipython message loop, monitor console
            IPYTHON_MSGLOOP = 1 << 2,
 
            // standard polling message loop
            POLLING_MSGLOOP = 1 << 3,
        };

        static FVector3 dim();

        static FloatP_t volume();
 
        bool isRunning = false;
 
        event::EventBaseList *events;
 
        // name of the model / script, usually picked up from command line;
        std::string name;

        static std::string getName();
        
        static FMatrix3 *virial(FVector3 *origin=NULL, FloatP_t *radius=NULL, std::vector<ParticleType*> *types=NULL);

        static FVector3 getCenter();

        static HRESULT step(const FloatP_t &until=0, const FloatP_t &dt=0);

        static HRESULT stop();

        static HRESULT start();
 
        static HRESULT reset();
 
        static Universe* get();

        static ParticleList particles();

        static std::vector<int32_t> particleIds();

        static void resetSpecies();

        static std::vector<std::vector<std::vector<ParticleList> > > grid(iVector3 shape);

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

        static std::vector<AngleHandle> angles();

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

        static FloatP_t getTemperature();

        static FloatP_t getTime();

        static FloatP_t getDt();
        static event::EventList *getEventList();

        static BoundaryConditions *getBoundaryConditions();

        static FloatP_t getKineticEnergy();

        static int getNumTypes();

        static FloatP_t getCutoff();

        static unsigned int getNumFluxSteps();
    };

 
    struct CAPI_EXPORT UniverseConfig {
        FVector3 dim;

        iVector3 spaceGridSize;

        FloatP_t cutoff;
        uint32_t flags;
        uint32_t maxTypes;

        FloatP_t dt;

        long start_step;
        FloatP_t temp;
        int nParticles;

        int threads;

        unsigned int nr_fluxsteps;

        EngineIntegrator integrator;
        
        // pointer to boundary conditions ctor data
        // these objects are parsed initializing the engine.
        BoundaryConditionsArgsContainer *boundaryConditionsPtr;
 
        FloatP_t max_distance;
        
        // bitmask of timers to show in performance counter output.
        uint32_t timers_mask;
        
        long timer_output_period;
        
        UniverseConfig();
        
        // just set the object, borow a pointer to python handle
        void setBoundaryConditions(BoundaryConditionsArgsContainer *_bcArgs) {
            boundaryConditionsPtr = _bcArgs;
        }
        
        ~UniverseConfig() {
            if(boundaryConditionsPtr) {
                delete boundaryConditionsPtr;
                boundaryConditionsPtr = 0;
            }
        }
    };
 

    CAPI_FUNC(HRESULT) Universe_Step(FloatP_t until, FloatP_t dt);

    CAPI_FUNC(int) Universe_Flag(Universe::Flags flag);

    CAPI_FUNC(HRESULT) Universe_SetFlag(Universe::Flags flag, int value);
 
 

    extern CAPI_EXPORT Universe _Universe;

    CAPI_FUNC(Universe*) getUniverse();
 
 
    namespace io { 
 
        template <>
        HRESULT toFile(const Universe &dataElement, const MetaData &metaData, IOElement &fileElement);
 
        template <>
        HRESULT fromFile(const IOElement &fileElement, const MetaData &metaData, Universe *dataElement);
 
    }
 
};
 
#endif // _SOURCE_TFUNIVERSE_H_