engngm.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2025   Borek Patzak
 *
 *
 *
 *       Czech Technical University, Faculty of Civil Engineering,
 *   Department of Structural Mechanics, 166 29 Prague, Czech Republic
 *
 *  This library 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 2.1 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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef engngm_h
#define engngm_h
 
#include "oofemenv.h"
#include "inputrecord.h"
#include "intarray.h"
#include "fieldmanager.h"
#include "metastep.h"
#include "timer.h"
#include "assemblercallback.h"
#include "chartype.h"
#include "unknowntype.h"
#include "varscaletype.h"
#include "numericalcmpn.h"
#include "valuemodetype.h"
#include "internalstatetype.h"
#include "problemmode.h"
#include "fmode.h"
#include "dofiditem.h"
#include "contextoutputmode.h"
#include "contextfilemode.h"
#include "contextioresulttype.h"
#include "metastep.h"
#include "parallelcontext.h"
#include "exportmodulemanager.h"
#include "initmodulemanager.h"
#include "monitormanager.h"
#include "timestepcontroller.h"
 
#ifdef __MPM_MODULE
#include "../mpm/mpm.h"
#include "../mpm/integral.h"
#endif
 
#ifdef __MPI_PARALLEL_MODE
 #include "parallel.h"
#endif
 
#include <string>
#include <memory>


#define _IFT_EngngModel_nsteps "nsteps"
#define _IFT_EngngModel_contextoutputstep "contextoutputstep"
#define _IFT_EngngModel_renumberFlag "renumber"
#define _IFT_EngngModel_profileOpt "profileopt"
#define _IFT_EngngModel_nmsteps "nmsteps"
#define _IFT_EngngModel_nonLinFormulation "nonlinform"
#define _IFT_EngngModel_eetype "eetype"
#define _IFT_EngngModel_parallelflag "parallelflag"
#define _IFT_EngngModel_loadBalancingFlag "lbflag"
#define _IFT_EngngModel_forceloadBalancingFlag "forcelb1"
#define _IFT_EngngModel_initialGuess "initialguess"
#define _IFT_EngngModel_referenceFile "referencefile"
 
#define _IFT_EngngModel_lstype "lstype"
#define _IFT_EngngModel_smtype "smtype"
 
#define _IFT_EngngModel_suppressOutput "suppress_output" // Suppress writing to .out file

 
namespace oofem {
class Domain;
class TimeStep;
class Dof;
class DofManager;
class DataReader;
class DataStream;
class ErrorEstimator;
class MetaStep;
class MaterialInterface;
class SparseMtrx;
class NumericalMethod;
class InitModuleManager;
class ExportModuleManager;
class FloatMatrix;
class FloatArray;
class LoadBalancer;
class LoadBalancerMonitor;
class oofegGraphicContext;
class ProblemCommunicator;
class ProcessCommunicatorBuff;
class CommunicatorBuff;
class ProcessCommunicator;
class UnknownNumberingScheme;
 

class OOFEM_EXPORT EngngModelContext
{
protected:
    FieldManager fieldManager;
 
public:
    EngngModelContext() : fieldManager() { }
    FieldManager *giveFieldManager() { return & ( this->fieldManager ); }
};
 

class OOFEM_EXPORT EngngModel
{
public:
    enum EngngModel_UpdateMode { EngngModel_Unknown_Mode, EngngModel_SUMM_Mode, EngngModel_SET_Mode };
    enum EngngModelCommType { PC_default, PC_nonlocal };
    struct ArrayWithNumbering {
        FloatArray *array;
        const UnknownNumberingScheme *numbering;
    };

    enum InitialGuess {
        IG_None = 0, 
        IG_Tangent = 1, 
        //IG_Extrapolated = 2, ///< Assumes constant increment extrapolating @f$ {}^{n+1}x = {}^{n}x + \Delta t\delta{x}'@f$, where @f$ \delta x' = ({}^{n}x - {}^{n-1}x)/{}^{n}Delta t@f$.
    };
 
protected:
    int ndomains;
    std :: vector< std :: unique_ptr< Domain > > domainList;
    int numberOfSteps;
    int numberOfEquations;
    int numberOfPrescribedEquations;
    IntArray domainNeqs;
    IntArray domainPrescribedNeqs;
    bool renumberFlag;
    bool profileOpt;
    int equationNumberingCompleted;
    int nMetaSteps;
    std :: vector< MetaStep > metaStepList;
    std :: unique_ptr< TimeStep > stepWhenIcApply;
    std :: unique_ptr< TimeStep > currentStep;
    std :: unique_ptr< TimeStep > previousStep;
    int number;

