domain.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 domain_h
#define domain_h
 
#include "oofemenv.h"
#include "domaintype.h"
#include "statecountertype.h"
#include "parametermanager.h"
#include "intarray.h"
#include "error.h"
#include "bctracker.h"
#include "inputrecord.h"
 
#ifdef __MPI_PARALLEL_MODE
 #include "entityrenumberingscheme.h"
#endif
 
#include <memory>
#include <unordered_map>
#include <map>
#include <string>
#include <list>


#define _IFT_Domain_type "domain" 
#define _IFT_Domain_ndofman "ndofman"
#define _IFT_Domain_nelem "nelem"
#define _IFT_Domain_nmat "nmat"
#define _IFT_Domain_ncrosssect "ncrosssect"
#define _IFT_Domain_nbc "nbc"
#define _IFT_Domain_nic "nic"
#define _IFT_Domain_nfunct "nltf"
#define _IFT_Domain_nset "nset"
#define _IFT_Domain_nbarrier "nbarrier"
#define _IFT_Domain_topology "topology"
#define _IFT_Domain_nxfemman "nxfemman" 
#define _IFT_Domain_ncontactsurf "ncontactsurf"
#define _IFT_Domain_numberOfSpatialDimensions "nsd" 
#define _IFT_Domain_nfracman "nfracman" 
#define _IFT_Domain_axisymmetric "axisymm" 
 
namespace oofem {
class Element;
class Node;
class Material;
class GeneralBoundaryCondition;
class InitialCondition;
class Load;
class Function;
class CrossSection;
class ElementSide;
class DofManager;
class OutputManager;
class EngngModel;
class ConnectivityTable;
class ErrorEstimator;
class SpatialLocalizer;
class NodalRecoveryModel;
class NonlocalBarrier;
class DomainTransactionManager;
class XfemManager;
class TopologyDescription;
class DataReader;
class Set;
class ContactSurface;
class FractureManager;
class oofegGraphicContext;
class ProcessCommunicator;
 

class OOFEM_EXPORT Domain
{
    public:
    std :: vector< std :: unique_ptr< Element > > elementList;
    std :: vector< std :: unique_ptr< DofManager > > dofManagerList;
    std :: vector< std :: unique_ptr< CrossSection > > crossSectionList;    
    ParameterManager elementPPM;
    ParameterManager dofmanPPM;
 
private:
    std :: vector< std :: unique_ptr< Material > > materialList;
    std :: vector< std :: unique_ptr< GeneralBoundaryCondition > > bcList;
    std :: vector< std :: unique_ptr< InitialCondition > > icList;
    std :: vector< std :: unique_ptr< Function > > functionList;
    std :: vector< std :: unique_ptr< Set > > setList;
    std::vector< std::unique_ptr< ContactSurface > >contactSurfaceList;
    std :: vector< std :: unique_ptr< NonlocalBarrier > > nonlocalBarrierList;

    IntArray defaultNodeDofIDArry;

    domainType dType;

    EngngModel *engineeringModel;

    std :: unique_ptr< ConnectivityTable > connectivityTable;
    std :: unique_ptr< SpatialLocalizer > spatialLocalizer;
    std :: unique_ptr< OutputManager > outputManager;
    int number;
    int serialNumber;
    int nsd;
    bool axisymm;
    std :: unique_ptr< NodalRecoveryModel > smoother; 
 
    std :: string mDomainType;
    StateCounterType nonlocalUpdateStateCounter;
    std :: unique_ptr< XfemManager > xfemManager;

    std :: unique_ptr< FractureManager > fracManager;
 
 

    BCTracker bcTracker;
    
    // elementGlobal2LocalMap
    std::unordered_map< int, int > elementGlobal2LocalMap;

    std::unordered_map< int, int > dofmanGlobal2LocalMap;

    std::unordered_map< int, IntArray> materialNum2ElMap;

    std :: unique_ptr< TopologyDescription > topology;
 
public:
    int freeDofID;
private:
 
#ifdef __MPI_PARALLEL_MODE
    std :: unique_ptr< DomainTransactionManager > transactionManager;
    std :: map< int, DofManager * >dmanMap;
    bool dmanMapInitialized;
    std :: map< int, Element * >elementMap;
    bool elementMapInitialized;
 


