SpeciesHandler.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 "SpeciesHandler.h"
#include "DPMBase.h"

#include "Species/LinearViscoelasticSpecies.h"
#include "Species/LinearPlasticViscoelasticSpecies.h"
#include "Species/LinearViscoelasticFrictionSpecies.h"
#include "Species/LinearViscoelasticSlidingFrictionSpecies.h"
#include "Species/LinearPlasticViscoelasticFrictionSpecies.h"
#include "Species/LinearPlasticViscoelasticSlidingFrictionSpecies.h"

#include "Species/LinearViscoelasticIrreversibleAdhesiveSpecies.h"
#include "Species/LinearPlasticViscoelasticIrreversibleAdhesiveSpecies.h"
#include "Species/LinearViscoelasticFrictionIrreversibleAdhesiveSpecies.h"
#include "Species/LinearViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies.h"
#include "Species/LinearPlasticViscoelasticFrictionIrreversibleAdhesiveSpecies.h"
#include "Species/LinearPlasticViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies.h"

#include "Species/LinearViscoelasticReversibleAdhesiveSpecies.h"
#include "Species/LinearPlasticViscoelasticReversibleAdhesiveSpecies.h"
#include "Species/LinearViscoelasticFrictionReversibleAdhesiveSpecies.h"
#include "Species/LinearViscoelasticSlidingFrictionReversibleAdhesiveSpecies.h"
#include "Species/LinearPlasticViscoelasticFrictionReversibleAdhesiveSpecies.h"
#include "Species/LinearPlasticViscoelasticSlidingFrictionReversibleAdhesiveSpecies.h"

#include "Species/LinearViscoelasticFrictionLiquidBridgeWilletSpecies.h"

SpeciesHandler::SpeciesHandler()
{
    logger(DEBUG, "SpeciesHandler::SpeciesHandler() finished");
}

SpeciesHandler::SpeciesHandler(const SpeciesHandler& other)
{
    clear();
    setDPMBase(other.getDPMBase());
    copyContentsFromOtherHandler(other);
    for (BaseSpecies* mixSpec : other.mixedObjects_) 
    {
      mixedObjects_.push_back(mixSpec->copy());
      mixedObjects_.back()->setHandler(this);
    }
    logger(DEBUG, "SpeciesHandler::SpeciesHandler(const SpeciesHandler &other) finished");
}

