// Update particle position, velocity, temp, and conc // throws CommonException() void UpdateParticlesTask::Execute(void) { CommonException *upErr = NULL; #ifdef CONST_ARRAYS int ndsArray[MAX_SHAPE_NODES]; double fn[MAX_SHAPE_NODES]; #else int ndsArray[maxShapeNodes]; double fn[maxShapeNodes]; #endif // Damping terms on the grid or on the particles // particleAlpha = (1-beta)/dt + pdamping(t) // gridAlpha = -m*(1-beta)/dt + damping(t) double particleAlpha = bodyFrc.GetParticleDamping(mtime); double gridAlpha = bodyFrc.GetDamping(mtime); // nonPICGridAlpha = damping(t) // globalPIC = (1-beta)/dt double nonPICGridAlpha = bodyFrc.GetNonPICDamping(mtime); double globalPIC = bodyFrc.GetPICDamping(); // Update particle position, velocity, temp, and conc #pragma omp parallel for private(ndsArray,fn) for(int p=0;p<nmpmsNR;p++) { MPMBase *mpmptr = mpm[p]; try { // get shape functions const ElementBase *elemRef = theElements[mpmptr->ElemID()]; int *nds = ndsArray; elemRef->GetShapeFunctions(fn,&nds,mpmptr); int numnds = nds[0]; // Update particle position and velocity const MaterialBase *matRef=theMaterials[mpmptr->MatID()]; int matfld=matRef->GetField(); // Allow material to override global settings double localParticleAlpha = particleAlpha; double localGridAlpha = gridAlpha; matRef->GetMaterialDamping(localParticleAlpha,localGridAlpha,nonPICGridAlpha,globalPIC); // data structure for extrapolations GridToParticleExtrap *gp = new GridToParticleExtrap; // acceleration on the particle gp->acc = mpmptr->GetAcc(); ZeroVector(gp->acc); // extrapolate nodal velocity from grid to particle ZeroVector(&gp->vgpnp1); // only two possible transport tasks double rate[2]; rate[0] = rate[1] = 0.; int task; TransportTask *nextTransport; // Loop over nodes for(int i=1;i<=numnds;i++) { // increment velocity and acceleraton const NodalPoint *ndptr = nd[nds[i]]; short vfld = (short)mpmptr->vfld[i]; // increment ndptr->IncrementDelvaTask5(vfld,matfld,fn[i],gp); #ifdef CHECK_NAN // conditionally compiled check for nan velocities if(gp->vgpnp1.x!=gp->vgpnp1.x || gp->vgpnp1.y!=gp->vgpnp1.y || gp->vgpnp1.z!=gp->vgpnp1.z) { #pragma omp critical (output) { cout << "\n# UpdateParticlesTask::Execute: bad material velocity field for vfld=" << vfld << "matfld=" << matfld << " fn[i]=" << fn[i] << endl;; PrintVector("# Particle velocity vgpn1 = ",&gp->vgpnp1); cout << endl; ndptr->Describe(); } } #endif // increment transport rates nextTransport=transportTasks; task=0; while(nextTransport!=NULL) nextTransport=nextTransport->IncrementTransportRate(ndptr,fn[i],rate[task++]); } // Find grid damping acceleration parts = ag*Vgp(n) = ag*(Vgp(n+1) - Agp(n)*dt) Vector accExtra = gp->vgpnp1; AddScaledVector(&accExtra, gp->acc, -timestep); ScaleVector(&accExtra,localGridAlpha); // update position, and must be before velocity update because updates need initial velocity // This section does second order update mpmptr->MovePosition(timestep,&gp->vgpnp1,&accExtra,localParticleAlpha); // update velocity in mm/sec mpmptr->MoveVelocity(timestep,&accExtra); // update transport values nextTransport=transportTasks; task=0; while(nextTransport!=NULL) nextTransport=nextTransport->MoveTransportValue(mpmptr,timestep,rate[task++]); // energy coupling here adds adiabtic temperature rise if(ConductionTask::adiabatic) { double dTad = mpmptr->GetBufferClear_dTad(); // in K mpmptr->pTemperature += dTad; // in K } // delete grid to particle extrap data delete gp; } catch(CommonException& err) { if(upErr==NULL) { #pragma omp critical (error) upErr = new CommonException(err); } } catch(std::bad_alloc&) { if(upErr==NULL) { #pragma omp critical (error) upErr = new CommonException("Memory error","UpdateParticlesTask::Execute"); } } catch(...) { if(upErr==NULL) { #pragma omp critical (error) upErr = new CommonException("Unexpected error","UpdateParticlesTask::Execute"); } } } // throw any errors if(upErr!=NULL) throw *upErr; // rigid materials move at their current velocity for(int p=nmpmsNR;p<nmpms;p++) { mpm[p]->MovePosition(timestep); } }
// Adjust change in momentum for frictional contact in tangential direction // If has component of tangential motion, calculate force depending on whether it is sticking or sliding // When frictional sliding, find tangential force (times dt) and set flag, if not set flag false // When friction heating is on, set Ftdt term and set hasFriction to true // (hasFriction (meaning has frictional heating value) must be initialized to false when called) // contactArea only provided if frictional law needs it // Normally in contact when called, but some laws might want call even when not in contact. If return // value is false, the contact should be treated as no contact bool CoulombFriction::GetFrictionalDeltaMomentum(Vector *delPi,Vector *norm,double dotn,double *mredDE,double mred, bool getHeating,double contactArea,bool inContact,double deltime,Vector *at) const { // indicate no frictional heat yet *mredDE=-1.; // stick and frictionless are easy and no heating if(frictionStyle==STICK) { // stick conditions no change return true; } else if(frictionStyle==FRICTIONLESS) { // remove tangential term CopyScaleVector(delPi,norm,dotn); return true; } // Rest implements friction sliding // The initial delPi = (-N A dt) norm + (Sstick A dt) tang = dotn norm + dott tang // where N is normal traction (positive in compression), A is contact area, and dt is timestep // get unnormalized tangential vector and its magnitude // tang = delPi - dotn norm Vector tang; CopyVector(&tang,delPi); AddScaledVector(&tang,norm,-dotn); double tangMag = sqrt(DotVectors(&tang,&tang)); // if has tangential motion, we need to change momemtum if frictional sliding is occuring if(!DbleEqual(tangMag,0.)) { ScaleVector(&tang,1./tangMag); double dott = DotVectors(delPi,&tang); // make it positive for comparison to the positive frictional force Sslide if(dott < 0.) { ScaleVector(&tang,-1.); dott = -dott; } // Let frictional sliding force be Sslide Ac dt = f(N) Ac dt // Then if dott > Sslide Ac dt (which means Sstick>Sslide) // a. Set delPi = dotn norm + Sslide Ac dt tang // For example, Coulomb friction has Fslide dt = mu(dotn) so delPi = (norm - mu tang) dotn double SslideAcDt = GetSslideAcDt(-dotn,dott,0.,mred,contactArea,inContact,deltime); if(!inContact) return false; if(dott > SslideAcDt) { CopyScaleVector(delPi,norm,dotn); AddScaledVector(delPi,&tang,SslideAcDt); // get frictional heating term as friction work times reduced mass // As heat source need Energy/sec or divide by timestep*reduced mass // Note: only add frictional heating during momentum update (when friction // force is appropriate) and only if frictional contact heat is enabled. if(getHeating) { if(at!=NULL) { double Vs = SslideAcDt*(dott-SslideAcDt); AddScaledVector(at, delPi, -1./deltime); double AsDt = SslideAcDt*DotVectors(at,&tang)*deltime; if(AsDt>Vs) { //*mredDE = Vs*(Vs/AsDt-1.)+0.5*AsDt; *mredDE = 0.5*Vs*Vs/AsDt; } else *mredDE = Vs - 0.5*AsDt; } else *mredDE = SslideAcDt*(dott-SslideAcDt); } } } // still in contact return true; }
/* Calculate change in momentum when there is contact. Return true or false if an adjustment was calculated If BC at the node, the delta momemtum should be zero in fixed direction Only called if both verified are verified and have 1 or more particles This method should ignore material that are ignoring cracks */ bool CrackSurfaceContact::GetDeltaMomentum(NodalPoint *np,Vector *delPa,CrackVelocityField *cva,CrackVelocityField *cvb, Vector *normin,int number,bool postUpdate,double deltime,int *inContact) { // first determine if there is contact *inContact=IN_CONTACT; // velocities above and below bool hasParticles; double massa,massb; Vector pka=cva->GetCMatMomentum(hasParticles,&massa); Vector pkb=cvb->GetCMatMomentum(hasParticles,&massb); double mnode=1./(massa+massb); // screen low masses double aratio=massa*mnode; if(aratio<1.e-6 || aratio>0.999999) return false; //if(aratio<1.e-3 || aratio>0.999) return FALSE; // find Delta p_a (see notes) CopyScaleVector(delPa,&pkb,massa*mnode); AddScaledVector(delPa,&pka,-massb*mnode); // get normalized normal vector and find Delta p_a . n (actual (vb-va).n = dotn*(ma+mb)/(ma*mb)) Vector norm; CopyScaleVector(&norm,normin,1./sqrt(DotVectors2D(normin,normin))); double dotn=DotVectors2D(delPa,&norm); // With the first check, any movement apart will be taken as noncontact // Also, frictional contact assume dvel<0. if(dotn>=0.) *inContact=SEPARATED; else { // if approaching, check displacements // (Note: to use only velocity, skip the following displacement check) Vector dispa=cva->GetCMDisplacement(np,true); dispa.x/=massa; dispa.y/=massa; Vector dispb=cvb->GetCMDisplacement(np,true); dispb.x/=massb; dispb.y/=massb; // normal cod double dnorm=(dispb.x-dispa.x)*norm.x + (dispb.y-dispa.y)*norm.y - mpmgrid.GetNormalCODAdjust(&norm,NULL,0); if(postUpdate) { double dvel=(massa+massb)*dotn/(massa*massb); dnorm+=dvel*deltime; } // if current displacement positive then no contact if(dnorm >= 0.) *inContact=SEPARATED; } // if separated, then no contact unless possibly needed for an imperfect interface if(crackContactLaw[number]->ContactIsDone(*inContact==IN_CONTACT)) return false; // Now need to change momentum. For imperfect interface, change only for perfect directions double mredDE; if(crackContactLaw[number]->IsFrictionalContact()) { bool getHeating = postUpdate && ConductionTask::crackContactHeating; double mred = (massa*massb)/(massa+massb); double contactArea = 1.; if(crackContactLaw[number]->FrictionLawNeedsContactArea()) { // Angled path correction (2D only) double dist = mpmgrid.GetPerpendicularDistance(&norm, NULL, 0.); // Area correction method (new): sqrt(2*vmin/vtot)*vtot/dist = sqrt(2*vmin*vtot)/dist double vola = cva->GetVolumeNonrigid(true),volb = cvb->GetVolumeNonrigid(true),voltot=vola+volb; contactArea = sqrt(2.0*fmin(vola,volb)*voltot)/dist; if(fmobj->IsAxisymmetric()) contactArea *= np->x; } if(!crackContactLaw[number]->GetFrictionalDeltaMomentum(delPa,&norm,dotn,&mredDE,mred, getHeating,contactArea,*inContact==IN_CONTACT,deltime,NULL)) { return false; } if(mredDE>0.) { double qrate = mredDE/mred; NodalPoint::frictionWork += qrate; // As heat source need nJ/sec or multiply by 1/timestep // Note that this is after transport rates are calculated (by true in last parameter) conduction->AddFluxCondition(np,fabs(qrate/deltime),true); } } else { // Contact handled here only perfect interface (Dt or Dn < 0) // Imperfect interfaces are handled as forces later if(crackContactLaw[number]->IsPerfectTangentialInterface()) { if(!crackContactLaw[number]->IsPerfectNormalInterface(*inContact==IN_CONTACT)) { // prefect in tangential, but imperfect in normal direction // make stick in tangential direction only AddScaledVector(delPa,&norm,-dotn); } // else perfect in both so return with the stick conditions already in delPa } else if(crackContactLaw[number]->IsPerfectNormalInterface(*inContact==IN_CONTACT)) { // perfect in normal direction, but imperfect in tangential direction // make stick in normal direction only CopyScaleVector(delPa,&norm,dotn); } else { // no change in momentum, just imperfect interface forces later and nothing changed here return false; } } return true; }
/* Calculate change in momentum when there is contact. Return true or false if an adjustment was calculated If BC at the node, the delta momemtum should be zero in fixed direction Only called if both verified are verified and have 1 or more particles This method should ignore material that are ignoring cracks */ bool CrackSurfaceContact::GetDeltaMomentum(NodalPoint *np,Vector *delPa,CrackVelocityField *cva,CrackVelocityField *cvb, Vector *normin,int number,bool postUpdate,double deltime,int *inContact) { // first determine if there is contact *inContact=IN_CONTACT; // velocities above and below bool hasParticles; double massa,massb; Vector pka=cva->GetCMatMomentum(hasParticles,&massa); Vector pkb=cvb->GetCMatMomentum(hasParticles,&massb); double mnode=1./(massa+massb); // screen low masses double aratio=massa*mnode; if(aratio<1.e-6 || aratio>0.999999) return false; //if(aratio<1.e-3 || aratio>0.999) return FALSE; // find Delta p_a (see notes) CopyScaleVector(delPa,&pkb,massa*mnode); AddScaledVector(delPa,&pka,-massb*mnode); // get normalized normal vector and find Delta p_a . n (actual (vb-va).n = dotn*(ma+mb)/(ma*mb)) Vector norm; CopyScaleVector(&norm,normin,1./sqrt(DotVectors2D(normin,normin))); double dotn=DotVectors2D(delPa,&norm); // With the first check, any movement apart will be taken as noncontact // Also, frictional contact assume dvel<0. if(dotn>=0.) *inContact=SEPARATED; else { // if approaching, check displacements // (Note: to use only velocity, skip the following displacement check) Vector dispa=cva->GetCMDisplacement(np,true); dispa.x/=massa; dispa.y/=massa; Vector dispb=cvb->GetCMDisplacement(np,true); dispb.x/=massb; dispb.y/=massb; // normal cod double dnorm=(dispb.x-dispa.x)*norm.x + (dispb.y-dispa.y)*norm.y - mpmgrid.GetNormalCODAdjust(&norm,NULL,0); if(postUpdate) { double dvel=(massa+massb)*dotn/(massa*massb); dnorm+=dvel*deltime; } // if current displacement positive then no contact if(dnorm >= 0.) *inContact=SEPARATED; } // if separated, then no contact unless possibly needed for an imperfect interface if(*inContact==SEPARATED && CrackContactLaw[number].law!=IMPERFECT_INTERFACE) return false; // Now need to change momentum. For imperfect interface, may or may not need a change Vector tang; double dott,mu; switch(CrackContactLaw[number].law) { case STICK: break; case FRICTIONLESS: CopyScaleVector(delPa,&norm,dotn); break; case FRICTIONAL: CopyVector(&tang,delPa); AddScaledVector(&tang,&norm,-dotn); dott=sqrt(DotVectors2D(&tang,&tang)); if(!DbleEqual(dott,0.)) { ScaleVector(&tang,1./dott); dott=DotVectors2D(delPa,&tang); if(dott<0.) { ScaleVector(&tang,-1.); dott=-dott; } mu=-CrackContactLaw[number].friction; if(dott>mu*dotn) { AddScaledVector(&norm,&tang,mu); CopyScaleVector(delPa,&norm,dotn); // get frictional heating part - this is g mm^2/sec^2 = nJ // Note: only add frictional heating during momentum update (when frictional // force is appropriate) and only if conduction is on. if(postUpdate && ConductionTask::crackContactHeating) { if(np->NodeHasNonrigidParticles()) { Vector Ftdt; CopyScaleVector(&Ftdt,&tang,mu*dotn); double qrate = (massa+massb)*DotVectors2D(&Ftdt,delPa)/(massa*massb); // As heat source need nJ/sec or multiply by 1/timestep // Note that this is after transport rates are calculated (by true in last parameter) conduction->AddFluxCondition(np,fabs(qrate/deltime),true); } } } } break; case IMPERFECT_INTERFACE: // Contact handled here only perfect interface (Dt or Dn < 0) // Imperfect interfaces are handled as forces later if(CrackContactLaw[number].Dt<0) { if( (*inContact==SEPARATED && CrackContactLaw[number].Dn>=0.) || (*inContact==IN_CONTACT && CrackContactLaw[number].Dnc>=0.) ) { // prefect in tangential, but imperfect in normal direction // make stick in tangential direction only AddScaledVector(delPa,&norm,-dotn); } // else perfect in both so return with the stick conditions already in delPa } else if( (*inContact==SEPARATED && CrackContactLaw[number].Dn<0.) || (*inContact==IN_CONTACT && CrackContactLaw[number].Dnc<0.) ) { // perfect in normal direction, but imperfect in tangential direction // make stick in normal direction only CopyScaleVector(delPa,&norm,dotn); } else { // no change in momentum, just imperfect interface forces later and nothing changed here return false; } break; default: break; } return true; }
// Update particle position, velocity, temp, and conc void UpdateParticlesTask::Execute(void) { CommonException *upErr = NULL; int numnds,nds[maxShapeNodes]; double fn[maxShapeNodes]; Vector vgpnp1; // Damping terms on the grid or on the particles // particleAlpha = alpha(PIC)/dt + pdamping(t) // gridAlpha = -alpha(PIC)/dt + damping(t) double particleAlpha = bodyFrc.GetParticleDamping(mtime); double gridAlpha = bodyFrc.GetDamping(mtime); // copy to local values (OSParticulas uses to implement material damping) double localParticleAlpha = particleAlpha; double localGridAlpha = gridAlpha; // Update particle position, velocity, temp, and conc #pragma omp parallel for private(numnds,nds,fn,vgpnp1) for(int p=0;p<nmpmsNR;p++) { MPMBase *mpmptr = mpm[p]; try { // get shape functions const ElementBase *elemRef = theElements[mpmptr->ElemID()]; elemRef->GetShapeFunctions(&numnds,fn,nds,mpmptr); // Update particle position and velocity const MaterialBase *matRef=theMaterials[mpmptr->MatID()]; int matfld=matRef->GetField(); Vector *acc=mpmptr->GetAcc(); ZeroVector(acc); ZeroVector(&vgpnp1); double rate[2]; // only two possible transport tasks rate[0] = rate[1] = 0.; int task; TransportTask *nextTransport; short vfld; // Loop over nodes for(int i=1;i<=numnds;i++) { // increment velocity and acceleraton const NodalPoint *ndptr = nd[nds[i]]; vfld = (short)mpmptr->vfld[i]; ndptr->IncrementDelvaTask5(vfld,matfld,fn[i],&vgpnp1,acc); #ifdef CHECK_NAN if(vgpnp1.x!=vgpnp1.x || vgpnp1.y!=vgpnp1.y || vgpnp1.z!=vgpnp1.z) { cout << "\n# UpdateParticlesTask::Execute: bad material velocity field for vfld = " << vfld << endl; ndptr->Describe(); } #endif // increment transport rates nextTransport=transportTasks; task=0; while(nextTransport!=NULL) nextTransport=nextTransport->IncrementTransportRate(ndptr,fn[i],rate[task++]); } // Find vgpn Vector vgpn = vgpnp1; AddScaledVector(&vgpn,acc,-timestep); // find effective grid acceleration and velocity AddScaledVector(acc,&vgpn,-localGridAlpha); AddScaledVector(&vgpnp1,&vgpn,-timestep*localGridAlpha); // update position, and must be before velocity update because updates need initial velocity // This section does second order update mpmptr->MovePosition(timestep,&vgpnp1,0.5*timestep,localParticleAlpha); // update velocity in mm/sec mpmptr->MoveVelocity(timestep,localParticleAlpha); // update transport values nextTransport=transportTasks; task=0; while(nextTransport!=NULL) nextTransport=nextTransport->MoveTransportValue(mpmptr,timestep,rate[task++]); // thermal ramp thermal.UpdateParticleTemperature(&mpmptr->pTemperature,timestep); // energy coupling here if conduction not doing it if(!ConductionTask::active) { if(ConductionTask::adiabatic) { double energy = mpmptr->GetDispEnergy(); // in nJ/g double Cv = matRef->GetHeatCapacity(mpmptr); // in nJ/(g-K) mpmptr->pTemperature += energy/Cv; // in K } mpmptr->SetDispEnergy(0.); } } catch(CommonException err) { if(upErr==NULL) { #pragma omp critical upErr = new CommonException(err); } } } // throw any errors if(upErr!=NULL) throw *upErr; // rigid materials move at their current velocity for(int p=nmpmsNR;p<nmpms;p++) { mpm[p]->MovePosition(timestep,&mpm[p]->vel,0.,0.); } }