    std :: string dataOutputFileName;
    std :: string coreOutputFileName;
    FILE *outputStream;
    std :: string referenceFileName;
    ContextOutputMode contextOutputMode;
    int contextOutputStep;

    ExportModuleManager exportModuleManager;
    InitModuleManager initModuleManager;
    MonitorManager monitorManager;

    problemMode pMode;
    problemScale pScale;
    time_t startTime;

    EngngModel *master;

    EngngModelContext *context;
    EngngModelTimer timer;
    int parallelFlag;
    enum fMode nonLinFormulation;
    std::unique_ptr<ErrorEstimator> defaultErrEstimator;
    std::unique_ptr<TimeStepController> timeStepController;
    int rank;
    int numProcs;
    int nonlocalExt;
#ifdef __MPI_PARALLEL_MODE
    char processor_name [ PROCESSOR_NAME_LENGTH ];
 #ifdef __USE_MPI
    MPI_Comm comm;
 #endif

    std::unique_ptr<LoadBalancer> lb;
    std::unique_ptr<LoadBalancerMonitor> lbm;
    bool loadBalancingFlag;
    bool force_load_rebalance_in_first_step;

    CommunicatorBuff *commBuff;
    ProblemCommunicator *communicator;

    ProblemCommunicator *nonlocCommunicator;
#endif
    enum { InternalForcesExchangeTag, MassExchangeTag, LoadExchangeTag, ReactionExchangeTag, RemoteElementExchangeTag };
    std :: vector< ParallelContext > parallelContextList;
 
 
#ifdef __MPM_MODULE
    std :: map< std :: string, std::unique_ptr< Variable > >  variableMap;
    std :: vector < std :: unique_ptr< Term > > termList;
    std :: vector < std :: unique_ptr< Integral > > integralList;
#endif
 
 
 

    bool suppressOutput;
 
    std::string simulationDescription;
 
public:
    EngngModel(int i, EngngModel * _master = NULL);
    virtual ~EngngModel();
    EngngModel(const EngngModel &) = delete;
    EngngModel &operator=(const EngngModel &) = delete;
    Domain *giveDomain(int n);
    void setDomain(int i, Domain *ptr, bool iDeallocateOld = true);
    int giveNumberOfDomains() { return (int)domainList.size(); }
 
    const std :: string &giveDescription() const { return simulationDescription; }
    const time_t &giveStartTime() { return startTime; }
    bool giveSuppressOutput() const { return suppressOutput; }

    virtual ErrorEstimator *giveDomainErrorEstimator(int n) { return defaultErrEstimator.get(); }
    virtual MaterialInterface *giveMaterialInterface(int n) { return nullptr; }
    void setNumberOfEquations(int id, int neq) {
        numberOfEquations = neq;
        domainNeqs.at(id) = neq;
    }
    // input / output
    FILE *giveOutputStream();
    std :: string giveOutputBaseFileName() { return dataOutputFileName; }

    std :: string giveReferenceFileName()  { return referenceFileName;}

    void letOutputBaseFileNameBe(const std :: string &src);
    ContextOutputMode giveContextOutputMode() const { return contextOutputMode; }
    int giveContextOutputStep() const { return contextOutputStep; }
    void setContextOutputMode(ContextOutputMode contextMode)
    { contextOutputMode = contextMode; }

    void setUDContextOutputMode(int cStep)
    {
        contextOutputMode = COM_UserDefined;
        contextOutputStep = cStep;
    }

    double giveDeltaT(){return this->timeStepController->giveDeltaT();}
    void setDeltaT(double dT){return this->timeStepController->setDeltaT(dT);}
 
    
    void setProblemMode(problemMode pmode) { pMode = pmode; }
    void setParallelMode(bool newParallelFlag);
    problemMode giveProblemMode() const { return pMode; }
    void setProblemScale(problemScale pscale) { pScale = pscale; }
    problemScale giveProblemScale() const { return pScale; }
    virtual void setRenumberFlag() { this->renumberFlag = true; }
    virtual void resetRenumberFlag() { this->renumberFlag = false; }