SpeciesHandler SpeciesHandler::operator =(const SpeciesHandler& rhs)
{
    if (this != &rhs)
    {
        clear();
        copyContentsFromOtherHandler(rhs);
        for (BaseSpecies* mixSpec : mixedObjects_)
        {
            delete mixSpec;
        }
        mixedObjects_.clear();
        for (BaseSpecies* mixSpec : rhs.mixedObjects_) 
        {
            mixedObjects_.push_back(mixSpec->copy());
            mixedObjects_.back()->setHandler(this);
        }
    }

    logger(DEBUG, "SpeciesHandler SpeciesHandler::operator =(const SpeciesHandler& rhs)");
    return *this;
}
SpeciesHandler::~SpeciesHandler()
{
    clear(); //this deletes everything that comes from the BaseHandler.
    /*for (BaseSpecies* o : mixedObjects_)
    {
        delete o;
    }*/
    for (BaseSpecies* mixSpec : mixedObjects_)
    {
        delete mixSpec;
    }
    mixedObjects_.clear();
    logger(DEBUG, "SpeciesHandler::~SpeciesHandler() finished");
}
void SpeciesHandler::readObject(std::istream& is)
{
    std::string type;
    is >> type;
    if (type == "LinearViscoelasticSpecies")
    {
        LinearViscoelasticSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticSpecies")
    {
        LinearPlasticViscoelasticSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticSlidingFrictionSpecies")
    {
        LinearViscoelasticSlidingFrictionSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticSlidingFrictionSpecies")
    {
        LinearPlasticViscoelasticSlidingFrictionSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticFrictionSpecies")
    {
        LinearViscoelasticFrictionSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticFrictionSpecies")
    {
        LinearPlasticViscoelasticFrictionSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticIrreversibleAdhesiveSpecies")
    {
        LinearViscoelasticIrreversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticIrreversibleAdhesiveSpecies")
    {
        LinearPlasticViscoelasticIrreversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies")
    {
        LinearViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies")
    {
        LinearPlasticViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticFrictionIrreversibleAdhesiveSpecies")
    {
        LinearViscoelasticFrictionIrreversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticFrictionIrreversibleAdhesiveSpecies")
    {
        LinearPlasticViscoelasticFrictionIrreversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }        
    else if (type == "LinearViscoelasticReversibleAdhesiveSpecies")
    {
        LinearViscoelasticReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticReversibleAdhesiveSpecies")
    {
        LinearPlasticViscoelasticReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticSlidingFrictionReversibleAdhesiveSpecies")
    {
        LinearViscoelasticSlidingFrictionReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticSlidingFrictionReversibleAdhesiveSpecies")
    {
        LinearPlasticViscoelasticSlidingFrictionReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticFrictionReversibleAdhesiveSpecies")
    {
        LinearViscoelasticFrictionReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearPlasticViscoelasticFrictionReversibleAdhesiveSpecies")
    {
        LinearPlasticViscoelasticFrictionReversibleAdhesiveSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "LinearViscoelasticFrictionLiquidBridgeWilletSpecies")
    {
        LinearViscoelasticFrictionLiquidBridgeWilletSpecies species;
        is >> species;
        copyAndAddObject(species);
    }
    else if (type == "k") //for backwards compatibility
    {
        addObject(readOldObject(is));
    }
    else
    {        
        std::stringstream line(std::stringstream::in | std::stringstream::out);
        helpers::getLineFromStringStream(is, line);
        logger(ERROR, "Species type % not understood in restart file. %", type, line.str());
    }

    //remove the default mixed species
    for (unsigned int i = 0; i + 1 < getNumberOfObjects(); i++)
    {
        delete mixedObjects_.back();
        mixedObjects_.pop_back();
    }

    //Read the mixed species.
    for (unsigned int i = 0; i+1 < getNumberOfObjects(); i++)
    {
        is >> type;
        if (type == "LinearViscoelasticMixedSpecies")
        {
            LinearViscoelasticMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticMixedSpecies")
        {
            LinearPlasticViscoelasticMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticSlidingFrictionMixedSpecies")
        {
            LinearViscoelasticSlidingFrictionMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticSlidingFrictionMixedSpecies")
        {
            LinearPlasticViscoelasticSlidingFrictionMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticFrictionMixedSpecies")
        {
            LinearViscoelasticFrictionMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticFrictionMixedSpecies")
        {
            LinearPlasticViscoelasticFrictionMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticIrreversibleAdhesiveMixedSpecies")
        {
            LinearViscoelasticIrreversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticIrreversibleAdhesiveMixedSpecies")
        {
            LinearPlasticViscoelasticIrreversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticSlidingFrictionIrreversibleAdhesiveMixedSpecies")
        {
            LinearViscoelasticSlidingFrictionIrreversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticSlidingFrictionIrreversibleAdhesiveMixedSpecies")
        {
            LinearPlasticViscoelasticSlidingFrictionIrreversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticFrictionIrreversibleAdhesiveMixedSpecies")
        {
            LinearViscoelasticFrictionIrreversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticFrictionIrreversibleAdhesiveMixedSpecies")
        {
            LinearPlasticViscoelasticFrictionIrreversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }        
        else if (type == "LinearViscoelasticReversibleAdhesiveMixedSpecies")
        {
            LinearViscoelasticReversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticReversibleAdhesiveMixedSpecies")
        {
            LinearPlasticViscoelasticReversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticSlidingFrictionReversibleAdhesiveMixedSpecies")
        {
            LinearViscoelasticSlidingFrictionReversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticSlidingFrictionReversibleAdhesiveMixedSpecies")
        {
            LinearPlasticViscoelasticSlidingFrictionReversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearViscoelasticFrictionReversibleAdhesiveMixedSpecies")
        {
            LinearViscoelasticFrictionReversibleAdhesiveMixedSpecies species;
            is >> species;
            mixedObjects_.push_back(species.copy());
        }
        else if (type == "LinearPlasticViscoelasticFrictionReversibleAdhesiveMixedSpecies")
        {
            LinearPlasticViscoelasticFrictionReversibleAdhesiveMixedSpecies species;
            is >> species;
        }
        else if (type == "LinearViscoelasticFrictionLiquidBridgeWilletMixedSpecies")
        {
            LinearViscoelasticFrictionLiquidBridgeWilletMixedSpecies species;
            is >> species;
        }
        else if (type == "k") //for backwards compatibility
        {
            mixedObjects_.push_back(readOldObject(is));
        }
        else
        {
            logger(ERROR, "Species type: % not understood in restart file", type);
        }
    }
}

ParticleSpecies* SpeciesHandler::readOldObject(std::istream& is)
{
    //read in next line
    std::stringstream line(std::stringstream::in | std::stringstream::out);
    helpers::getLineFromStringStream(is, line);

    //read each property
    std::string property;
    unsigned int particleDimension=0;
    Mdouble density=0.0, stiffness=0.0, dissipation=0.0, slidingFrictionCoefficient=0.0, slidingFrictionCoefficientStatic=0.0, slidingStiffness=0.0, slidingDissipation=0.0;
    line >> stiffness;
    while (true)
    {
        line >> property;
        if (property == "disp")
            line >> dissipation;
        else if (property == "rho")
            line >> density;
        else if (property == "kt")
            line >> slidingStiffness;
        else if (property == "dispt")
            line >> slidingDissipation;
        else if (property == "mu")
            line >> slidingFrictionCoefficient;
        else if (property == "mus")
            line >> slidingFrictionCoefficientStatic;
        else if (property == "dim_particle")
        {
            line >> particleDimension;
            getDPMBase()->setParticleDimensions(particleDimension);
        }
        else if (property == "(mixed)")
        {
            density = 0;
        }
        else
        {
            logger(WARN, "Warning: % is not a species property", property);
            break;
        }
        if (line.eof())
            break;
    }

    //create the correct species
    if (slidingFrictionCoefficient == 0.0)
    {
        LinearViscoelasticSpecies* species = new LinearViscoelasticSpecies;
        species->setDensity(density);
        species->setStiffness(stiffness);
        species->setDissipation(dissipation);
        return species;
    }
    else
    {
        LinearViscoelasticSlidingFrictionSpecies* species = new LinearViscoelasticSlidingFrictionSpecies;
        species->setDensity(density);
        species->setStiffness(stiffness);
        species->setDissipation(dissipation);
        species->setSlidingStiffness(slidingStiffness);
        species->setSlidingDissipation(slidingDissipation);
        species->setSlidingFrictionCoefficient(slidingFrictionCoefficient);
        if (slidingFrictionCoefficientStatic == 0.0)
            slidingFrictionCoefficientStatic = slidingFrictionCoefficient;
        species->setSlidingFrictionCoefficientStatic(slidingFrictionCoefficientStatic);
        return species;
    }
}

unsigned int SpeciesHandler::getMixedId(const unsigned int id1, const unsigned int id2) const
{
    unsigned int maxId = std::max(id1,id2);
    return (maxId*(maxId-1))/2 + std::min(id1,id2);
}

template<class U> typename U::MixedSpeciesType* SpeciesHandler::getMixedObject(const U* S, const U* T)
{
    return dynamic_cast<typename U::MixedSpeciesType*>(getMixedObject(S->getIndex(),T->getIndex()));
}

const std::vector<BaseSpecies*>& SpeciesHandler::getMixedObjects() const
{
    return mixedObjects_;
}

BaseSpecies* SpeciesHandler::getMixedObject(const unsigned int id1, const unsigned int id2)
{
    if (id1 == id2)
    {
      return getObject(id1);
    }
    else
    {
        if (std::max(id1,id2) >= getNumberOfObjects())
        {
            logger(ERROR, "In: Object* SpeciesHandler::getMixedObject(const unsigned int id) const. No Object exist with index %, number of objects is %", std::max(id1, id2), getNumberOfObjects());
            return nullptr;
        }
        else
        {
            return mixedObjects_[getMixedId(id1,id2)];
        }        
    }
}
void SpeciesHandler::addObject(ParticleSpecies* const S)
{
    BaseHandler<ParticleSpecies>::addObject(S);
    //logger(INFO, "Part / Mix: % / %", objects_.size(), mixedObjects_.size());
    for (unsigned int id = 0; id + 1 < getNumberOfObjects(); ++id)
    {
        mixedObjects_.push_back(S->copyMixed());
        mixedObjects_.back()->setIndex(id);
        mixedObjects_.back()->setId(getNumberOfObjects()-1);
        mixedObjects_.back()->mixAll(S,getObject(id));
    }
    S->setHandler(this);
    getDPMBase()->particleHandler.computeAllMasses(S->getIndex());
    getDPMBase()->setRotation(useAngularDOFs());
    getDPMBase()->setRotation(useAngularDOFs());
}

void SpeciesHandler::removeObject(unsigned const int id)
{
    BaseHandler<ParticleSpecies>::removeObject(id);
    for (unsigned int id2 = 0; id2 < getNumberOfObjects(); ++id2)
    {
        mixedObjects_.erase(mixedObjects_.begin()+getMixedId(id, id2));
    }
    getDPMBase()->setRotation(useAngularDOFs());
}
void SpeciesHandler::write(std::ostream& os) const
{
    os << "Species " << getNumberOfObjects() << std::endl;
    std::vector<BaseSpecies*>::const_iterator it2 = mixedObjects_.begin();
    for (std::vector<ParticleSpecies*>::const_iterator it = begin(); it != end(); ++it)
    {
        os << (**it) << std::endl;
        for (unsigned int id2 =0; id2 < (*it)->getIndex(); id2++)
        {
            os << (**it2) << std::endl;
            it2++;
        }
    }
    /*
    This behaves like the code above but is actually readable
    @weinhartt is there a reason?
    
    there is a reason. Curernt architecture does not allow this
    \todo define new restart format. @dducks
    
    The code is written such that it writes PS0, then PS1 and MS01, then PS2 and 
    MS02, MS12, and so on (PS=ParticleSpecies, MS=MixedSpecies). We can change 
    the restart format, but we should write the read(os) function such that 
    it can also read the old format @weinhartt
    
    for (ParticleSpecies * spec : objects_) {
      os << *spec << std::endl;
    }
    for (BaseSpecies * spec : mixedObjects_) {
       os << *spec << std::endl;
    }
    */
}
std::string SpeciesHandler::getName() const
{
    return "SpeciesHandler";
}

bool SpeciesHandler::useAngularDOFs()
{
    for (unsigned int i = 0; i < getNumberOfObjects(); i++)
    {
        if (getObject(i)->getUseAngularDOFs())
            return true;
        for (unsigned int j = 0; j + 1 < i; j++)
        {
            if (getMixedObject(i, j)->getUseAngularDOFs())
                return true;
        }
    }
    return false;
}

//instantiate templated functions
//template<class U> typename U::MixedSpeciesType* SpeciesHandler::getMixedObject(const U* S, const U* T)

template LinearViscoelasticSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearViscoelasticSpecies*,const LinearViscoelasticSpecies*);
template LinearPlasticViscoelasticSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearPlasticViscoelasticSpecies*,const LinearPlasticViscoelasticSpecies*);
template LinearViscoelasticSlidingFrictionSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearViscoelasticSlidingFrictionSpecies*,const LinearViscoelasticSlidingFrictionSpecies*);
template LinearPlasticViscoelasticSlidingFrictionSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearPlasticViscoelasticSlidingFrictionSpecies*,const LinearPlasticViscoelasticSlidingFrictionSpecies*);
template LinearViscoelasticFrictionSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearViscoelasticFrictionSpecies*,const LinearViscoelasticFrictionSpecies*);
template LinearPlasticViscoelasticFrictionSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearPlasticViscoelasticFrictionSpecies*,const LinearPlasticViscoelasticFrictionSpecies*);

template LinearViscoelasticIrreversibleAdhesiveSpecies::MixedSpeciesType * SpeciesHandler::getMixedObject(const LinearViscoelasticIrreversibleAdhesiveSpecies*,const LinearViscoelasticIrreversibleAdhesiveSpecies*);
template LinearPlasticViscoelasticIrreversibleAdhesiveSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearPlasticViscoelasticIrreversibleAdhesiveSpecies*,const LinearPlasticViscoelasticIrreversibleAdhesiveSpecies*);
template LinearViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies*,const LinearViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies*);
template LinearPlasticViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearPlasticViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies*,const LinearPlasticViscoelasticSlidingFrictionIrreversibleAdhesiveSpecies*);
template LinearViscoelasticFrictionIrreversibleAdhesiveSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearViscoelasticFrictionIrreversibleAdhesiveSpecies*,const LinearViscoelasticFrictionIrreversibleAdhesiveSpecies*);
template LinearPlasticViscoelasticFrictionIrreversibleAdhesiveSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearPlasticViscoelasticFrictionIrreversibleAdhesiveSpecies*,const LinearPlasticViscoelasticFrictionIrreversibleAdhesiveSpecies*);

template LinearViscoelasticReversibleAdhesiveSpecies::MixedSpeciesType * SpeciesHandler::getMixedObject(const LinearViscoelasticReversibleAdhesiveSpecies*,const LinearViscoelasticReversibleAdhesiveSpecies*);
template LinearPlasticViscoelasticReversibleAdhesiveSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearPlasticViscoelasticReversibleAdhesiveSpecies*,const LinearPlasticViscoelasticReversibleAdhesiveSpecies*);
template LinearViscoelasticSlidingFrictionReversibleAdhesiveSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearViscoelasticSlidingFrictionReversibleAdhesiveSpecies*,const LinearViscoelasticSlidingFrictionReversibleAdhesiveSpecies*);
template LinearPlasticViscoelasticSlidingFrictionReversibleAdhesiveSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearPlasticViscoelasticSlidingFrictionReversibleAdhesiveSpecies*,const LinearPlasticViscoelasticSlidingFrictionReversibleAdhesiveSpecies*);
template LinearViscoelasticFrictionReversibleAdhesiveSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearViscoelasticFrictionReversibleAdhesiveSpecies*,const LinearViscoelasticFrictionReversibleAdhesiveSpecies*);
template LinearPlasticViscoelasticFrictionReversibleAdhesiveSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearPlasticViscoelasticFrictionReversibleAdhesiveSpecies*,const LinearPlasticViscoelasticFrictionReversibleAdhesiveSpecies*);

template LinearViscoelasticFrictionLiquidBridgeWilletSpecies::MixedSpeciesType* SpeciesHandler::getMixedObject(const LinearViscoelasticFrictionLiquidBridgeWilletSpecies*,const LinearViscoelasticFrictionLiquidBridgeWilletSpecies*);