MaserBoundary.cc

Go to the documentation of this file.

//Copyright (c) 2013-2014, 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.


#include "MaserBoundary.h"
#include "DPMBase.h"
#include "BoundaryHandler.h"
#include "ParticleHandler.h"
#include "Particles/BaseParticle.h"
#include "Species/ParticleSpecies.h"
#include <Logger.h>

MaserBoundary* MaserBoundary::copy() const
{
    return new MaserBoundary(*this);
}

void MaserBoundary::set(Vec3D normal, Mdouble distanceLeft, Mdouble distanceRight)
{
    // factor is used to set normal to unit length
    normal_ = normal;
    distanceLeft_ = distanceLeft;
    distanceRight_ = distanceRight;
    shift_ = normal_ * (distanceRight_ - distanceLeft_);
}

void MaserBoundary::read(std::istream& is)
{
    BaseBoundary::read(is);
}

void MaserBoundary::write(std::ostream& os) const
{
    BaseBoundary::write(os);
}

std::string MaserBoundary::getName() const
{
    return "MaserBoundary";
}

Mdouble MaserBoundary::getDistance(BaseParticle& p)
{
    return getDistance(p.getPosition());
}

Mdouble MaserBoundary::getDistance(const Vec3D& position)
{
    Mdouble distance = Vec3D::dot(position, normal_);

    if (distance - distanceLeft_ < distanceRight_ - distance)
    {
        closestToLeftBoundary_ = true;
        return distance - distanceLeft_;
    }
    else
    {
        closestToLeftBoundary_ = false;
        return distanceRight_ - distance;
    }
}

void MaserBoundary::shiftPosition(BaseParticle* p)
{
    if (closestToLeftBoundary_)
    {
        p->move(shift_);
        closestToLeftBoundary_ = false;
    }
    else // if closest to right boundary
    {
        p->move(-shift_);
        closestToLeftBoundary_ = true;
        
    }
}

void MaserBoundary::createPeriodicParticles(BaseParticle* p, ParticleHandler& pH)
{
    // check if particle is close to either of the boundary walls
    if (getDistance(*p) < p->getInteractionRadius() + pH.getLargestParticle()->getInteractionRadius() && !closestToLeftBoundary_)
    {
        auto conversion = speciesConversionMaserToNormal_.find(p->getSpecies());
        if (conversion != speciesConversionMaserToNormal_.end()) //Test if it is a maser particle
        {
            // Copy the particle if it IS a maser particle
            BaseParticle* F0 = p->copy();
            F0->copyInteractionsForPeriodicParticles(*p);
            
            // shift to the periodic location
            shiftPosition(F0);

            //Set the 'from' particle. If Particle is multiply shifted, get correct original particle
            BaseParticle* From = p;
            while (From->getPeriodicFromParticle() != nullptr)
            {
                From = From->getPeriodicFromParticle();
            }
            F0->setPeriodicFromParticle(From);
            
            // add the periodic particle to the handler
            pH.addObject(F0);
            
            if (closestToLeftBoundary_)
            {   
            }
            else
            {
            }
        }
    }
}

bool MaserBoundary::checkBoundaryAfterParticleMoved(BaseParticle* p, ParticleHandler& pH)
{
    // check if particle passed either of the boundary walls
    if (getDistance(*p) < 0)
    {
        // check if species is found in the list of maser particle species
        auto conversion = speciesConversionMaserToNormal_.find(p->getSpecies());
        if (conversion != speciesConversionMaserToNormal_.end()) //Test if it is a maser particle
        {
            
            // If particle is closest to the right particle, create a 'real' equivalent
            if (!closestToLeftBoundary_)
            {   
                //std::cout << "bleep!" << std::endl;
                BaseParticle pCopy = *p;
                //pCopy.setId(pCopy->getIndex());
                
                pCopy.setSpecies(conversion->second);
                
                pH.copyAndAddObject(pCopy);
//                std::cout << "new particle pos: " << pCopy->getPosition() << std::endl;
//                std::cout << "new particle vel: " << pCopy->getVelocity() << std::endl;
//                std::cout << "new particle forces: " << pCopy->getForce() << std::endl;
//                std::cout << "original particle id: " << P->getId() << std::endl;
//                
//                std::cout << "new particle idx: " << pCopy->getIndex() << std::endl;
//                std::cout << "new particle ine: " << pCopy->getInertia() << std::endl;
//                std::cout << "new particle mas: " << pCopy->getMass() << std::endl;
                logger(DEBUG, "size of ParticleHandler: %", pH.getNumberOfObjects());
                
                
//                std::cout << "new particle id:  " << pCopy->getId() << std::endl;
                
                //std::cout << "last particle pos: " << pH.getLastObject()->getPosition() << std::endl;
                //shiftPosition(pCopy);
            }

            // if maserparticle: shift it periodically!
            shiftPosition(p);
            
            /*
            // check if to be shifted leftward or rightward. Now done by MaserBoundary::shiftPosition().
            if (closestToLeftBoundary_)
            {
                P->move(shift_);
                closestToLeftBoundary_ = false;
            }
            else
            {
                P->move(-shift_);
                closestToLeftBoundary_ = true;
                //BaseParticle* pCopy = pH.copyAndAddObject(P);
                //pCopy->setIndSpecies(conversion->second);
            }
             */
            
        }
    }
    return false;
}

void MaserBoundary::addParticleToMaser(BaseParticle* p)
{
    // check if particle species already known by the maser
    auto conversion = speciesConversionNormalToMaser_.find(p->getSpecies());
    if (conversion == speciesConversionNormalToMaser_.end())
    {
        // nope: species has to be added to the list
        ParticleSpecies* newSpecies = getHandler()->getDPMBase()->speciesHandler.copyAndAddObject(p->getSpecies()->copy());
        speciesConversionNormalToMaser_.insert(std::pair<const ParticleSpecies*, const ParticleSpecies*>(p->getSpecies(), newSpecies));
        speciesConversionMaserToNormal_.insert(std::pair<const ParticleSpecies*, const ParticleSpecies*>(newSpecies, p->getSpecies()));
        logger(INFO,"[MaserBoundary::addParticleToMaser()] New species conversion created");
        logger(INFO, "Original species ID: %", p->getSpecies()->getId());
        
        // now the species IS added, so flag (convert) it!
        p->setSpecies(newSpecies);
    }
    else
    {
        // yep: species known and flagged (i.e. 'converted')
        logger(VERBOSE,"[MaserBoundary::addParticleToMaser()] Species conversion already present");
        p->setSpecies(conversion->second);
    }
}