    double giveSolutionStepTime();
    void giveAnalysisTime(int &rhrs, int &rmin, int &rsec, int &uhrs, int &umin, int &usec);
    void terminateAnalysis();
 
    // solving
    virtual void solveYourself();    
    virtual void restartYourself(TimeStep *tS){;}
    virtual void solveYourselfAt(TimeStep *tStep) { }
    virtual void terminate(TimeStep *tStep);
    virtual void doStepOutput(TimeStep *tStep);
    void saveStepContext(TimeStep *tStep, ContextMode mode);
    virtual void updateYourself(TimeStep *tStep);
    virtual void initializeYourself(TimeStep *tStep);
    virtual int initializeAdaptive(int tStepNumber) { return 0; }

    virtual int giveNumberOfDomainEquations(int di, const UnknownNumberingScheme &num);
 
    // management components
    virtual double giveUnknownComponent(ValueModeType, TimeStep *, Domain *, Dof *) { return 0.0; }

    virtual FieldPtr giveField (FieldType key, TimeStep *) { return FieldPtr();}
    virtual FieldPtr giveField (InternalStateType key, TimeStep *) ;
 

    EngngModel *giveMasterEngngModel() { return this->master; }

    virtual double giveLoadLevel() { return 1.0; }

    virtual double giveEigenValue(int eigNum) { return 0.0; }
    virtual void setActiveVector(int i) { }
    int updateSharedDofManagers(FloatArray &answer, const UnknownNumberingScheme &s, int ExchangeTag);
    int exchangeRemoteElementData(int ExchangeTag);
    virtual int giveCurrentNumberOfIterations() {return 1;}
 
#ifdef __MPI_PARALLEL_MODE
    MPI_Comm giveParallelComm() { return this->comm; }
    int packRemoteElementData(ProcessCommunicator &processComm);
    int unpackRemoteElementData(ProcessCommunicator &processComm);
    int packDofManagers(ArrayWithNumbering *src, ProcessCommunicator &processComm);
    int unpackDofManagers(ArrayWithNumbering *dest, ProcessCommunicator &processComm);
 
    ProblemCommunicator *giveProblemCommunicator(EngngModelCommType t) {
        if ( t == PC_default ) {
            return communicator;
        } else if ( t == PC_nonlocal ) {
            return nonlocCommunicator;
        } else {
            return NULL;
        }
    }
#endif
    void initializeCommMaps(bool forceInit = false);
    virtual int instanciateYourself(DataReader &dr, InputRecord &ir, const char *outFileName, const char *desc);
    void Instanciate_init();
    virtual void initializeFrom(InputRecord &ir);
    int instanciateDomains(DataReader &dr);
    int instanciateMetaSteps(DataReader &dr);
    virtual int instanciateDefaultMetaStep(InputRecord &ir);

    virtual void updateAttributes(MetaStep *mStep);
    void initMetaStepAttributes(MetaStep *mStep){
      this->timeStepController->initMetaStepAttributes(mStep);
    }

    virtual void saveContext(DataStream &stream, ContextMode mode);
    virtual void restoreContext(DataStream &stream, ContextMode mode);
    virtual void updateDomainLinks();
    MetaStep *giveCurrentMetaStep();
    virtual TimeStep *giveCurrentStep(bool force = false) {
      if ( master && (!force)) {
            return master->giveCurrentStep();
        } else {
        return currentStep.get();
        //timeStepController->giveCurrentStep();
        }
    }
    
    virtual void adaptTimeStep(double nIter){
      //timeStepController->adaptTimeStep(nIter);
    }
 
 
    
    virtual TimeStep *givePreviousStep(bool force = false) {
        if ( master && (!force)) {
            return master->givePreviousStep();
        } else {
        return previousStep.get();
      //timeStepController->givePreviousStep();
        }
    }

    virtual TimeStep *giveNextStep() { return this->timeStepController->giveNextStep(); }
    virtual void preInitializeNextStep() {}
    virtual TimeStep *giveSolutionStepWhenIcApply(bool force = false) {
        if ( master && (!force)) {
            return master->giveSolutionStepWhenIcApply();
        } else {
            return stepWhenIcApply.get();
        }
    }

