Class_Intersection_2D.tpp

// =================================================================================== //
// CLASS SPECIALIZATION                                                                //
// =================================================================================== //

template<>
class Class_Intersection<2> {
    // ------------------------------------------------------------------------------- //
    // FRIENDSHIPS ------------------------------------------------------------------- //
    template<int dim> friend class Class_Local_Tree;
    template<int dim> friend class Class_Para_Tree;

    // ------------------------------------------------------------------------------- //
    // TYPEDEFS ----------------------------------------------------------------------- //
public:
    typedef vector<uint32_t>            u32vector;
    typedef vector<vector<uint32_t> >   u32vector2D;
    typedef vector<vector<uint64_t> >   u64vector2D;

    // ------------------------------------------------------------------------------- //
    // MEMBERS ----------------------------------------------------------------------- //
private:
    uint32_t    owners[2];          
    uint8_t     iface;              
    bool        finer;              
    //TODO proposta: eliminare isghost, contiene la stessa info in pbound
    bool        isghost;            
    bool        isnew;              
    bool        bound;              
    bool        pbound;             
    // ------------------------------------------------------------------------------- //
    // CONSTRUCTORS AND OPERATORS----------------------------------------------------- //

public:
    Class_Intersection(){
        owners[0] = 0;
        owners[1] = 0;
        iface = 0;
        isnew = false;
        isghost = false;
        finer = 0;
        bound = pbound = false;
    };
    ~Class_Intersection(){};
    Class_Intersection(const Class_Intersection<2> & intersection){
        owners[0] = intersection.owners[0];
        owners[1] = intersection.owners[1];
        iface = intersection.iface;
        isnew = intersection.isnew;
        isghost = intersection.isghost;
        finer = intersection.finer;
        bound = intersection.bound;
        pbound = intersection.pbound;
    };
    Class_Intersection<2>& operator =(const Class_Intersection<2> & intersection){
        owners[0] = intersection.owners[0];
        owners[1] = intersection.owners[1];
        iface = intersection.iface;
        isnew = intersection.isnew;
        isghost = intersection.isghost;
        finer = intersection.finer;
        bound = intersection.bound;
        pbound = intersection.pbound;
        return *this;
    };
    bool operator ==(const Class_Intersection<2> & intersection){
        bool check = true;
        check = check && (owners[0] == intersection.owners[0]);
        check = check && (owners[1] == intersection.owners[1]);
        check = check && (iface == intersection.iface);
        check = check && (isnew == intersection.isnew);
        check = check && (isghost == intersection.isghost);
        check = check && (finer == intersection.finer);
        check = check && (bound == intersection.bound);
        check = check && (pbound == intersection.pbound);
        return check;

    };

    // ------------------------------------------------------------------------------- //
    // METHODS ----------------------------------------------------------------------- //

    // Basic Get/Set methods --------------------------------------------------------- //
private:
    uint32_t getOut(){                      // Get the owner with exiting normal
        return owners[0];
    };
    uint32_t getIn(){                       // Get the owner with entering normal
        return owners[1];
    };
    void getNormal(int8_t normal[2]){       // Get the normal of the intersection
        for (int i=0; i<2; i++){
            normal[i] = global2D.normals[iface][i];
        }
    };
    bool getBound(){
        return bound;
    }

    bool getIsGhost(){
        return isghost;
    }

    bool getPbound(){
        return pbound;
    }
}; // end of Class_Intersection_2D.tpp