    std :: list< Element * >recvElemList; 
#endif
 
public:
    Domain(int n, int serNum, EngngModel * e);
 
    Domain(const Domain& src) = delete;
    Domain &operator = (const Domain &src) = delete;

    ~Domain();

    int giveNumber() { return this->number; }
    void setNumber(int nn) { this->number = nn; }
    int giveSerialNumber() { return this->serialNumber; }
 
    // management of the mesh components
    Element *giveElement(int n);
    std :: vector< std :: unique_ptr< Element > > &giveElements() { return this->elementList; }
    Element *giveGlobalElement(int n);
    int giveElementPlaceInArray(int iGlobalElNum) const;
    int giveDofManPlaceInArray(int iGlobalDofManNum) const;
    const IntArray &giveElementsWithMaterialNum(int iMaterialNum) const;

    ContactSurface *giveContactSurface(int n);
    std::vector< std::unique_ptr< ContactSurface > > &giveContactSurface() { return this->contactSurfaceList; }
 
 
 
    
    EngngModel *giveEngngModel();
 
    void SetEngngModel(EngngModel *ipEngngModel) {engineeringModel = ipEngngModel;}

    Load *giveLoad(int n);
    GeneralBoundaryCondition *giveBc(int n);
    std :: vector< std :: unique_ptr< GeneralBoundaryCondition > > &giveBcs() { return this->bcList; }
    InitialCondition *giveIc(int n);
    std :: vector< std :: unique_ptr< InitialCondition > > &giveIcs() { return this->icList; }

    Function *giveFunction(int n);
    std :: vector< std :: unique_ptr< Function > > &giveFunctions() { return this->functionList; }
    Material *giveMaterial(int n);
    std :: vector< std :: unique_ptr< Material > > &giveMaterials() { return this->materialList; }
    CrossSection *giveCrossSection(int n);
    std :: vector< std :: unique_ptr< CrossSection > > &giveCrossSections() { return this->crossSectionList; }
    NonlocalBarrier *giveNonlocalBarrier(int n);
    Set *giveSet(int n);
    std :: vector< std :: unique_ptr< Set > > &giveSets() { return this->setList; }
    inline Node *giveNode(int n)
    {
    #ifdef DEBUG
        if ( n < 1 || n > (int)dofManagerList.size() ) {
            OOFEM_ERROR("undefined dofManager (%d)", n);
        }
 
        Node *node = reinterpret_cast< Node * >( dofManagerList[n-1].get() );
 
        return node;
 
    #else
        return reinterpret_cast< Node * >( dofManagerList[n-1].get() );
    #endif
    }

    ElementSide *giveSide(int n);
    DofManager *giveDofManager(int n);
    std :: vector< std :: unique_ptr< DofManager > > &giveDofManagers() { return this->dofManagerList; }
    DofManager *giveGlobalDofManager(int n);
    int instanciateYourself(DataReader &dr);
    int instanciateYourself(DataReader &dr, InputRecord& ir);
    void initializeFinish();
    void postInitialize();
    void createDofs();
    int giveNumberOfDofManagers() const { return (int)dofManagerList.size(); }
    int giveNumberOfElements() const { return (int)elementList.size(); }
    int giveNumberOfMaterialModels() const { return (int)materialList.size(); }
    int giveNumberOfCrossSectionModels() const { return (int)crossSectionList.size(); }
    int giveNumberOfBoundaryConditions() const { return (int)bcList.size(); }
    int giveNumberOfInitialConditions() const { return (int)icList.size(); }
    int giveNumberOfFunctions() const { return (int)functionList.size(); }
    int giveNumberOfRegions() const { return this->giveNumberOfCrossSectionModels(); }
    int giveNumberOfNonlocalBarriers() const { return (int)nonlocalBarrierList.size(); }
    int giveNumberOfSets() const { return (int)setList.size(); }
    int giveNumberOfContactSurfaces() const { return ( int ) contactSurfaceList.size(); }

    int giveNumberOfSpatialDimensions();
    bool isAxisymmetric();

    void resizeDofManagers(int _newSize);
    void resizeElements(int _newSize);
    void resizeCrossSectionModels(int _newSize);
    void resizeMaterials(int _newSize);
    void resizeNonlocalBarriers(int _newSize);
    void resizeBoundaryConditions(int _newSize);
    void resizeInitialConditions(int _newSize);
    void resizeFunctions(int _newSize);
    void resizeSets(int _newSize);
    void resizeContactSurfaces(int _newSize);


