Shape.hxx

Go to the documentation of this file.

#ifndef _SHAPE_HXX_
#define _SHAPE_HXX_

#include <iostream>
#include <fstream>

#define EPSILON 1e-10 

#include "MureHeaders.hxx"
#include <vector>
#include <string>
using namespace std;


class Shape;
typedef Reference_ptr<Shape> Shape_ptr; 


class Shape : public TReference
{
 public :
    Shape(); 
    Shape(const Shape  &s); 
    virtual ~Shape(); 


    double  GetSigne(){return fSigne;} 
    void    SetSigne(double s){fSigne=s;} 

    void SetOutermostShape(bool flag=true){fOutermostShape = flag;}
    bool IsInfinite() {return fInfinite;} 


    virtual unsigned IsBrick()      {return 0;} 
    virtual unsigned IsCylinder()   {return 0;} 
    virtual unsigned IsFullVoid()   {return 0;} 
    virtual unsigned IsHexagon()    {return 0;} 
    virtual unsigned IsNode()         {return 0;} 
    virtual unsigned IsPlane()      {return 0;} 
    virtual unsigned IsSphere()     {return 0;} 
    virtual unsigned IsTube()         {return 0;} 
    virtual unsigned IsFull()       {return 0;} 
    virtual unsigned IsVoid()       {return 0;} 



    virtual double  GetVolume(){return fVolume;}

    virtual double  GetSurface(){return fSurface;}
    void            SetVolume(double V){fVolume=V;} 
    void            SetSurface(double S){fSurface=S;} 
    virtual void SetMirrorBoundary(bool state=true); 
    virtual void SetTopBottomPlanesOpen() {fOpenZPlanes=true;} 
    virtual bool GetTopBottomPlanesOpen() {return fOpenZPlanes;} 
    virtual void SetSidePlanesOpen() {fOpenXYPlanes=true;} 
    virtual bool GetSidePlanesOpen() {return fOpenXYPlanes;} 
    virtual void SetWhiteBoundary(bool state=true); 
    

    virtual void SetPeriodicBoundary(bool state=true,string TopBottPlaneBC="mirror");
    virtual bool IsMirrorBoundary(){return fMirrorBoundary;} 
    virtual bool IsWhiteBoundary(){return fWhiteBoundary;} 
    virtual bool IsPeriodicBoundary(){return fPeriodicBoundary;} 


    Shape_ptr Not(); 


    virtual void Rotate(double phi,double theta=0,double psi=0,double *center=0,int count=0){}

    virtual void Translate(double dx,double dy,double dz,int count=0){}

    void RotateVector(double *V,double phi,double theta=0,double psi=0);

    void RotatePoint(double *P,double phi,double theta=0,double psi=0,double *center=0);

    virtual unsigned Add(Shape_ptr OtherShape){return 0;}


    virtual unsigned Inclus(Shape_ptr OtherShape){return 0;} 
    

    virtual unsigned Disjoint(Shape_ptr OtherShape){return 0;}   

    virtual void    SetMouvement(bool state=true){fMouvement=state;} 
    virtual void    UnSetMouvement(); 
    bool            GetMouvement(){return fMouvement;} 
    

    virtual void Simplify(bool violent=false){} 

    virtual void DevElague(int count=0,bool violent=false){}  


    unsigned    AddInsideShape(Shape_ptr OtherShape);
    

    unsigned    AddOriginalInsideShape(Shape_ptr OtherShape) {fOriginalInsideShape.push_back(OtherShape); return 1;} 
    void        ClearOriginalInsideShape() {fOriginalInsideShape.clear();} 
    void        ClearInsideShape() {fInsideShape.clear();} 
    unsigned    GetInsideShapeSize() {return fInsideShape.size();} 
    unsigned    GetOriginalInsideShapeSize() {return fOriginalInsideShape.size();} 
    void        SetInsideShape(int i,Shape_ptr S) {fInsideShape[i]=S;} 
    void        SetOriginalInsideShape(int i,Shape_ptr S) {fOriginalInsideShape[i]=S;} 
    Shape_ptr   GetInsideShape(int i) {return fInsideShape[i];} 
    Shape_ptr   GetOriginalInsideShape(int i) {return fOriginalInsideShape[i];} 

    
    virtual string  Print(); 
    virtual string  PrintSurface(){return "";} 
    
