PossibleContact.h

Go to the documentation of this file.

// This file is part of the MercuryDPM project (https://www.mercurydpm.org).
// Copyright (c), The MercuryDPM Developers Team. All rights reserved.
// License: BSD 3-Clause License; see the LICENSE file in the root directory.
 
#ifndef POSSIBLECONTACT_H
#define POSSIBLECONTACT_H
 
#include "Particles/BaseParticle.h"
#include "Logger.h"
 
class PossibleContact
{
public:
    PossibleContact()
    {
        P1_ = nullptr;
        P2_ = nullptr;
        Next_ = nullptr;
        Prev_ = nullptr;
        Next1_ = nullptr;
        Prev1_ = nullptr;
        Next2_ = nullptr;
        Prev2_ = nullptr;
        index_ = 0;
    }
    
    PossibleContact(BaseParticle* P1, BaseParticle* P2)
    {
        P1_ = P1;
        P2_ = P2;
        Next_ = nullptr;
        Prev_ = nullptr;
        Next1_ = nullptr;
        Prev1_ = nullptr;
        Next2_ = nullptr;
        Prev2_ = nullptr;
        index_ = 0;
    }
    
    PossibleContact(BaseParticle* P1, BaseParticle* P2, PossibleContact* Next)
    {
        P1_ = P1;
        P2_ = P2;
        Next_ = Next;
        Prev_ = nullptr;
        if (Next != nullptr)
            index_ = Next->getIndex() + 1;
        else
            index_ = 0;
        
        Next1_ = nullptr;
        Prev1_ = nullptr;
        Next2_ = nullptr;
        Prev2_ = nullptr;
    }
    
    PossibleContact(BaseParticle* P1, BaseParticle* P2, PossibleContact* Next, PossibleContact* Next1,
                    PossibleContact* Next2)
    {
        P1_ = P1;
        P2_ = P2;
        Next_ = Next;
        Next1_ = Next1;
        Next2_ = Next2;
        Prev_ = 0;
        Prev1_ = 0;
        Prev2_ = 0;
        if (Next != nullptr)
            index_ = Next->getIndex() + 1;
        else
            index_ = 0;
    }
    
    BaseParticle* getP1()
    {
        return P1_;
    }
    
    BaseParticle* getP2()
    {
        return P2_;
    }
    
    BaseParticle* getOtherParticle(BaseParticle* P)
    {
        if (P1_ == P)
            return P2_;
        else if (P2_ == P)
            return P1_;
        else
        {
            logger(WARN, "Particle* getOtherParticle(Particle *P), no match for % posibilities are % and %",
                   P->getIndex(), P1_->getIndex(), P2_->getIndex());
            return nullptr;
        }
    }
    
    PossibleContact* getNext()
    {
        return Next_;
    }
    
    PossibleContact* getNext(BaseParticle* P)
    {
        if (P1_ == P)
            return Next1_;
        else if (P2_ == P)
            return Next2_;
        else
        {
            logger(WARN, "PossibleContact* getNext(Particle* P), no match for %. Possibilities are % and %.",
                   P->getIndex(), P1_->getIndex(), P2_->getIndex());
            return nullptr;
        }
    }
    
    PossibleContact* getPrevious()
    {
        return Prev_;
    }
    
    PossibleContact* getPrevious(BaseParticle* P)
    {
        if (P1_ == P)
            return Prev1_;
        else if (P2_ == P)
            return Prev2_;
        else
        {
            logger(WARN, "PossibleContact* getPrevious(Particle* P), no match for %. Possibilities are % and %.",
                   P->getIndex(), P1_->getIndex(), P2_->getIndex());
            return nullptr;
        }
    }
    
    PossibleContact* getNext1()
    {
        return Next1_;
    }
    
    PossibleContact* getPrevious1()
    {
        return Prev1_;
    }
    
    PossibleContact* getNext2()
    {
        return Next2_;
    }
    
    PossibleContact* getPrevious2()
    {
        return Prev2_;
    }
    
    int getIndex()
    {
        return index_;
    }
    
    void setP1(BaseParticle* P1)
    {
        P1_ = P1;
    }
    
    void setP2(BaseParticle* P2)
    {
        P2_ = P2;
    }
    
    void setNextPosition(PossibleContact* Next)
    {
        Next_ = Next;
    }
    
    void setNextPosition(BaseParticle* P, PossibleContact* Next)
    {
        if (P1_ == P)
            Next1_ = Next;
        else if (P2_ == P)
            Next2_ = Next;
        else
            logger(WARN,
                   "void setNextPosition(Particle* P,PossibleContact* Next), no match for %. Possibilities are %  and % ",
                   P->getIndex(), P1_->getIndex(), P2_->getIndex());
    }
    
    void setPreviousPosition(PossibleContact* Prev)
    {
        Prev_ = Prev;
    }
    
    void setPreviousPosition(BaseParticle* P, PossibleContact* Prev)
    {
        if (P1_ == P)
            Prev1_ = Prev;
        else if (P2_ == P)
            Prev2_ = Prev;
        else
            logger(WARN,
                   "void setPreviousPosition(Particle* P,PossibleContact* Prev), no match for %. Possibilities are %  and % ",
                   P->getIndex(), P1_->getIndex(), P2_->getIndex());
    }
    
    void setNextPosition1(PossibleContact* Next1)
    {
        Next1_ = Next1;
    }
    
    void setPreviousPosition1(PossibleContact* Prev1)
    {
        Prev1_ = Prev1;
    }
    
    void setNextPosition2(PossibleContact* Next2)
    {
        Next2_ = Next2;
    }
    
    void setPreviousPosition2(PossibleContact* Prev2)
    {
        Prev2_ = Prev2;
    }
    
    friend std::ostream& operator<<(std::ostream& os, const PossibleContact& o)
    {
        os << o.index_ << " between (" << o.P1_->getIndex() << "," << o.P2_->getIndex() << ")";
        return os;
    }
 
private:
    int index_;
    BaseParticle* P1_;
    BaseParticle* P2_;
    PossibleContact* Next_;
    PossibleContact* Prev_;
    PossibleContact* Next1_;
    PossibleContact* Prev1_;
    PossibleContact* Next2_;
    PossibleContact* Prev2_;
    
};
 
#endif