SimulationAbaqus.h

Go to the documentation of this file.

/*=============================================================================
TexGen: Geometric textile modeller.
Copyright (C) 2006 Martin Sherburn
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
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 General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
=============================================================================*/
 
#pragma once
 
#include "Simulation.h"
#include "Materials.h"
 
namespace TexGen
{ 
    using namespace std;
 
    class CTextileWeave;
    class CTextile3DWeave;
    class CDomain;
    class CMaterial;
 
    struct ELEMENT_INDICES
    {
        CMesh::ELEMENT_TYPE ElementType;
        vector<int>         Index;
    };
 
    class CLASS_DECLSPEC CSimulationAbaqus : public CSimulation
    {
    public:
        CSimulationAbaqus(void);
        virtual ~CSimulationAbaqus(void);
 
        bool CreateAbaqusInputFile(CTextile &Textile, string Filename, bool bRegenerateMesh, int iElementType = 0, bool bAdjustMesh = false, double Tolerance = 0.0000001 );
 
        void SetIncludePlates(bool bInclude) { m_bIncludePlates = bInclude; }
        bool GetIncludePlates() { return m_bIncludePlates; }
 
        void SetInitialPlateGap(double dPlateGap) { m_dInitialPlateGap = dPlateGap; }
        double GetInitialPlateGap() { return m_dInitialPlateGap; }
 
        void SetWholeSurfaces(bool bWholeSurface ) { m_bWholeSurfaces = bWholeSurface; }
        bool GetWholeSurfaces() { return m_bWholeSurfaces; }
 
 
        void SetYarnSurfaceInteraction(string AbaqusCommands);
 
        void SetPlateSurfaceInteraction(string AbaqusCommands);
        
        void SetStaticStepParameters(double dInitTimeInc = 0, double dTimePeriod = 0, double dMinTimeInc = 0, double dMaxTimeInc = 0);
 
    protected:
        enum SET_TYPE
        {
            NODE_SET,
            ELEMENT_SET,
        };
 
        enum SURFACE_TYPE
        {
            SURFACE_UPPER,
            SURFACE_LOWER,
            SURFACE_ALL
        };
 
        struct ELEMENT_FACE
        {
            int iYarn;
            CMesh::ELEMENT_TYPE ElementType;
            int iElementIndex;
            int iFaceIndex;
        };
 
        /*struct ELEMENT_INDICES
        {
            CMesh::ELEMENT_TYPE ElementType;
            vector<int>         Index;
        };*/
 
        struct INTERSECTION_DATA
        {
        double  Depth;
        XYZ     Point;
        XYZ     InterpPoint;
        int     Yarn;
        int     Index;
        vector<ELEMENT_INDICES> Elements;
        };
 
        struct SECTION_VF_DATA
        {
            int iMin;
            int iMax;
            double dVolumeFraction;
        };
 
        
 
        class CSurfaceInteraction
        {
        public:
            virtual CSurfaceInteraction* Copy() const = 0;
            virtual string GetAbaqusCommands() = 0;
        };
 
        class CKeywordInteraction : public CSurfaceInteraction
        {
        public:
            CKeywordInteraction() {}
            CKeywordInteraction(string AbaqusCommands):m_AbaqusCommands(AbaqusCommands){}
            CSurfaceInteraction* Copy() const { return new CKeywordInteraction(*this); }
            string GetAbaqusCommands() { return m_AbaqusCommands; }
            void SetAbaqusCommands(string AbaqusCommands) { m_AbaqusCommands = AbaqusCommands; }
        protected:
            string m_AbaqusCommands;
        };
 
        void CreateMaterials(ostream &Output, string Filename);
 
        
        void CreateContact(ostream &Output, string Name1, string Name2, string InteractionName);
 
 
        void CreateSet(ostream &Output, SET_TYPE Type, string Name, vector<int> &Indices, bool bUnSorted = false);
 
        void CreateSet(ostream &Output, string Name, const vector<pair<int, int> > &NodePairs);
 
 
        void CreateSurfaces(ostream &Output, map<string, vector<ELEMENT_FACE> > &SurfaceDefinitions);
 
        void CreateSurfaceDefinitions( int iNumYarns, const vector<XYZ> &Repeats, map<string, vector<ELEMENT_FACE> > &SurfaceDefinitions);
 
 
        void CreateContacts(ostream &Output, const CTextile &Textile);
 
        void CreateContacts(ostream &Output, const CTextileWeave &Weave);
 
        void OutputContacts( ostream &Output, set<pair<int, int> > &Contacts );
 
        void CreateContacts(ostream &Output, const CTextile3DWeave &Weave);
 
        void CreateCompressionPlates(ostream &Output);
 
        void CreatePeriodicBoundaries(ostream &Output, const CDomain &Domain);
 
        void CreateStep(ostream &Output);
 
        void CreateBoundary(ostream &Output, CLinearTransformation Deformation, const vector<int> &YarnCenterNodes, const vector<XYZ> &Repeats);
 
 
        int GetFaceIndex(CMesh::ELEMENT_TYPE ElemType, const set<int> &NodeIndices);
 
 
        void GetYarnSurfaces(int iYarn, const vector<XYZ> &Repeats, vector<ELEMENT_FACE> &UpperFaces, vector<ELEMENT_FACE> &LowerFaces );
 
 
        void GetYarnSurface(int iYarn, const vector<XYZ> &Repeats, vector<ELEMENT_FACE> &Faces );
 
 
        ELEMENT_FACE FindFaceIndex(int iYarn, const vector<int> &SurfIndices);
 
 
        set<int> GetCommonIndices(const vector<int> &SurfIndices, const vector<int> &VolIndices);
 
        int GetCenterNode(const CMesh &Mesh);
 
        void BuildIndexOffsets();
 
        int GetGlobalElementIndex(int iYarn, CMesh::ELEMENT_TYPE ElemType, int iIndex);
 
        int GetGlobalElementIndex(ELEMENT_FACE Face);
 
        int GetGlobalNodeIndex(int iYarn, int iIndex);
 
        double GetSectionArea( vector<int> &Section, CMesh &Mesh );
 
        double GetSectionVolumeFraction( double Area, CTextile &Textile, int Yarn );
 
        void CreateMidPointVolumeFractions( vector<SECTION_VF_DATA> &VFData, vector<SECTION_VF_DATA> &VFMidData );
 
        void GetElementVolumeFractions( vector<POINT_INFO> &ElementsInfo, vector<SECTION_VF_DATA> &MidVFData );
 
        void GetSectionVolumeFractions(CTextile &Textile, vector<SECTION_VF_DATA> &VolFractionData, int iYarn );
 
        
 
        vector<CMesh> m_YarnMeshes;
        CMesh m_TextileMesh;
        typedef int YarnNumber;
        map<YarnNumber, map<CMesh::ELEMENT_TYPE, int> > m_ElementIndexOffsets;
        map<YarnNumber, int> m_NodeIndexOffsets;
        int m_iTotalNumNodes;       // This is including any dummy nodes created for whatever purposes
        bool m_bIncludePlates;
        XYZ m_TopPlatePos;
        XYZ m_BottomPlatePos;
        double m_dInitialPlateGap;
        bool m_bWholeSurfaces;
        
        CTextileMaterials m_Materials;
        
        string m_StaticStepParameters;
        CObjectContainer<CSurfaceInteraction> m_YarnInteraction;
        CObjectContainer<CSurfaceInteraction> m_PlateInteraction;
    };
};  // namespace TexGen