PossibleContactList.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 POSSIBLECONTACTLIST_H
#define POSSIBLECONTACTLIST_H
 
#include "PossibleContact.h"
 
class PossibleContactList
{
public:
    
    PossibleContactList()
    {
        firstPossibleContact_ = nullptr;
        logger(DEBUG, "PossibleContactList() constructor finished.");
    }
    
    void add_PossibleContact(BaseParticle* P1, BaseParticle* P2)
    {
        firstPossibleContact_ = new PossibleContact(P1, P2, firstPossibleContact_, P1->getFirstPossibleContact(),
                                                    P2->getFirstPossibleContact());
        P1->setFirstPossibleContact(firstPossibleContact_);
        P2->setFirstPossibleContact(firstPossibleContact_);
        if (firstPossibleContact_->getNext())
            firstPossibleContact_->getNext()->setPreviousPosition(firstPossibleContact_);
        if (firstPossibleContact_->getNext1())
            firstPossibleContact_->getNext1()->setPreviousPosition(P1, firstPossibleContact_);
        if (firstPossibleContact_->getNext2())
            firstPossibleContact_->getNext2()->setPreviousPosition(P2, firstPossibleContact_);
        logger(VERBOSE, "Added new possible contact between particles % and % ", P1->getIndex(), P2->getIndex());
    }
    
    void remove_ParticlePosibleContacts(BaseParticle* P)
    {
        logger(VERBOSE, "Removing all contacts of particle %.", P->getIndex());
        //The BaseParticle that shares a PossibleContact with P.
        BaseParticle* O;
        //The next possible contact for P.
        PossibleContact* Next;
        //The current possible contact for P.
        PossibleContact* Curr = P->getFirstPossibleContact();
        while (Curr != nullptr)
        {
            logger(VERBOSE, "Removing possible contacts index = % between particles % and %.", Curr->getIndex(),
                   Curr->getP1()->getIndex(), Curr->getP2()->getIndex());
            Next = Curr->getNext(P);
            O = Curr->getOtherParticle(P);
            //Set the pointers of the next global possible contact.
            if (Curr->getNext())
                Curr->getNext()->setPreviousPosition(Curr->getPrevious());
            
            //Set the pointers of the previous possible contact.
            if (Curr->getPrevious())
                Curr->getPrevious()->setNextPosition(Curr->getNext());
            else
                firstPossibleContact_ = Curr->getNext();
            
            //Set the pointers of the other object of the possible contact.
            if (Curr->getNext(O))
                Curr->getNext(O)->setPreviousPosition(O, Curr->getPrevious(O));
            
            if (Curr->getPrevious(O))
                Curr->getPrevious(O)->setNextPosition(O, Curr->getNext(O));
            else
                O->setFirstPossibleContact(Curr->getNext(O));
            
            //Delete the possible contact and update the the pointer Curr to the
            //next possible contact with P.
            delete Curr;
            Curr = Next;
        }
        P->setFirstPossibleContact(nullptr);
    }
    
    void write(std::ostream& os) const
    {
        os << "Possible contacts are: " << std::endl;
        PossibleContact* it = firstPossibleContact_;
        while (it != nullptr)
        {
            os << *it << std::endl;
            it = it->getNext();
        }
    }
    
    PossibleContact* getFirstPossibleContact()
    {
        return firstPossibleContact_;
    }
 
private:
    PossibleContact* firstPossibleContact_;
    
};
 
#endif