    virtual int giveNumberOfFirstStep(bool force = false) {
        if ( master && (!force)) {
            return master->giveNumberOfFirstStep();
        } else {
            return 1;
        }
    }

    int giveNumberOfMetaSteps() { return this->timeStepController->giveNumberOfMetaSteps(); }
    MetaStep *giveMetaStep(int i) {return this->timeStepController->giveMetaStep(i);}
    int giveNumberOfSteps(bool force = false) {
        if ( master && (!force)) {
            return master->giveNumberOfSteps();
        } else {
      return timeStepController->giveNumberOfSteps();
        }
    }

    virtual double giveEndOfTimeOfInterest() { return 0.; }
    int giveNumberOfTimeStepWhenIcApply() { return 0; }
    virtual NumericalMethod *giveNumericalMethod(MetaStep *mStep) { return nullptr; }
    ExportModuleManager *giveExportModuleManager() { return &exportModuleManager; }
    EngngModelTimer *giveTimer() { return & timer; }
 

    virtual double giveInitialTime(){return 0.;}
    virtual double giveFinalTime()
    {
      return timeStepController->giveFinalTime();
    }

    virtual int giveNewEquationNumber(int domain, DofIDItem) { return ++domainNeqs.at(domain); }
    virtual int giveNewPrescribedEquationNumber(int domain, DofIDItem) { return ++domainPrescribedNeqs.at(domain); }
    std :: string giveContextFileName(int tStepNumber, int stepVersion) const;
    std :: string giveDomainFileName(int domainNum, int domainSerNum) const;
    virtual void updateComponent(TimeStep *tStep, NumericalCmpn cmpn, Domain *d);
    virtual void initForNewIteration(Domain *d, TimeStep *tStep, int iterationNumber, const FloatArray &solution);
    virtual void updateSolution(FloatArray &solutionVector, TimeStep *tStep, Domain *d);
    virtual void updateInternalRHS(FloatArray &answer, TimeStep *tStep, Domain *d, FloatArray *eNorm);
    virtual void updateMatrix(SparseMtrx &mat, TimeStep *tStep, Domain *d);
    virtual void initStepIncrements();
    virtual int forceEquationNumbering(int i);
    virtual int forceEquationNumbering();
    virtual int requiresUnknownsDictionaryUpdate() { return false; }
    virtual bool requiresEquationRenumbering(TimeStep *tStep) { return renumberFlag; }
    //virtual int supportsBoundaryConditionChange () {return 0;}
    virtual void updateDofUnknownsDictionary(DofManager *, TimeStep *) { }
    virtual int giveUnknownDictHashIndx(ValueModeType mode, TimeStep *tStep) { return 0; }
    virtual bool newDofHandling() { return false; }
    virtual ParallelContext *giveParallelContext(int n);
    virtual void initParallelContexts();

    virtual void assemble(SparseMtrx &answer, TimeStep *tStep,
                          const MatrixAssembler &ma, const UnknownNumberingScheme &s, Domain *domain);
    virtual void assemble(SparseMtrx &answer, TimeStep *tStep,
                          const MatrixAssembler &ma, const UnknownNumberingScheme &r_s, const UnknownNumberingScheme &c_s, Domain *domain);
    void assembleVector(FloatArray &answer, TimeStep *tStep, const VectorAssembler &va, ValueModeType mode,
                        const UnknownNumberingScheme &s, Domain *domain, FloatArray *eNorms = NULL);
    void assembleVectorFromDofManagers(FloatArray &answer, TimeStep *tStep, const VectorAssembler &va, ValueModeType mode,
                                       const UnknownNumberingScheme &s, Domain *domain, FloatArray *eNorms = NULL);
    void assembleVectorFromElements(FloatArray &answer, TimeStep *tStep, const VectorAssembler &va, ValueModeType mode,
                                    const UnknownNumberingScheme &s, Domain *domain, FloatArray *eNorms = NULL);

    void assembleVectorFromBC(FloatArray &answer, TimeStep *tStep, const VectorAssembler &va, ValueModeType mode,
                              const UnknownNumberingScheme &s, Domain *domain, FloatArray *eNorms = NULL);

    void assembleExtrapolatedForces(FloatArray &answer, TimeStep *tStep, CharType type, Domain *domain);
 
