engngm.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2013   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 "oofemcfg.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 "problemmode.h"
#include "fmode.h"
#include "dofiditem.h"
#include "contextoutputmode.h"
#include "contextfilemode.h"
#include "contextioresulttype.h"
#include "metastep.h"
#include "parallelcontext.h"

#ifdef __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;

    problemMode pMode;
    problemScale pScale;
    time_t startTime;

    EngngModel *master;

    EngngModelContext *context;
    EngngModelTimer timer;
    int parallelFlag;
    enum fMode nonLinFormulation;
    ErrorEstimator *defaultErrEstimator;

    int rank;
    int numProcs;
    int nonlocalExt;
#ifdef __PARALLEL_MODE
    char processor_name [ PROCESSOR_NAME_LENGTH ];
 #ifdef __USE_MPI
    MPI_Comm comm;
 #endif

    LoadBalancer *lb;
    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;

    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; }
    virtual MaterialInterface *giveMaterialInterface(int n) { return NULL; }
    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() { return contextOutputMode; }
    int giveContextOutputStep() { return contextOutputStep; }
    void setContextOutputMode(ContextOutputMode contextMode)
    { contextOutputMode = contextMode; }
    void setUDContextOutputMode(int cStep)
    {
        contextOutputMode = COM_UserDefined;
        contextOutputStep = cStep;
    }
    void setProblemMode(problemMode pmode) { pMode = pmode; }
    void setParallelMode(bool newParallelFlag);
    problemMode giveProblemMode() { return pMode; }
    void setProblemScale(problemScale pscale) { pScale = pscale; }
    problemScale giveProblemScale() { 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 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();}


    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 __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 IRResultType 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);
    virtual contextIOResultType saveContext(DataStream &stream, ContextMode mode);
    virtual contextIOResultType 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();
        }
    }
    virtual TimeStep *givePreviousStep(bool force = false) {
        if ( master && (!force)) {
            return master->givePreviousStep();
        } else {
            return previousStep.get();
        }
    }
    virtual TimeStep *giveNextStep() { return NULL; }
    TimeStep* generateNextStep();
    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 nMetaSteps; }
    MetaStep *giveMetaStep(int i);
    int giveNumberOfSteps(bool force = false) {
        if ( master && (!force)) {
            return master->giveNumberOfSteps();
        } else {
            return numberOfSteps;
        }
    }
    virtual double giveEndOfTimeOfInterest() { return 0.; }
    int giveNumberOfTimeStepWhenIcApply() { return 0; }
    virtual NumericalMethod *giveNumericalMethod(MetaStep *mStep) { return NULL; }
    ExportModuleManager *giveExportModuleManager() { return exportModuleManager; }
    EngngModelTimer *giveTimer() { return & timer; }

    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 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 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);
    

    void assembleVectorFromContacts(FloatArray &answer, TimeStep *tStep, CharType type, ValueModeType mode,
                                    const UnknownNumberingScheme &s, Domain *domain, FloatArray *eNorms = NULL);

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 __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; }

    

#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

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