    virtual Shape_ptr Clone(int count=0); 
    void    SetClone(Shape_ptr clone){fCloneShape=clone;} 
    void    SetClone2Not(); 
    
    virtual void Copy(Shape_ptr S){} 
    virtual Shape_ptr GetLeaf(int i) {Shape_ptr t(0);return t;} 
    virtual int GetNumberOfLeaves(){return 0;}
    
    void AddSurfaceNumber(int i) {return fSurfaceNumber.push_back(i);} 
    vector<int> GetSurfaceNumber(); 
    

    virtual void DefineSurface(){}
    virtual void AlreadyDefine(bool state=true); 
    

    virtual void    SetUniverse(int u=0);       
    virtual void    SetFill(int f){fFill=f;} 
    int     GetUniverse(){return fUniverse;} 
    int     GetFill(){return fFill;} 
    
    void    IncrementSurface(double S){fSurface+=S;} 

    virtual double  GetVirtualSphereRadius(){return fVirtualSphereR;}
    virtual double  *GetVirtualSphereCenter(){return fVirtualSphereO;}
    
    virtual void RemoveSurface();

    virtual void PrintX(int count=0); 
    virtual void PrintY(int count=0); 

#ifdef _PTODEBUG_
    virtual void PrintLatex(int count=0); 
    static  void AddLatexLine(char *txt){BeginLatex();DEBUGFILE<<txt<<"\\\\ "<<endl;} 
    static  void BeginLatex(); 
    static  void EndLatex(); 
#endif

    virtual void CalculNot() {} 
    void        NewNot(){if(fNot) CalculNot();} 
    

    virtual bool PointInShape(double *P,int border){return false;}
    virtual void SetLinkedPlane(Shape_ptr P){fLinkedPlane=P;} 
    virtual void ReplaceNode(Shape_ptr C){} 
    double PS(double *U,double *V); 
    string GetName(); 
    virtual int NumberOfShapes(){return 1;} 
    
    void SetZone(int z){fZone = z;} 
    int  GetZone(){return fZone;}

 
 protected :
    

    void SetNot(Shape* Not)
    {
        if(fNot) fNot->fNot=0;
        fNot=Not;
        fNot->fNot=this;
    }
    void SetNotofNot(){fNot->SetNot(this);} 


    void UpdateSurface(Surface* &S);

        
    vector<int>         fSurfaceNumber; 
    vector<Shape_ptr>   fInsideShape; 
    vector<Shape_ptr>   fOriginalInsideShape; 
                
    double  fSigne; 
     bool    fInfinite; 
    Shape   *fNot; 
    bool    fAlreadyDefine; 
    bool    fMouvement; 
    int     fUniverse; 
    int     fFill; 
    double  fVolume; 
    double  fSurface; 
    string  fName; 
    double  fVirtualSphereR;
    double* fVirtualSphereO;
    Shape_ptr   fCloneShape;
    bool    fMirrorBoundary; 
    bool    fOpenZPlanes; 
    bool    fOpenXYPlanes; 
    bool    fWhiteBoundary; 
    bool    fPeriodicBoundary; 
    string  fTopBottPlaneBoundaryCondition; 
    Shape_ptr   fLinkedPlane;
    
    bool fOutermostShape; 
    int  fZone; 
    
};


Shape_ptr operator&(Shape_ptr A,Shape_ptr B );
Shape_ptr & operator&=(Shape_ptr &A,Shape_ptr B );
Shape_ptr operator|(Shape_ptr A,Shape_ptr B );
Shape_ptr & operator|=(Shape_ptr &A,Shape_ptr B );
Shape_ptr & operator>>(Shape_ptr &B,Shape_ptr &A );

Shape_ptr operator!(Shape_ptr A);


#endif