HertzianSinterNormalSpecies.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 "HertzianSinterNormalSpecies.h"
#include "Interactions/NormalForceInteractions/HertzianSinterInteraction.h"
#include "BaseHandler.h"
#include "Species/ParticleSpecies.h"
#include <assert.h>
class BaseParticle;
class BaseInteractable;

HertzianSinterNormalSpecies::HertzianSinterNormalSpecies()
{
    loadingModulus_ = 0.0;
    unloadingModulusMax_ = 0.0;
    cohesionModulus_ = 0.0;
    penetrationDepthMax_ = 0.0;
    dissipation_ = 0.0;
    sinterRate_ = 0.0;
#ifdef DEBUG_CONSTRUCTOR
    std::cout<<"HertzianSinterNormalSpecies::HertzianSinterNormalSpecies() finished"<<std::endl;
#endif
}

HertzianSinterNormalSpecies::HertzianSinterNormalSpecies(const HertzianSinterNormalSpecies &p)
{
    loadingModulus_ = p.loadingModulus_;
    unloadingModulusMax_ = p.unloadingModulusMax_;
    cohesionModulus_ = p.cohesionModulus_;
    penetrationDepthMax_ = p.penetrationDepthMax_;
    dissipation_ = p.dissipation_;
    sinterRate_ = p.sinterRate_;
#ifdef DEBUG_CONSTRUCTOR
    std::cout<<"HertzianSinterNormalSpecies::HertzianSinterNormalSpecies(const HertzianSinterNormalSpecies &p) finished"<<std::endl;
#endif
}

HertzianSinterNormalSpecies::~HertzianSinterNormalSpecies()
{
#ifdef DEBUG_DESTRUCTOR
    std::cout<<"HertzianSinterNormalSpecies::~HertzianSinterNormalSpecies() finished"<<std::endl;
#endif   
}

void HertzianSinterNormalSpecies::write(std::ostream& os) const
{
    os  << " loadingModulus " << loadingModulus_;
    os  << " maxUnloadingModulus " << unloadingModulusMax_;
    os  << " cohesionModulus " << cohesionModulus_;
    os  << " maxPenetration " << penetrationDepthMax_;
    os  << " dissipation " << dissipation_;
    os  << " sinterRate " << sinterRate_;
}

void HertzianSinterNormalSpecies::read(std::istream& is)
{
    std::string dummy;
    is >> dummy >> loadingModulus_;
    is >> dummy >> unloadingModulusMax_;
    is >> dummy >> cohesionModulus_;
    is >> dummy >> penetrationDepthMax_;
    is >> dummy >> dissipation_;
    is >> dummy >> sinterRate_;
}

std::string HertzianSinterNormalSpecies::getBaseName() const
{
    return "HertzianSinter";
}

void HertzianSinterNormalSpecies::mix(HertzianSinterNormalSpecies* const S, HertzianSinterNormalSpecies* const T)
{
    loadingModulus_ = average(S->getLoadingModulus(), T->getLoadingModulus());
    unloadingModulusMax_ = average(S->getUnloadingModulusMax(), T->getUnloadingModulusMax());
    cohesionModulus_ = average(S->getCohesionModulus(), T->getCohesionModulus());
    penetrationDepthMax_ = average(S->getPenetrationDepthMax(), T->getPenetrationDepthMax());
    dissipation_ = average(S->getDissipation(), T->getDissipation());
    sinterRate_ = average(S->getSinterRate(), T->getSinterRate());
}

void HertzianSinterNormalSpecies::setPlasticParameters (Mdouble loadingModulus, Mdouble unloadingModulusMax, Mdouble cohesionModulus, Mdouble penetrationDepthMax)
{
    if (loadingModulus <= 0 || unloadingModulusMax <= 1.000001*(loadingModulus+cohesionModulus) || cohesionModulus < 0 || penetrationDepthMax < 0)
    {
        std::cerr << "Error: arguments of setPlasticParameters do not make sense" << std::endl;
        exit(-1);
    }
    setLoadingModulus(loadingModulus);
    setUnloadingModulusMax(unloadingModulusMax);
    setCohesionModulus(cohesionModulus);
    setPenetrationDepthMax(penetrationDepthMax);
}

Mdouble HertzianSinterNormalSpecies::getLoadingModulus() const
{
    return loadingModulus_;
}

Mdouble HertzianSinterNormalSpecies::getUnloadingModulusMax() const
{
    return unloadingModulusMax_;
}

Mdouble HertzianSinterNormalSpecies::getCohesionModulus() const
{
    return cohesionModulus_;
}

Mdouble HertzianSinterNormalSpecies::getPenetrationDepthMax() const
{
    return penetrationDepthMax_;
}

void HertzianSinterNormalSpecies::setLoadingModulus(Mdouble loadingModulus)
{
    loadingModulus_ = loadingModulus;
}

void HertzianSinterNormalSpecies::setUnloadingModulusMax(Mdouble unloadingModulusMax)
{
    unloadingModulusMax_ = unloadingModulusMax;
}

void HertzianSinterNormalSpecies::setCohesionModulus(Mdouble cohesionModulus)
{
    cohesionModulus_ = cohesionModulus;
}

void HertzianSinterNormalSpecies::setPenetrationDepthMax(Mdouble penetrationDepthMax)
{
    penetrationDepthMax_ = penetrationDepthMax;
}

Mdouble HertzianSinterNormalSpecies::computeTimeStep(Mdouble mass)
{
//    if (stiffnessMax / (.5 * mass) < mathsFunc::square(dissipation_ /mass)) {
//        std::cerr << "Dissipation too high; max. allowed " << sqrt(2.0 * stiffnessMax * mass) << std::endl;
//        return 0.02 * constants::pi / std::sqrt(2.0*stiffnessMax / mass);
//    } else {
    std::cerr << "Warning: Dissipation is not taken into account when computing the time step"  << std::endl;
    ParticleSpecies* p=dynamic_cast<ParticleSpecies*>(this);
    assert(p);
    Mdouble radius = cbrt(mass*3./(4.*constants::pi*p->getDensity()));
    return 0.02 * constants::pi / std::sqrt(2.0*getUnloadingModulusMax()*getPenetrationDepthMax()*radius / mass);
}

void HertzianSinterNormalSpecies::setDissipation(Mdouble dissipation)
{
    if (dissipation >= 0)
    {
        dissipation_ = dissipation;
    }
    else
    {
        std::cerr << "Error in setDissipation(" << dissipation << ")" << std::endl;
        exit(-1);
    }
}

void HertzianSinterNormalSpecies::setSinterRate(Mdouble sinterRate)
{
    if (sinterRate >= 0)
    {
        sinterRate_ = sinterRate;
    }
    else
    {
        std::cerr << "Error in setSinterRate(" << sinterRate << ")" << std::endl;
        exit(-1);
    }
}

Mdouble HertzianSinterNormalSpecies::getDissipation() const
{
    return dissipation_;
}

Mdouble HertzianSinterNormalSpecies::getSinterRate() const
{
    return sinterRate_;
}