    void assemblePrescribedExtrapolatedForces(FloatArray &answer, TimeStep *tStep, CharType type, Domain *domain);
    
 
#ifdef __MPM_MODULE
    std :: vector < std :: unique_ptr< Integral > > & giveIntegralList() {
        return this->integralList;
    }
    void addIntegral (std :: unique_ptr< Integral > obj) {
        integralList.push_back(std::move(obj));
    }
    // Needed for some of the boost-python bindings. NOTE: This takes ownership of the pointers, so it's actually completely unsafe.
    void py_addIntegral(Integral *obj) {
        std::size_t size = integralList.size();
        integralList.resize(size+1);
        integralList[size].reset(obj);
    }
    const Variable* giveVariableByName (std::string name) {
        if(variableMap.find(name)==variableMap.end()) OOFEM_ERROR("Unknown MPM variable '%s'",name.c_str());
        return variableMap[name].get();
        
    }
    const Term* giveTerm (int indx) {
        // @BP: add better error handling than provided by at()
        if(indx<1 || (int)termList.size()<indx) OOFEM_ERROR("MPM term number %d outside of valid range 1..%d",indx,(int)termList.size());
        return termList[indx-1].get();
    }   
    int instanciateMPM (DataReader &dr, InputRecord &ir);
    // end mpm experimental
#endif
 
protected:
    virtual void packMigratingData(TimeStep *tStep) { }
    virtual void unpackMigratingData(TimeStep *tStep) { }
 
public:
    virtual int checkConsistency() { return 1; }
    virtual int checkProblemConsistency();
    virtual void init();
    virtual void postInitialize();
    virtual void printOutputAt(FILE *file, TimeStep *tStep);
    virtual void printOutputAt(FILE *file, TimeStep *tStep, const IntArray &nodeSets, const IntArray &elementSets);
    void outputNodes(FILE *file, Domain &domain, TimeStep *tStep, int setNum);
    void outputElements(FILE *file, Domain &domain, TimeStep *tStep, int setNum);
 
    // input / output
    void printYourself();

    virtual void printDofOutputAt(FILE *stream, Dof *iDof, TimeStep *tStep);
 
 
    // identification
    virtual const char *giveClassName() const = 0;
    virtual int useNonlocalStiffnessOption() { return 0; }
    bool isParallel() const { return ( parallelFlag != 0 ); }
    int giveRank() const { return rank; }
    int giveNumberOfProcesses() const { return numProcs; }
 

    virtual fMode giveFormulation() { return nonLinFormulation; }
    /*
     * Returns Load Response Mode of receiver.
     * This value indicates, whether nodes and elements should assemble
     * total or incremental load vectors.
     *
     * virtual LoadResponseMode giveLoadResponseMode () {return TotalLoad;}
     */
    EngngModelContext *giveContext() { return this->context; }
    virtual int giveNumberOfSlaveProblems() { return 0; }
    virtual EngngModel *giveSlaveProblem(int i) { return NULL; }

    virtual bool giveEquationScalingFlag() { return false; }
    virtual double giveVariableScale(VarScaleType varId) { return 1.0; }
 

    virtual int estimateMaxPackSize(IntArray &commMap, DataStream &buff, int packUnpackType) { return 0; }
#ifdef __MPI_PARALLEL_MODE
    virtual void balanceLoad(TimeStep *tStep);
    virtual LoadBalancer *giveLoadBalancer() { return NULL; }
    virtual LoadBalancerMonitor *giveLoadBalancerMonitor() { return NULL; }
#endif
    void initParallel();
    EngngModel *giveEngngModel() { return this; }
    virtual bool isElementActivated( int elemNum ) { return true; }
    virtual bool isElementActivated( Element *e ) { return true; }
    TimeStepController* giveTimeStepController() { return this->timeStepController.get(); }
 
#ifdef __OOFEG
    virtual void drawYourself(oofegGraphicContext &gc);
    virtual void drawElements(oofegGraphicContext &gc);
    virtual void drawNodes(oofegGraphicContext &gc);
    virtual void showSparseMtrxStructure(int type, oofegGraphicContext &gc, TimeStep *tStep) { }
#endif
 
#ifdef _PYBIND_BINDINGS
    void setNumberOfDomains(const int& i) {this->ndomains=i;}
    const int& getNumberOfDomains() const {return this->ndomains;}
#endif

    std :: string errorInfo(const char *func) const;
};
} // end namespace oofem
#endif // engngm_h