state_engine.h

Go to the documentation of this file.

/* -------------------------------------------------------------------------*
*                               SPHinXsys                                   *
* --------------------------------------------------------------------------*
* SPHinXsys (pronunciation: s'finksis) is an acronym from Smoothed Particle *
* Hydrodynamics for industrial compleX systems. It provides C++ APIs for    *
* physical accurate simulation and aims to model coupled industrial dynamic *
* systems including fluid, solid, multi-body dynamics and beyond with SPH   *
* (smoothed particle hydrodynamics), a meshless computational method using  *
* particle discretization.                                                  *
*                                                                           *
* SPHinXsys is partially funded by German Research Foundation               *
* (Deutsche Forschungsgemeinschaft) DFG HU1527/6-1, HU1527/10-1             *
* and HU1527/12-1.                                                          *
*                                                                           *
* Portions copyright (c) 2017-2020 Technical University of Munich and       *
* the authors' affiliations.                                                *
*                                                                           *
* Licensed under the Apache License, Version 2.0 (the "License"); you may   *
* not use this file except in compliance with the License. You may obtain a *
* copy of the License at http://www.apache.org/licenses/LICENSE-2.0.        *
*                                                                           *
* --------------------------------------------------------------------------*/
#ifndef STATE_ENGINE_SIMBODY_H
#define STATE_ENGINE_SIMBODY_H


#define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING

#include "base_data_package.h"
#include "array.h"
#include "exception.h"
#include "all_simbody.h"

#include <iostream>
#include <string>
#include <cstdio>
#include <stdexcept>

#include "Simbody.h"
#include "SimTKmath.h"
#include "SimTKcommon.h"
#include "simbody/internal/MultibodySystem.h"

namespace SPH {
    class StateEngine {
        //===============================================================//
        // PROTECTED
        //===============================================================//
    protected:

        XmlEngine simbody_xml_engine_;

        void resizeXmlDocForSimbody(size_t input_size);

        class StateVariable {
            //friend void StateEngine::addStateVariable(StateVariable* sv);
        public:
            StateVariable() :name_(""), owner_(nullptr),
                subsysindex_(SimTK::InvalidIndex),
                varindex_(SimTK::InvalidIndex),
                sysyindex_(SimTK::InvalidIndex) {}
            explicit StateVariable(std::string& name,    
                StateEngine& owner,                    
                SimTK::SubsystemIndex subsys,          
                int varindex)                          
                : name_(name), owner_(&owner), subsysindex_(subsys),
                varindex_(varindex), sysyindex_(SimTK::InvalidIndex) {}
            virtual ~StateVariable() {}

            std::string& getName() { return name_; }
            StateEngine& getOwner() { return *owner_; }
            int& getVarIndex() { return varindex_; }
            SimTK::SubsystemIndex& getSubsysIndex() { return subsysindex_; }
            SimTK::SystemYIndex& getSystemYIndex() { return sysyindex_; }
            void setVarIndex(int index) { varindex_ = index; }
            void setSubsystemIndex(SimTK::SubsystemIndex& subsysindx)
            {
                subsysindex_ = subsysindx;
            }
            virtual Real getValue() = 0;
            virtual void setValue(Real value) = 0;
            virtual Real getDerivative() = 0;
            virtual void setDerivative(Real deriv) = 0;
        private:
            std::string name_;
            SimTK::ReferencePtr<StateEngine> owner_;
            SimTK::SubsystemIndex subsysindex_;
            int  varindex_;
            SimTK::SystemYIndex sysyindex_;
        };
        //===============================================================//
        // PRIVATE
        //===============================================================//
        class AddedStateVariable : public StateVariable {
        public:
            AddedStateVariable() : StateVariable(), invalidatestage_(SimTK::Stage::Empty) {}

            explicit AddedStateVariable(std::string& name,     
                StateEngine& owner,
                SimTK::Stage invalidatestage) :              
                StateVariable(name, owner,
                    SimTK::SubsystemIndex(SimTK::InvalidIndex),
                    SimTK::InvalidIndex),
                invalidatestage_(SimTK::Stage::Empty) {}

            Real getValue() override;
            void setValue(Real value) override;
            Real getDerivative() override;
            void setDerivative(Real deriv) override;

        private:
            SimTK::Stage    invalidatestage_;
        };
 
        UniquePtrKeepers<AddedStateVariable> added_state_variable_ptr_keeper_;
        struct StateVariableInfo {
            StateVariableInfo() {}
            explicit StateVariableInfo(StateEngine::StateVariable* sv, int order) :
                statevariable_(sv), order(order) {}

            StateVariableInfo(const StateVariableInfo&) {}
            StateVariableInfo& operator=(const StateVariableInfo& svi) {
                if (this != &svi) {
                    StateVariableInfo* mutableSvi = const_cast<StateVariableInfo*>(&svi);
                    statevariable_.swap(mutableSvi->statevariable_);
                }
                order = svi.order;
                return *this;
            }

            // State variable
            std::unique_ptr<StateEngine::StateVariable> statevariable_;
            // order of allocation
            int order;
        };
        //===============================================================//
        // PULIC
        //===============================================================//       
    public:

        void addStateVariable(std::string  statevariablename,
            SimTK::Stage invalidatestage);

        void addStateVariable(StateEngine::StateVariable* statevariable);
        //===========================================================//
        SimTK::DefaultSystemSubsystem& getDefaultSubsystem()
        {
            return const_cast<SimTK::DefaultSystemSubsystem&>
                (getMultibodySystem().getDefaultSubsystem());
        }
        SimTK::DefaultSystemSubsystem& updDefaultSubsystem()
        {
            return getMultibodySystem().updDefaultSubsystem();
        }
        //===========================================================//
        StateVariable* traverseToStateVariable(std::string& pathname);
        mutable std::map<std::string, StateVariableInfo> namedstatevariableinfo_;
        bool isAllStatesVariablesListValid();

        mutable SimTK::Array_<SimTK::ReferencePtr<StateVariable> >
            allstatevariables_;
        mutable SimTK::ReferencePtr<SimTK::System> statesassociatedsystem_;

        StateEngine(SimTK::MultibodySystem& system);

        SimTK::ReferencePtr<SimTK::MultibodySystem> mbsystem_;
        SimTK::State working_state_;

        virtual ~StateEngine() {};
        void InitializeState();
        SimTK::MultibodySystem& getMultibodySystem();
        SimTK::MultibodySystem& updMultibodySystem();
        int getNumOfStateVariables();
        int getNumStateVariablesAddedByEngine()
        {
            return (int)namedstatevariableinfo_.size();
        }
        Array<std::string> getStateVariableNames();
        SimTK::Vector getStateVariableValues();
        void reporter(SimTK::State& state_);
        std::string restart_folder_;
        void writeStateInfoToXml(int ite_rst_, const SimTK::State& state_);
        SimTK::State readAndSetStateInfoFromXml(int ite_rst_, SimTK::MultibodySystem& system_);
        void realizeTime();
        void realizePosition();
        void realizeVelocity();
        void realizeDynamics();
        void realizeAcceleration();
        void realizeReport();
    };
}
#endif //STATE_ENGINE_SIMBODY_H