PossibleContactList.h

Go to the documentation of this file.

//Copyright (c) 2013-2023, The MercuryDPM Developers Team. All rights reserved.
//For the list of developers, see <http://www.MercuryDPM.org/Team>.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name MercuryDPM nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//DISCLAIMED. IN NO EVENT SHALL THE MERCURYDPM DEVELOPERS TEAM BE LIABLE FOR ANY
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
#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