Textile.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 "Yarn.h"
#include "PropertiesTextile.h"
namespace TexGen
{ 
    class CDomain;
    class CTextileWeave;
    class CTextile3DWeave;
    class CTextileLayered;
    class CTextileOrthogonal;
    class CTextileLayerToLayer;
    class CTextileDecoupledLToL;
    class CTextileAngleInterlock;
    class CTextileWeave2D;
 
    using namespace std;
 
    class CLASS_DECLSPEC CTextile : public CPropertiesTextile
    {
    public:
        CTextile(void);
        CTextile(const vector<CYarn> &Yarns);
        CTextile(const CTextile &CopyMe);
        CTextile(TiXmlElement &Element);
        virtual ~CTextile(void);
 
        // NOTE: IF DERIVING FROM THIS CLASS BE SURE TO IMPLEMENT THIS FUNCTION
        virtual CTextile* Copy() const { return new CTextile(*this); }
 
        virtual string GetType() const { return "CTextile"; }
 
        CTextile &operator=(const CTextile& CopyMe);
 
        virtual void PopulateTiXmlElement(TiXmlElement &Element, OUTPUT_TYPE OutputType);
 
        int AddYarn(const CYarn &Yarn);
 
 
        bool DeleteYarn(int iIndex);
 
        void DeleteYarns();
 
        void AddNodesToMesh(CMesh &Mesh);
 
        void AddPathToMesh(CMesh &Mesh);
 
 
        void AddSurfaceToMesh(CMesh &Mesh, bool bTrimToDomain = false);
 
 
        bool AddSurfaceToMesh(CMesh &Mesh, vector<CMesh> &DomainMeshes, bool bTrimToDomain = false);
 
 
        void AddVolumeToMesh(vector<CMesh> &YarnMeshes, bool bTrimToDomain = false);
 
        
        void AddVolumeToMesh(CMesh &Mesh, bool bTrimToDomain = false);
 
 
        void AddCentrePlaneToMesh(CMesh &Mesh, bool bTrimToDomain = false);
 
/*      /// Create Mesh and output to abaqus file format
        bool OutputAbaqus(string FileName, double dInitialStrains = 0);*/
 
 
        void GetPointInformation(const vector<XYZ> &Points, vector<POINT_INFO> &PointsInfo, double dTolerance = 1e-9);
 
 
        void GetPointInformation(const vector<XYZ> &Points, vector<POINT_INFO> &PointsInfo, int iYarn, double dTolerance = 1e-9, bool bSurface = false);
 
 
        void SavePointInformationToVTK(string Filename, const CMesh &Mesh, double dTolerance = 1e-9);
 
 
        double GetApproximateSize();
 
        int DetectInterference(vector<float> &DistanceToSurface, vector<int> &YarnIndex, bool bTrimToDomain, CMesh *pInterferingPoints = NULL );
 
        void Rotate(WXYZ Rotation, XYZ Origin = XYZ(0,0,0));
 
        void Translate(XYZ Vector);
 
 
        virtual string GetDefaultName() const { return "Textile"; }
 
        string GetName() const;
 
        void AssignDomain(const CDomain &Domain);
 
        void RemoveDomain();
 
        bool SetResolution(int Resolution);
 
 
 
 
        double GetYarnLength(string Units = "m");
 
 
        double GetYarnLengthPerUnitArea(string Units = "/m");
 
 
        double GetYarnVolume(string Units = "m^3");
 
 
        double GetYarnVolumePerUnitArea(string Units = "m");
 
 
        double GetFibreVolume(string Units = "m^3");
 
 
        double GetFibreVolumePerUnitArea(string Units = "m");
 
 
        double GetFibreYarnVolumeFraction();
 
 
        double GetQuickDomainVolumeFraction();
 
        double GetDomainVolumeFraction();
 
        void SetAllYarnsYoungsModulusX( double dValue, string Units = "MPa");
        void SetAllYarnsYoungsModulusY( double dValue, string Units = "MPa");
        void SetAllYarnsYoungsModulusZ( double dValue, string Units = "MPa");
        void SetAllYarnsShearModulusXY(double dValue, string Units = "MPa");
        void SetAllYarnsShearModulusXZ(double dValue, string Units = "MPa");
        void SetAllYarnsShearModulusYZ(double dValue, string Units = "MPa");
        void SetAllYarnsAlphaX( double dValue, string Units = "/K");
        void SetAllYarnsAlphaY( double dValue, string Units = "/K");
        void SetAllYarnsAlphaZ( double dValue, string Units = "/K");
        void SetAllYarnsPoissonsRatioX(double dValue);
        void SetAllYarnsPoissonsRatioY(double dValue);
        void SetAllYarnsPoissonsRatioZ(double dValue);
 
        bool ConvertToInterpNodes() const;
 
 
 
        CTextileWeave* GetWeave();
        CTextileWeave2D* GetWeave2D();
        CTextile3DWeave* Get3DWeave();
        CTextileOrthogonal* GetOrthogonalWeave();
        CTextileLayered* GetLayeredTextile();
        CTextileLayerToLayer* GetLayerToLayerWeave();
        CTextileDecoupledLToL * GetDecoupledLToLWeave();
        CTextileAngleInterlock* GetAngleInterlockWeave();
 
        // Accessor methods
        int GetNumYarns() const;
        const CYarn *GetYarn(int iIndex) const;
        CYarn *GetYarn(int iIndex);
        const vector<CYarn> &GetYarns() const;
        vector<CYarn> &GetYarns();
        const CDomain* GetDomain() const {return m_pDomain;}
        CDomain* GetDomain() {return m_pDomain;}
 
    protected:
 
        bool BuildTextileIfNeeded() const;
 
 
        virtual bool BuildTextile() const { return true; }
 
        void CleanUp();
 
        int AddYarn(const CYarn &Yarn) const;
 
 
        mutable vector<CYarn> m_Yarns;
 
 
        mutable bool m_bNeedsBuilding;
 
        CObjectContainer<CDomain> m_pDomain;
    };
};  // namespace TexGen