    void py_setDofManager(int i, DofManager *obj);
    void py_setElement(int i, Element *obj);
    void py_setCrossSection(int i, CrossSection *obj);
    void py_setMaterial(int i, Material *obj);
    void py_setNonlocalBarrier(int i, NonlocalBarrier *obj);
    void py_setBoundaryCondition(int i, GeneralBoundaryCondition *obj);
    void py_setInitialCondition(int i, InitialCondition *obj);
    void py_setFunction(int i, Function *obj);
    void py_setSet(int i, Set *obj);

    void setDofManager(int i, std::unique_ptr<DofManager> obj);
    void setElement(int i, std::unique_ptr<Element> obj);
    void setCrossSection(int i, std::unique_ptr<CrossSection> obj);
    void setMaterial(int i, std::unique_ptr<Material> obj);
    void setNonlocalBarrier(int i, std::unique_ptr<NonlocalBarrier> obj);
    void setBoundaryCondition(int i, std::unique_ptr<GeneralBoundaryCondition> obj);
    void setInitialCondition(int i, std::unique_ptr<InitialCondition> obj);
    void setFunction(int i, std::unique_ptr<Function> obj);
    void setSet(int i, std::unique_ptr<Set> obj);

    void setXfemManager(std::unique_ptr<XfemManager> ipXfemManager);
 
    XfemManager *giveXfemManager();
    bool hasXfemManager();
   
    FractureManager *giveFractureManager();
    bool hasFractureManager();
 
    BCTracker *giveBCTracker();
    
    void setTopology(TopologyDescription *topo, bool destroyOld = true);
    void clearBoundaryConditions();
    void clearElements();
    void clear();

    void saveContext(DataStream &stream, ContextMode mode);
    void restoreContext(DataStream &stream, ContextMode mode);
    const IntArray &giveDefaultNodeDofIDArry();
    domainType giveDomainType() { return dType; }
    void setDomainType(domainType _dType) { this->dType = _dType; }
    int checkConsistency();

    double giveArea();
    double giveVolume();
    double giveSize();

    int giveNextFreeDofID(int increment = 1);
    void resetFreeDofID();
    int giveMaxDofID() { return this->freeDofID - 1; }
 
    void setNextFreeDofID(int dofid){ this->freeDofID = dofid;}

    ConnectivityTable *giveConnectivityTable();
    SpatialLocalizer *giveSpatialLocalizer();
    
    void setSpatialLocalizer(std::unique_ptr<SpatialLocalizer> sl);
    OutputManager *giveOutputManager();
    ErrorEstimator *giveErrorEstimator();
    NodalRecoveryModel *giveSmoother();
    TopologyDescription *giveTopology();
    void setSmoother(NodalRecoveryModel *newSmoother, bool destroyOld = true);
 
#ifdef __MPI_PARALLEL_MODE

    DomainTransactionManager *giveTransactionManager();
    int commitTransactions(DomainTransactionManager *tm);

    void initGlobalDofManMap(bool forceinit = false);
    void initGlobalElementMap(bool forceinit = false);
    void renumberDofManagers();
    void renumberDofManData(DomainTransactionManager *tm);
    void renumberElements();
    void renumberElementData(DomainTransactionManager *tm);
    int LB_giveUpdatedLocalNumber(int oldnum, EntityRenumberingScheme scheme);
    int LB_giveUpdatedGlobalNumber(int oldnum, EntityRenumberingScheme scheme);
 

    int dofmanGlobal2Local(int _globnum);
    int elementGlobal2Local(int _globnum);
#endif

    const char *giveClassName() const { return "Domain"; }

    StateCounterType giveNonlocalUpdateStateCounter() { return this->nonlocalUpdateStateCounter; }
    void setNonlocalUpdateStateCounter(StateCounterType val) { this->nonlocalUpdateStateCounter = val; }
 
    void resolveDomainDofsDefaults(const char *);
 
private:
    std :: string errorInfo(const char *func) const;
 
private:
    void BuildElementPlaceInArrayMap();

    void BuildDofManPlaceInArrayMap();

    void BuildMaterialToElementMap();
};
} // end namespace oofem
#endif // domain_h