void PCModelObject::setCloud(const PCPtr& nuCloud)
{
cloud = nuCloud;
computeBoundingBox(cloud, vMin, vMax);
setCenter(computeCentroid(cloud));
cloudScreenCoords = getScreenCoords(cloud);
}
bool Polygon::init(int vertexCount_, const Vertex *vertices_) {
// Rember the old obstate to restore it if an error occurs whilst initializing it with the new data
int oldvertexCount = this->vertexCount;
Vertex *oldvertices = this->vertices;
this->vertexCount = vertexCount_;
this->vertices = new Vertex[vertexCount_ + 1];
memcpy(this->vertices, vertices_, sizeof(Vertex) * vertexCount_);
// TODO:
// Duplicate and remove redundant vertecies (Superflous = 3 co-linear verts)
// _WeedRepeatedvertices();
// The first vertex is repeated at the end of the vertex array; this simplifies
// some algorithms, running through the edges and thus can save the overflow control.
this->vertices[vertexCount_] = this->vertices[0];
// If the polygon is self-intersecting, the object state is restore, and an error signalled
if (checkForSelfIntersection()) {
delete[] this->vertices;
this->vertices = oldvertices;
this->vertexCount = oldvertexCount;
// BS_LOG_ERROR("POLYGON: Tried to create a self-intersecting polygon.\n");
return false;
}
// Release old vertex list
delete[] oldvertices;
// Calculate properties of the polygon
_isCW = computeIsCW();
_centroid = computeCentroid();
return true;
}
Vector3d getCentroid() {
if (HaveCentroid_) {
return centroid_;
} else {
return computeCentroid();
}
}
void recomputeCentroid(cluster& cl) {
vector ¢roid = cl.centroid;
list<vector*> vectors;
for(int i=0; i<cl.members.size();i++)
vectors.add(&(cl.members.get(i)->v));
centroid.size = 0;
computeCentroid(centroid, vectors);
}
void ConfigStat::compute() {
deleteComputation();
initComputation();
computeDistanceMatrix();
computeCenter();
computeCentroid();
computeBetweennessCenter();
}
ConvexPolyhedronID createConvexPolyhedron( BodyStorage& globalStorage, BlockStorage& blocks, BlockDataID storageID,
id_t uid, Vec3 gpos, TriangleMesh mesh,
MaterialID material,
bool global, bool communicating, bool infiniteMass )
{
WALBERLA_ASSERT_UNEQUAL( ConvexPolyhedron::getStaticTypeID(), std::numeric_limits<id_t>::max(), "ConvexPolyhedron TypeID not initalized!");
ConvexPolyhedronID poly = nullptr;
Vec3 centroid = toWalberla( computeCentroid( mesh ) );
translate( mesh, -centroid );
gpos += centroid;
if (global)
{
const id_t sid = UniqueID<RigidBody>::createGlobal();
WALBERLA_CHECK_EQUAL(communicating, false, "Global bodies can not be communicating!" );
WALBERLA_CHECK_EQUAL(infiniteMass, true, "Global bodies must have infinite mass!" );
auto cp = std::make_unique<ConvexPolyhedron>(sid, uid, gpos, Vec3(0,0,0), Quat(), mesh, material, global, false, true);
poly = static_cast<ConvexPolyhedronID>(&globalStorage.add(std::move(cp)));
} else
{
for (auto& block : blocks){
if (block.getAABB().contains(gpos))
{
const id_t sid( UniqueID<RigidBody>::create() );
BodyStorage& bs = (*block.getData<Storage>(storageID))[0];
auto cp = std::make_unique<ConvexPolyhedron>(sid, uid, gpos, Vec3(0,0,0), Quat(), mesh, material, global, communicating, infiniteMass);
cp->MPITrait.setOwner(Owner(MPIManager::instance()->rank(), block.getId().getID()));
poly = static_cast<ConvexPolyhedronID>(&bs.add( std::move(cp) ) );
}
}
}
if (poly != nullptr)
{
// Logging the successful creation of the box
WALBERLA_LOG_DETAIL(
"Created ConvexPolyhedron " << poly->getSystemID() << "\n"
<< " User-ID = " << uid << "\n"
<< " Global position = " << gpos << "\n"
<< " Material = " << Material::getName( material )
);
}
return poly;
}
void detect2(Mat img, vector<Mat>& regionsOfInterest,vector<Blob>& blobs){
/* Mat blurred;
GaussianBlur(img, blurred, Size(), _SharpSigma, _SharpSigma);
Mat lowContrastMask = abs(img - blurred) < _SharpThreshold;
Mat sharpened = img*(1+_SharpAmount) + blurred*(-_SharpAmount);
img.copyTo(sharpened, lowContrastMask);
sharpened.copyTo(img);*/
/*************INIZIALIZZAZIONI**********/
Mat gray;
Mat out = Mat::zeros(Size(WIDTH,HEIGH), CV_8U);
Mat masked = Mat::zeros(Size(WIDTH,HEIGH), CV_8U);
Mat morph = Mat::zeros(Size(WIDTH,HEIGH), CV_8U);
Mat bwmorph = Mat::zeros(Size(WIDTH,HEIGH), CV_8U);
Mat cont = Mat::zeros(Size(WIDTH,HEIGH), CV_8U);
Mat maskHSV = Mat::zeros(Size(WIDTH,HEIGH), CV_8U);
Mat whiteMaskMasked = Mat::zeros(Size(WIDTH,HEIGH), CV_8U);
Mat whiteMaskOrig = Mat::zeros(Size(WIDTH,HEIGH), CV_8U);
Mat Bands[3];
Mat noBackMask = Mat::zeros(Size(WIDTH,HEIGH), CV_8U);
Mat kernelEr = getStructuringElement(MORPH_ELLIPSE,Size(5,5));
Mat thMasked; Mat thOrig; Mat bwOrig; Mat bwNoBackMask;
Mat kernelOp = getStructuringElement(MORPH_ELLIPSE,Size(13,13));
vector<Mat> BGRbands; split(img,BGRbands);
vector< vector<Point> > contours;
/***************************************/
/*cvtColor(img,gray,CV_BGR2GRAY);
gray = (gray!=0);
imshow("gray",gray);*/
/*Rimozione Ombre e Background*/
// masked = applyMaskBandByBand(maskHSV,BGRbands); split(masked,BGRbands);
/*Rimozione sfondo e sogliatura per videnziare esclusivamente ciò che è bianco*/
noBackMask = backgroundRemoval(img);
masked = applyMaskBandByBand(noBackMask,BGRbands);
/*
whiteMaskOrig = computeWhiteMaskLight(img);
whiteMaskOrig = whiteMaskOrig + computeWhiteMaskShadow(img);
whiteMaskMasked = computeWhiteMaskLight(masked);
whiteMaskMasked = whiteMaskMasked + computeWhiteMaskShadow(masked);
*/
CBlobResult blobsRs;
blobsRs = computeWhiteMaskOtsu(img, img, blobsRs, img.rows*img.cols, img.rows*img.cols, 0.8, 0.8, 30, 200, 0);
//Mat newimg(img.size(),img.type());
whiteMaskOrig.setTo(0);
for(int i=0;i<blobsRs.GetNumBlobs();i++){
blobsRs.GetBlob(i)->FillBlob(whiteMaskOrig,CV_RGB(255,255,255),0,0,true);
}
threshold(masked,whiteMaskMasked,0,255,THRESH_BINARY);
cvtColor(whiteMaskMasked,whiteMaskMasked,CV_BGR2GRAY);
cout << whiteMaskMasked.type() << " " << whiteMaskOrig.type() << endl;
bitwise_or(whiteMaskMasked,whiteMaskOrig,thOrig);
masked = applyMaskBandByBand(thOrig,BGRbands);
#if DO_MORPH
/*Operazioni morfologiche per poter riempire i buchi e rimuovere i bordi frastagliati*/
dilate(masked,morph,kernelEr);
erode(morph,morph,kernelEr);
erode(morph,morph,kernelOp);
dilate(morph,morph,kernelOp);
#else
morph = masked;
#endif
/*Ricerca componenti connesse e rimozione in base all'area*/
cvtColor(morph,bwmorph,CV_BGR2GRAY);
findContours(bwmorph, contours, CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
vector<double> areas = computeArea(contours);
for(int j = areas.size()-1; j>=0; j--){
if(areas.at(j)>MAX_AREA || areas.at(j)<MIN_AREA )
contours.erase(contours.begin()+j);
}
/*Calcolo Bounding Rectangle a partire dall'immagine con componenti connesse di interesse*/
vector<Rect> boundRect( contours.size() );
vector<vector<Point> > contours_poly( contours.size() );
vector<Point2f>center( contours.size() );
vector<float>radius( contours.size() );
/*Costruzione immagine finale ed estrazione regioni di interesse*/
for (int idx = 0; idx < contours.size(); idx++){
Blob b; b.originalImage = &img;
Scalar color(255);
approxPolyDP( Mat(contours[idx]), contours_poly[idx], 3, true );
boundRect[idx] = boundingRect( Mat(contours_poly[idx]) );
minEnclosingCircle( (Mat)contours_poly[idx], center[idx], radius[idx] );
// Rect tmpRect(center[idx].x-boundRect[idx].width/2,center[idx].y-boundRect[idx].height/2,boundRect[idx].width,boundRect[idx].height);
Rect tmpRect(center[idx].x-radius[idx],center[idx].y-radius[idx],radius[idx]*2,radius[idx]*2);
//Rect tmpRect = boundRect[idx];
Rect toPrint;
tmpRect += Size(tmpRect.width*RECT_AUGMENT ,tmpRect.height*RECT_AUGMENT); // Aumenta area di RECT_ARGUMENT
tmpRect -= Point((tmpRect.width*RECT_AUGMENT)/2 , (tmpRect.height*RECT_AUGMENT)/2 ); // Ricentra il rettangolo
drawContours(cont, contours, idx, color, CV_FILLED, 8);
if(tmpRect.x>0 && tmpRect.y>0 && tmpRect.x+tmpRect.width < morph.cols && tmpRect.y+tmpRect.height < morph.rows){ //Se il nuovo rettangolo allargato
// NON esce fuori dall'immagine, accettalo
regionsOfInterest.push_back(masked(tmpRect));
b.cuttedWithBack = img(tmpRect);
b.cuttedImages = masked(tmpRect);
b.blobsImage = cont(tmpRect);
b.rectangles = tmpRect;
toPrint = tmpRect;
}
else{
toPrint = boundRect[idx];
regionsOfInterest.push_back(masked(boundRect[idx]));
b.cuttedImages = masked(boundRect[idx]);
b.cuttedWithBack = img(boundRect[idx]);
b.rectangles = boundRect[idx];
b.blobsImage = cont(boundRect[idx]);
}
Point centroid = computeCentroid(contours[idx]);
b.centroid = centroid;
b.area = contourArea(contours[idx]);
b.distance = HEIGH - centroid.y;
/*rectangle( cont, toPrint.tl(), toPrint.br(), color, 2, 8, 0 );
circle( cont, center[idx], (int)radius[idx], color, 2, 8, 0 );*/
blobs.push_back(b);
}
//out = out+cont;
bitwise_xor(out,cont,out);
/*imshow("img",img);
imshow("out",out);
waitKey(0);*/
}
void MeshResampler::resample( HalfedgeMesh& mesh )
{
// TODO Compute the mean edge length.
double mean2 = 0;
for(auto edge = mesh.edgesBegin(); edge != mesh.edgesEnd(); ++edge)
{
Vector3D v0 = edge->halfedge()->vertex()->position;
Vector3D v1 = edge->halfedge()->twin()->vertex()->position;
mean2 += (v0 - v1).norm();
}
mean2 /= (double)mesh.nEdges();
mean2 *= mean2;
// TODO Repeat the four main steps for 5 or 6 iterations
const int ITER_TIMES = 5;
const int SMOOTH_TIMES = 20;
const double WEIGHT_FACTOR = 0.2;
const double LONG_EDGE_2 = 1.7777777778;
const double SHORT_EDGE_2 = 0.64;
std::unordered_set<EdgeIter> edgeSet;
edgeSet.reserve(mesh.nEdges());
for(int i = 0; i < ITER_TIMES; ++i)
{
// TODO Split edges much longer than the target length (being careful about how the loop is written!)
EdgeIter old_end = mesh.edgesEnd();
--old_end;
for(auto edge = mesh.edgesBegin(); edge != mesh.edgesEnd(); ++edge)
{
Vector3D v0 = edge->halfedge()->vertex()->position;
Vector3D v1 = edge->halfedge()->twin()->vertex()->position;
if((v0 - v1).norm2() > LONG_EDGE_2 * mean2)
{
mesh.splitEdge(edge);
}
if(edge == old_end)
break;
}
// TODO Collapse edges much shorter than the target length. Here we need to be EXTRA careful about
// TODO advancing the loop, because many edges may have been destroyed by a collapse (which ones?)
edgeSet.clear();
for(auto edge = mesh.edgesBegin(); edge != mesh.edgesEnd(); ++edge)
{
edgeSet.insert(edge);
}
while(edgeSet.size() > 0)
{
EdgeIter curr = *(edgeSet.begin());
edgeSet.erase(edgeSet.begin());
VertexIter v0 = curr->halfedge()->vertex();
VertexIter v1 = curr->halfedge()->twin()->vertex();
if((v0->position - v1->position).norm2() >= SHORT_EDGE_2 * mean2)
continue;
HalfedgeIter h = v0->halfedge();
do
{
if(edgeSet.find(h->edge()) != edgeSet.end())
edgeSet.erase(h->edge());
h = h->twin()->next();
}
while(h != v0->halfedge());
h = v1->halfedge();
do
{
if(edgeSet.find(h->edge()) != edgeSet.end())
edgeSet.erase(h->edge());
h = h->twin()->next();
}
while(h != v1->halfedge());
VertexIter v_new = mesh.collapseEdge(curr);
if(v_new != mesh.verticesEnd())
{
h = v_new->halfedge();
do
{
edgeSet.insert(h->edge());
h = h->twin()->next();
}
while(h != v_new->halfedge());
}
}
// TODO Now flip each edge if it improves vertex degree
for(auto edge = mesh.edgesBegin(); edge != mesh.edgesEnd(); ++edge)
{
if(willFlipEdgeImprove(edge))
mesh.flipEdge(edge);
}
// TODO Finally, apply some tangential smoothing to the vertex positions
for(int j = 0; j < SMOOTH_TIMES; ++j)
{
for(auto vertex = mesh.verticesBegin(); vertex != mesh.verticesEnd(); ++vertex)
{
if(vertex->isBoundary())
continue;
vertex->computeCentroid();
}
for(auto vertex = mesh.verticesBegin(); vertex != mesh.verticesEnd(); ++vertex)
{
if(vertex->isBoundary())
continue;
Vector3D dir = vertex->centroid - vertex->position;
Vector3D nrm = vertex->normal();
dir -= (dot(nrm, dir) * nrm);
vertex->position = vertex->position + WEIGHT_FACTOR * dir;
}
}
}
}
Triangle::Triangle( const PrecomputedTriangle& ptri ) :
a(ptri.a),b(ptri.b),c(ptri.c), plane( a,b,c )
{
computeCentroid() ;
}
bool Law2_ScGeom_JCFpmPhys_JointedCohesiveFrictionalPM::go(shared_ptr<IGeom>& ig, shared_ptr<IPhys>& ip, Interaction* contact){
const int &id1 = contact->getId1();
const int &id2 = contact->getId2();
ScGeom* geom = static_cast<ScGeom*>(ig.get());
JCFpmPhys* phys = static_cast<JCFpmPhys*>(ip.get());
Body* b1 = Body::byId(id1,scene).get();
Body* b2 = Body::byId(id2,scene).get();
Real Dtensile=phys->FnMax/phys->kn;
string fileCracks = "cracks_"+Key+".txt";
string fileMoments = "moments_"+Key+".txt";
/// Defines the interparticular distance used for computation
Real D = 0;
/*this is for setting the equilibrium distance between all cohesive elements at the first contact detection*/
if ( contact->isFresh(scene) ) {
phys->normalForce = Vector3r::Zero();
phys->shearForce = Vector3r::Zero();
if ((smoothJoint) && (phys->isOnJoint)) {
phys->jointNormal = geom->normal.dot(phys->jointNormal)*phys->jointNormal; //to set the joint normal colinear with the interaction normal
phys->jointNormal.normalize();
phys->initD = std::abs((b1->state->pos - b2->state->pos).dot(phys->jointNormal)); // to set the initial gap as the equilibrium gap
} else {
phys->initD = geom->penetrationDepth;
}
}
if ( smoothJoint && phys->isOnJoint ) {
if ( phys->more || ( phys-> jointCumulativeSliding > (2*min(geom->radius1,geom->radius2)) ) ) {
if (!neverErase) return false;
else {
phys->shearForce = Vector3r::Zero();
phys->normalForce = Vector3r::Zero();
phys->isCohesive =0;
phys->FnMax = 0;
phys->FsMax = 0;
return true;
}
} else {
D = phys->initD - std::abs((b1->state->pos - b2->state->pos).dot(phys->jointNormal));
}
} else {
D = geom->penetrationDepth - phys->initD;
}
phys->crackJointAperture = D<0? -D : 0.; // for DFNFlow
if (!phys->momentBroken && useStrainEnergy) phys->strainEnergy = 0.5*((pow(phys->normalForce.norm(),2)/phys->kn) + (pow(phys->shearForce.norm(),2)/phys->ks));
else if (!phys->momentBroken && !useStrainEnergy) computeKineticEnergy(phys, b1, b2);
//Compute clustered acoustic emission events:
if (recordMoments && !neverErase){
cerr << "Acoustic emissions algorithm requires neverErase=True, changing value from False to True" << endl;
neverErase=true;
}
if (phys->momentBroken && recordMoments && !phys->momentCalculated){
if (phys->originalClusterEvent && !phys->computedCentroid) computeCentroid(phys);
if (phys->originalClusterEvent) computeClusteredMoment(phys);
if (phys->momentCalculated && phys->momentMagnitude!=0){
std::ofstream file (fileMoments.c_str(), !momentsFileExist ? std::ios::trunc : std::ios::app);
if(file.tellp()==0){ file <<"i p0 p1 p2 moment numInts eventNum time beginTime"<<endl; }
file << boost::lexical_cast<string> ( scene->iter )<<" "<< boost::lexical_cast<string> ( phys->momentCentroid[0] ) <<" "<< boost::lexical_cast<string> ( phys->momentCentroid[1] ) <<" "<< boost::lexical_cast<string> ( phys->momentCentroid[2] ) <<" "<< boost::lexical_cast<string> ( phys->momentMagnitude ) << " " << boost::lexical_cast<string> ( phys->clusterInts.size() ) << " " << boost::lexical_cast<string> ( phys->eventNumber ) << " " << boost::lexical_cast<string> (scene->time) << " " << boost::lexical_cast<string> (phys->eventBeginTime) << endl;
momentsFileExist=true;
}
}
/* Determination of interaction */
if (D < 0) { //tensile configuration
if ( !phys->isCohesive) {
if (!neverErase) return false;
else {
phys->shearForce = Vector3r::Zero();
phys->normalForce = Vector3r::Zero();
phys->isCohesive =0;
phys->FnMax = 0;
phys->FsMax = 0;
return true;
}
}
if ( phys->isCohesive && (phys->FnMax>0) && (std::abs(D)>Dtensile) ) {
nbTensCracks++;
phys->isCohesive = 0;
phys->FnMax = 0;
phys->FsMax = 0;
/// Do we need both the following lines?
phys->breakOccurred = true; // flag to trigger remesh for DFNFlowEngine
phys->isBroken = true; // flag for DFNFlowEngine
// update body state with the number of broken bonds -> do we really need that?
JCFpmState* st1=dynamic_cast<JCFpmState*>(b1->state.get());
JCFpmState* st2=dynamic_cast<JCFpmState*>(b2->state.get());
st1->nbBrokenBonds++;
st2->nbBrokenBonds++;
st1->damageIndex+=1.0/st1->nbInitBonds;
st2->damageIndex+=1.0/st2->nbInitBonds;
phys->momentBroken = true;
Real scalarNF=phys->normalForce.norm();
Real scalarSF=phys->shearForce.norm();
totalTensCracksE+=0.5*( ((scalarNF*scalarNF)/phys->kn) + ((scalarSF*scalarSF)/phys->ks) );
totalCracksSurface += phys->crossSection;
if (recordCracks){
std::ofstream file (fileCracks.c_str(), !cracksFileExist ? std::ios::trunc : std::ios::app);
if(file.tellp()==0){ file <<"iter time p0 p1 p2 type size norm0 norm1 norm2 nrg onJnt"<<endl; }
Vector3r crackNormal=Vector3r::Zero();
if ((smoothJoint) && (phys->isOnJoint)) { crackNormal=phys->jointNormal; } else {crackNormal=geom->normal;}
file << boost::lexical_cast<string> ( scene->iter ) << " " << boost::lexical_cast<string> ( scene->time ) <<" "<< boost::lexical_cast<string> ( geom->contactPoint[0] ) <<" "<< boost::lexical_cast<string> ( geom->contactPoint[1] ) <<" "<< boost::lexical_cast<string> ( geom->contactPoint[2] ) <<" "<< 1 <<" "<< boost::lexical_cast<string> ( 0.5*(geom->radius1+geom->radius2) ) <<" "<< boost::lexical_cast<string> ( crackNormal[0] ) <<" "<< boost::lexical_cast<string> ( crackNormal[1] ) <<" "<< boost::lexical_cast<string> ( crackNormal[2] ) <<" "<< boost::lexical_cast<string> ( 0.5*( ((scalarNF*scalarNF)/phys->kn) + ((scalarSF*scalarSF)/phys->ks) ) ) <<" "<< boost::lexical_cast<string> ( phys->isOnJoint ) << endl;
}
if (recordMoments && !phys->momentCalculated){
checkForCluster(phys, geom, b1, b2, contact);
clusterInteractions(phys, contact);
computeTemporalWindow(phys, b1, b2);
}
cracksFileExist=true;
if (!neverErase) return false;
else {
phys->shearForce = Vector3r::Zero();
phys->normalForce = Vector3r::Zero();
return true;
}
}
}
/* NormalForce */
Real Fn = 0;
Fn = phys->kn*D;
/* ShearForce */
Vector3r& shearForce = phys->shearForce;
Real jointSliding=0;
if ((smoothJoint) && (phys->isOnJoint)) {
/// incremental formulation (OK?)
Vector3r relativeVelocity = (b2->state->vel - b1->state->vel); // angVel are not taken into account as particles on joint don't rotate ????
Vector3r slidingVelocity = relativeVelocity - phys->jointNormal.dot(relativeVelocity)*phys->jointNormal;
Vector3r incrementalSliding = slidingVelocity*scene->dt;
shearForce -= phys->ks*incrementalSliding;
jointSliding = incrementalSliding.norm();
phys->jointCumulativeSliding += jointSliding;
} else {
shearForce = geom->rotate(phys->shearForce);
const Vector3r& incrementalShear = geom->shearIncrement();
shearForce -= phys->ks*incrementalShear;
}
/* Mohr-Coulomb criterion */
Real maxFs = phys->FsMax + Fn*phys->tanFrictionAngle;
Real scalarShearForce = shearForce.norm();
if (scalarShearForce > maxFs) {
if (scalarShearForce != 0)
shearForce*=maxFs/scalarShearForce;
else
shearForce=Vector3r::Zero();
if ((smoothJoint) && (phys->isOnJoint)) {phys->dilation=phys->jointCumulativeSliding*phys->tanDilationAngle-D; phys->initD+=(jointSliding*phys->tanDilationAngle);}
// if (!phys->isCohesive) {
// nbSlips++;
// totalSlipE+=((1./phys->ks)*(trialForce-shearForce))/*plastic disp*/.dot(shearForce)/*active force*/;
//
// if ( (recordSlips) && (maxFs!=0) ) {
// std::ofstream file (fileCracks.c_str(), !cracksFileExist ? std::ios::trunc : std::ios::app);
// if(file.tellp()==0){ file <<"iter time p0 p1 p2 type size norm0 norm1 norm2 nrg"<<endl; }
// Vector3r crackNormal=Vector3r::Zero();
// if ((smoothJoint) && (phys->isOnJoint)) { crackNormal=phys->jointNormal; } else {crackNormal=geom->normal;}
// file << boost::lexical_cast<string> ( scene->iter ) <<" " << boost::lexical_cast<string> ( scene->time ) <<" "<< boost::lexical_cast<string> ( geom->contactPoint[0] ) <<" "<< boost::lexical_cast<string> ( geom->contactPoint[1] ) <<" "<< boost::lexical_cast<string> ( geom->contactPoint[2] ) <<" "<< 0 <<" "<< boost::lexical_cast<string> ( 0.5*(geom->radius1+geom->radius2) ) <<" "<< boost::lexical_cast<string> ( crackNormal[0] ) <<" "<< boost::lexical_cast<string> ( crackNormal[1] ) <<" "<< boost::lexical_cast<string> ( crackNormal[2] ) <<" "<< boost::lexical_cast<string> ( ((1./phys->ks)*(trialForce-shearForce)).dot(shearForce) ) << endl;
// }
// cracksFileExist=true;
// }
if ( phys->isCohesive ) {
nbShearCracks++;
phys->isCohesive = 0;
phys->FnMax = 0;
phys->FsMax = 0;
/// Do we need both the following lines?
phys->breakOccurred = true; // flag to trigger remesh for DFNFlowEngine
phys->isBroken = true; // flag for DFNFlowEngine
phys->momentBroken = true;
// update body state with the number of broken bonds -> do we really need that?
JCFpmState* st1=dynamic_cast<JCFpmState*>(b1->state.get());
JCFpmState* st2=dynamic_cast<JCFpmState*>(b2->state.get());
st1->nbBrokenBonds++;
st2->nbBrokenBonds++;
st1->damageIndex+=1.0/st1->nbInitBonds;
st2->damageIndex+=1.0/st2->nbInitBonds;
Real scalarNF=phys->normalForce.norm();
Real scalarSF=phys->shearForce.norm();
totalShearCracksE+=0.5*( ((scalarNF*scalarNF)/phys->kn) + ((scalarSF*scalarSF)/phys->ks) );
totalCracksSurface += phys->crossSection;
if (recordCracks){
std::ofstream file (fileCracks.c_str(), !cracksFileExist ? std::ios::trunc : std::ios::app);
if(file.tellp()==0){ file <<"iter time p0 p1 p2 type size norm0 norm1 norm2 nrg onJnt"<<endl; }
Vector3r crackNormal=Vector3r::Zero();
if ((smoothJoint) && (phys->isOnJoint)) { crackNormal=phys->jointNormal; } else {crackNormal=geom->normal;}
file << boost::lexical_cast<string> ( scene->iter ) << " " << boost::lexical_cast<string> ( scene->time ) <<" "<< boost::lexical_cast<string> ( geom->contactPoint[0] ) <<" "<< boost::lexical_cast<string> ( geom->contactPoint[1] ) <<" "<< boost::lexical_cast<string> ( geom->contactPoint[2] ) <<" "<< 2 <<" "<< boost::lexical_cast<string> ( 0.5*(geom->radius1+geom->radius2) ) <<" "<< boost::lexical_cast<string> ( crackNormal[0] ) <<" "<< boost::lexical_cast<string> ( crackNormal[1] ) <<" "<< boost::lexical_cast<string> ( crackNormal[2] ) <<" "<< boost::lexical_cast<string> ( 0.5*( ((scalarNF*scalarNF)/phys->kn) + ((scalarSF*scalarSF)/phys->ks) ) ) <<" "<< boost::lexical_cast<string> ( phys->isOnJoint ) << endl;
}
cracksFileExist=true;
// // option 1: delete contact whatsoever (if in compression, it will be detected as a new contact at the next timestep -> actually, not necesarily because of the near neighbour interaction: there could be a gap between the bonded particles and thus a broken contact may not be frictional at the next timestep if the detection is done for strictly contacting particles...) -> to TEST
// if (!neverErase) return false;
// else {
// phys->shearForce = Vector3r::Zero();
// phys->normalForce = Vector3r::Zero();
// return true;
// }
if (recordMoments && !phys->momentCalculated){
checkForCluster(phys, geom, b1, b2, contact);
clusterInteractions(phys, contact);
computeTemporalWindow(phys, b1, b2);
}
// option 2: delete contact if in tension
// shearForce *= Fn*phys->tanFrictionAngle/scalarShearForce; // now or at the next timestep? should not be very different -> to TEST
if ( D < 0 ) { // spheres do not touch
if (!neverErase) return false;
else {
phys->shearForce = Vector3r::Zero();
phys->normalForce = Vector3r::Zero();
return true;
}
}
}
}
/* Apply forces */
if ((smoothJoint) && (phys->isOnJoint)) { phys->normalForce = Fn*phys->jointNormal; } else { phys->normalForce = Fn*geom->normal; }
Vector3r f = phys->normalForce + shearForce;
/// applyForceAtContactPoint computes torque also and, for now, we don't want rotation for particles on joint (some errors in calculation due to specific geometry)
//applyForceAtContactPoint(f, geom->contactPoint, I->getId2(), b2->state->pos, I->getId1(), b1->state->pos, scene);
scene->forces.addForce (id1,-f);
scene->forces.addForce (id2, f);
// simple solution to avoid torque computation for particles interacting on a smooth joint
if ( (phys->isOnJoint)&&(smoothJoint) ) return true;
/// those lines are needed if rootBody->forces.addForce and rootBody->forces.addMoment are used instead of applyForceAtContactPoint -> NOTE need to check for accuracy!!!
scene->forces.addTorque(id1,(geom->radius1-0.5*geom->penetrationDepth)* geom->normal.cross(-f));
scene->forces.addTorque(id2,(geom->radius2-0.5*geom->penetrationDepth)* geom->normal.cross(-f));
return true;
}
