double AnisotropicMassTransferMaterial :: giveCharacteristicValue(MatResponseMode mode, GaussPoint *gp, TimeStep *atTime) { _error2( "giveCharacteristicValue : unknown mode (%s)", __MatResponseModeToString(mode) ); return 0.; }
void UserDefinedTemperatureField :: computeValueAt(FloatArray &answer, TimeStep *stepN, FloatArray &coords, ValueModeType mode) // Returns the value of the receiver at time and given position respecting the mode. { int err; double result; if ( ( mode != VM_Incremental ) && ( mode != VM_Total ) ) { _error2( "computeComponentArrayAt: unknown mode (%s)", __ValueModeTypeToString(mode) ); } answer.resize(this->size); std::ostringstream buff; for ( int i = 1; i <= size; i++ ) { buff << "x=" << coords.at(1) << ";y=" << coords.at(2) << ";z=" << coords.at(3) << ";t=" << stepN->giveTargetTime() << ";" <<ftExpression[i-1]; result = myParser.eval(buff.str().c_str(), err); if ( err ) { _error("computeValueAt: parser syntax error"); } answer.at(i) = result; if ( ( mode == VM_Incremental ) && ( !stepN->isTheFirstStep() ) ) { buff << "x=" << coords.at(1) << ";y=" << coords.at(2) << ";z=" << coords.at(3) << ";t=" << (stepN->giveTargetTime() - stepN->giveTimeIncrement()) << ";" << ftExpression[i-1]; result = myParser.eval(buff.str().c_str(), err); if ( err ) { _error("computeValueAt: parser syntax error"); } answer.at(i) -= result; } } }
bool HeMoTKMaterial :: isCharacteristicMtrxSymmetric(MatResponseMode mode) { if ( ( mode == Conductivity_ww ) || ( mode == Conductivity_hh ) || ( mode == Conductivity_hw ) || ( mode == Conductivity_wh ) ) { return false; } else { _error2( "isCharacteristicMtrxSymmetric : unknown mode (%s)", __MatResponseModeToString(mode) ); } return false; // to make compiler happy }
int NonStationaryTransportProblem :: giveUnknownDictHashIndx(EquationID type, ValueModeType mode, TimeStep *stepN) { if ( mode == VM_Total ) { //Nodal temperature return 0; } else if ( mode == VM_RhsTotal ) { //Nodal Rhs return 1; } else { _error2( "ValueModeType %s undefined", __ValueModeTypeToString(mode) ); } return 0; }
FloatArray * StructuralCrossSection :: imposeStressConstrainsOnGradient(GaussPoint *gp, FloatArray *gradientStressVector3d) // // returns modified gradient of stress vector, which is used to // bring stresses back to yield surface. // // imposes zeros on places, where zero stress occurs. if energetically connected // strain is zero, we do not impose zero there, because stress exist and // must be taken into account when computing yeld function. In such case // a problem is assumed to be full 3d with some explicit strain equal to 0. // // On the other hand, if some stress is imposed to be zero, we understand // such case as subspace of 3d case (like a classical plane stess problem, with no // tracing of ez, sigma_z) // { MaterialMode mode = gp->giveMaterialMode(); int i, size = gradientStressVector3d->giveSize(); if ( size != 6 ) { _error("ImposeStressConstrainsOnGradient: gradientStressVector3d size mismatch"); } if ( mode == _3dMat ) { return gradientStressVector3d; } switch ( mode ) { case _PlaneStress: gradientStressVector3d->at(3) = 0.; gradientStressVector3d->at(4) = 0.; gradientStressVector3d->at(5) = 0.; break; case _PlaneStrain: // gradientStressVector3d ->at(3) = 0.; gradientStressVector3d->at(4) = 0.; gradientStressVector3d->at(5) = 0.; break; case _1dMat: for ( i = 2; i <= 6; i++ ) { gradientStressVector3d->at(i) = 0.; } break; default: _error2( "ImposeStressConstrainsOnGradient: unknown mode (%s)", __MaterialModeToString(mode) ); break; } return gradientStressVector3d; }
double IsotropicHeatTransferMaterial :: giveCharacteristicValue(MatResponseMode mode, GaussPoint *gp, TimeStep *atTime) { if ( mode == Capacity ) { return ( capacity * this->give('d', gp) ); } else { _error2( "giveCharacteristicValue : unknown mode (%s)", __MatResponseModeToString(mode) ); } return 0.; }
void AnisotropicMassTransferMaterial :: giveCharacteristicMatrix(FloatMatrix &answer, MatResponseMode mode, GaussPoint *gp, TimeStep *atTime) { MaterialMode mMode = gp->giveMaterialMode(); switch ( mMode ) { case _1dHeat: case _2dHeat: case _3dHeat: answer = k; return; default: _error2( "giveCharacteristicMatrix : unknown mode (%s)", __MaterialModeToString(mMode) ); } }
void HeMoTKMaterial :: giveCharacteristicMatrix(FloatMatrix &answer, MatResponseForm form, MatResponseMode mode, GaussPoint *gp, TimeStep *atTime) { /* * returns constitutive matrix of receiver */ if ( ( mode == Conductivity_ww ) || ( mode == Conductivity_hh ) || ( mode == Conductivity_hw ) || ( mode == Conductivity_wh ) ) { this->computeConductivityMtrx(answer, mode, gp, atTime); } else { _error2( "giveCharacteristicMatrix : unknown mode (%s)", __MatResponseModeToString(mode) ); } }
void RCM2Material :: updateStatusForNewCrack(GaussPoint *gp, int i, double Le) // // updates gp status when new crack-plane i is formed with charLength Le // updates Le and computes and sets minEffStrainForFullyOpenCrack // { RCM2MaterialStatus *status = ( RCM2MaterialStatus * ) this->giveStatus(gp); if ( Le <= 0 ) { _error2( "Element %d returned zero char length", gp->giveElement()->giveNumber() ); } status->setCharLength(i, Le); //status -> setMinCrackStrainsForFullyOpenCrack (i, this->giveMinCrackStrainsForFullyOpenCrack(gp,i)); }
FloatArray * StructuralCrossSection :: imposeStrainConstrainsOnGradient(GaussPoint *gp, FloatArray *gradientStrainVector3d) // // returns modified gradient of strain vector, which is used to // compute plastic strain increment. // // imposes zeros on places, where zero strain occurs or energetically connected stress // is prescribed to be zero. // { MaterialMode mode = gp->giveMaterialMode(); int i, size = gradientStrainVector3d->giveSize(); if ( size != 6 ) { _error("ImposeStrainConstrainsOnGradient: gradientStrainVector3d size mismatch"); } if ( mode == _3dMat ) { return gradientStrainVector3d; } switch ( mode ) { case _PlaneStress: gradientStrainVector3d->at(3) = 0.; gradientStrainVector3d->at(4) = 0.; gradientStrainVector3d->at(5) = 0.; break; case _PlaneStrain: gradientStrainVector3d->at(3) = 0.; gradientStrainVector3d->at(4) = 0.; gradientStrainVector3d->at(5) = 0.; break; case _1dMat: for ( i = 2; i <= 6; i++ ) { gradientStrainVector3d->at(i) = 0.; } break; default: _error2( "ImposeStrainConstrainsOnGradient: unknown mode (%s)", __MaterialModeToString(mode) ); break; } return gradientStrainVector3d; }
void PrimaryField :: initialize(ValueModeType mode, TimeStep *atTime, FloatArray &answer) { int neq = emodel->giveNumberOfEquations(this->ut); answer.resize(neq); answer.zero(); if ( mode == VM_Total ) { answer = * ( this->giveSolutionVector(atTime) ); } else if ( mode == VM_Incremental ) { int indxm1 = this->resolveIndx(atTime, -1); answer = * ( this->giveSolutionVector(atTime) ); answer.subtract( *this->giveSolutionVector(indxm1) ); } else { _error2( "giveUnknownValue: unsupported mode %s", __ValueModeTypeToString(mode) ); } }
void QBrick1_ht :: SPRNodalRecoveryMI_giveDofMansDeterminedByPatch(IntArray &answer, int pap) { int found = 0; answer.resize(1); for ( int i = 1; i <= numberOfDofMans; i++ ) { if ( this->giveNode(i)->giveNumber() == pap ) { found = 1; } } if ( found ) { answer.at(1) = pap; } else { _error2("SPRNodalRecoveryMI_giveDofMansDeterminedByPatch: unknown node number %d", pap); } }
int SlaveDof :: giveNumberOfPrimaryMasterDofs() { if ( countOfPrimaryMasterDofs > 0 ) { return countOfPrimaryMasterDofs; } else if ( countOfPrimaryMasterDofs == 0 ) { _error2( "giveNumberOfPrimaryDofs: slaveDof number %ld is own master", this->giveNumber() ); } countOfPrimaryMasterDofs = 0; long i, c = 0; for ( i = 1; i <= countOfMasterDofs; i++ ) { c += this->giveMasterDof(i)->giveNumberOfPrimaryMasterDofs(); } return countOfPrimaryMasterDofs = c; }
void NonlinearMassTransferMaterial :: giveCharacteristicMatrix(FloatMatrix &answer, MatResponseForm form, MatResponseMode mode, GaussPoint *gp, TimeStep *atTime) { MaterialMode mMode = gp->giveMaterialMode(); AnisotropicMassTransferMaterialStatus *status = ( ( AnisotropicMassTransferMaterialStatus * ) this->giveStatus(gp) ); FloatArray eps = status->giveGradP(); double gradPNorm; FloatMatrix t1, t2; gradPNorm = eps.computeNorm(); t1.beDyadicProductOf(eps, eps); if ( gradPNorm != 0.0 ) { t1.times( C * alpha * pow(gradPNorm, alpha - 2) ); } switch ( mMode ) { case _1dHeat: t2.resize(1, 1); t2.at(1, 1) = 1; break; case _2dHeat: t2.resize(2, 2); t2.at(1, 1) = t2.at(2, 2) = 1; break; case _3dHeat: t2.resize(3, 3); t2.at(1, 1) = t2.at(2, 2) = t2.at(3, 3) = 1; break; default: _error2( "giveCharacteristicMatrix : unknown mode (%s)", __MaterialModeToString(mMode) ); } answer.beEmptyMtrx(); answer.add(t1); answer.add(1 + C * pow(gradPNorm, alpha), t2); }
/* * Read a chunk from a local stream, reading up to end of either the stream * or the chunk. */ static int _read(struct request *r, int fd, unsigned char *buf, int buf_size) { int nread; unsigned char *b, *b_end; b_end = buf + buf_size; b = buf; while (b < b_end) { nread = io_read(fd, b, b_end - b); if (nread < 0) { _error2(r, "read() failed", strerror(errno)); return -1; } if (nread == 0) return b - buf; b += nread; } return buf_size; }
void CebFipSlip90Material :: give1dInterfaceMaterialStiffnessMatrix(FloatMatrix &answer, MatResponseForm form, MatResponseMode rMode, GaussPoint *gp, TimeStep *atTime) { double kappa; CebFipSlip90MaterialStatus *status = ( CebFipSlip90MaterialStatus * ) this->giveStatus(gp); answer.resize(1, 1); if ( ( rMode == ElasticStiffness ) || ( rMode == SecantStiffness ) ) { kappa = status->giveKappa(); if ( kappa > 0.0 ) { answer.at(1, 1) = ( this->computeBondForce(kappa) / kappa ); } else { answer.at(1, 1) = computeBondForceStiffness(0.0); } } else if ( rMode == TangentStiffness ) { answer.at(1, 1) = computeBondForceStiffness( status->giveTempKappa() ); } else { _error2( "give2dInterfaceMaterialStiffnessMatrix: unknown MatResponseMode (%s)", __MatResponseModeToString(rMode) ); } }
void IsotropicHeatTransferMaterial :: giveCharacteristicMatrix(FloatMatrix &answer, MatResponseForm form, MatResponseMode mode, GaussPoint *gp, TimeStep *atTime) { /* * returns constitutive (conductivity) matrix of receiver */ MaterialMode mMode = gp->giveMaterialMode(); double cond = this->giveIsotropicConductivity(gp); /*if ( !isActivated(atTime) ) //element, which is inactive (activityLTF==0), will never go into this function cond = 0.; } */ switch ( mMode ) { case _1dHeat: answer.resize(1, 1); answer.at(1, 1) = cond; case _2dHeat: answer.resize(2, 2); answer.at(1, 1) = cond; answer.at(2, 2) = cond; return; case _3dHeat: answer.resize(3, 3); answer.at(1, 1) = cond; answer.at(2, 2) = cond; answer.at(3, 3) = cond; return; default: _error2( "giveCharacteristicMatrix : unknown mode (%s)", __MaterialModeToString(mMode) ); } }
void IsotropicMoistureTransferMaterial :: giveCharacteristicMatrix(FloatMatrix &answer, MatResponseForm form, MatResponseMode mode, GaussPoint *gp, TimeStep *atTime) { /* * returns constitutive (conductivity) matrix of receiver */ double permeability; permeability = this->givePermeability(gp, atTime); MaterialMode mMode = gp->giveMaterialMode(); switch ( mMode ) { case _1dHeat: answer.resize(1, 1); answer.at(1, 1) = permeability; case _2dHeat: answer.resize(2, 2); answer.at(1, 1) = permeability; answer.at(2, 2) = permeability; return; case _3dHeat: answer.resize(3, 3); answer.at(1, 1) = permeability; answer.at(2, 2) = permeability; answer.at(3, 3) = permeability; return; default: _error2( "giveCharacteristicMatrix : unknown mode (%s)", __MaterialModeToString(mMode) ); } return; }
double LoadTimeFunction :: evaluate(TimeStep *atTime, ValueModeType mode) { if ( mode == VM_Total ) { return this->__at( atTime->giveIntrinsicTime() ); } else if ( mode == VM_Velocity ) { return this->__derAt( atTime->giveIntrinsicTime() ); } else if ( mode == VM_Acceleration ) { return this->__accelAt( atTime->giveIntrinsicTime() ); } else if ( mode == VM_Incremental ) { //return this->__at( atTime->giveTime() ) - this->__at( atTime->giveTime() - atTime->giveTimeIncrement() ); if ( atTime->isTheFirstStep() ) { return this->__at(atTime->giveIntrinsicTime() - this->initialValue); } else { return this->__at( atTime->giveIntrinsicTime() ) - this->__at( atTime->giveIntrinsicTime() - atTime->giveTimeIncrement() ); } } else { _error2("LoadTimeFunction:: evaluate: unsupported mode(%d)", mode); } return 0.; }
void LEPlic :: doLagrangianPhase(TimeStep *atTime) { //Maps element nodes along trajectories using basic Runge-Kutta method (midpoint rule) int i, ci, ndofman = domain->giveNumberOfDofManagers(); int nsd = 2; double dt = atTime->giveTimeIncrement(); DofManager *dman; Node *inode; IntArray velocityMask; FloatArray x, x2(nsd), v_t, v_tn1; FloatMatrix t; #if 1 EngngModel *emodel = domain->giveEngngModel(); int err; #endif velocityMask.setValues(2, V_u, V_v); updated_XCoords.resize(ndofman); updated_YCoords.resize(ndofman); for ( i = 1; i <= ndofman; i++ ) { dman = domain->giveDofManager(i); // skip dofmanagers with no position information if ( ( dman->giveClassID() != NodeClass ) && ( dman->giveClassID() != RigidArmNodeClass ) && ( dman->giveClassID() != HangingNodeClass ) ) { continue; } inode = ( Node * ) dman; // get node coordinates x = * ( inode->giveCoordinates() ); // get velocity field v(tn, x(tn)) for dof manager #if 1 /* Original version */ dman->giveUnknownVector( v_t, velocityMask, EID_MomentumBalance, VM_Total, atTime->givePreviousStep() ); /* Modified version */ //dman->giveUnknownVector(v_t, velocityMask, EID_MomentumBalance, VM_Total, atTime); // Original version // compute updated position x(tn)+0.5*dt*v(tn,x(tn)) for ( ci = 1; ci <= nsd; ci++ ) { x2.at(ci) = x.at(ci) + 0.5 *dt *v_t.at(ci); } // compute interpolated velocity field at x2 [ v(tn+1, x(tn)+0.5*dt*v(tn,x(tn))) = v(tn+1, x2) ] Field *vfield; vfield = emodel->giveContext()->giveFieldManager()->giveField(FT_Velocity); if ( vfield == NULL ) { _error("doLagrangianPhase: Velocity field not available"); } err = vfield->evaluateAt(v_tn1, x2, VM_Total, atTime); if ( err == 1 ) { // point outside domain -> be explicit v_tn1 = v_t; } else if ( err != 0 ) { _error2("doLagrangianPhase: vfield->evaluateAt failed, error code %d", err); } // compute final updated position for ( ci = 1; ci <= nsd; ci++ ) { x2.at(ci) = x.at(ci) + dt *v_tn1.at(ci); } #else // pure explicit version dman->giveUnknownVector(v_t, velocityMask, EID_MomentumBalance, VM_Total, atTime); for ( ci = 1; ci <= nsd; ci++ ) { x2.at(ci) = x.at(ci) + dt *v_t.at(ci); } #endif // store updated node position updated_XCoords.at(i) = x2.at(1); updated_YCoords.at(i) = x2.at(2); } }
/* * Copy a local blob to a local stream. * * Return 0 if stream matches signature, -1 otherwise. * Note: this needs to be folded into sha_fs_get(). */ static int sha_fs_copy(struct request *r, int out_fd) { struct sha_fs_request *sp = (struct sha_fs_request *)r->open_data; int status = 0; blk_SHA_CTX ctx; unsigned char digest[20]; int fd; unsigned char chunk[CHUNK_SIZE]; int nread; static char n[] = "sha_fs_write"; blob_path(r, r->digest); /* * Open the file to the blob. */ switch (_open(r, sp->blob_path, &fd)) { case 0: break; case ENOENT: _warn3(r, n, "open(blob): not found", r->digest); return 1; default: _panic2(r, n, "_open(blob) failed"); } blk_SHA1_Init(&ctx); /* * Read a chunk from the file, write chunk to local stream, * update incremental digest. */ while ((nread = _read(r, fd, chunk, sizeof chunk)) > 0) { if (io_write_buf(out_fd, chunk, nread)) { _error2(r, n, "write_buf() failed"); goto croak; } /* * Update the incremental digest. */ blk_SHA1_Update(&ctx, chunk, nread); } if (nread < 0) _panic2(r, n, "_read(blob) failed"); /* * Finalize the digest. */ blk_SHA1_Final(digest, &ctx); /* * If the calculated digest does NOT match the stored digest, * then zap the blob from storage and get panicy. * A corrupt blob is a bad, bad thang. */ if (memcmp(sp->digest, digest, 20)) _panic3(r, n, "stored blob doesn't match digest", r->digest); goto cleanup; croak: status = -1; cleanup: if (_close(r, &fd)) _panic2(r, n, "_close(blob) failed"); return status; }
static int sha_fs_get(struct request *r) { struct sha_fs_request *sp = (struct sha_fs_request *)r->open_data; int status = 0; blk_SHA_CTX ctx; unsigned char digest[20]; int fd; unsigned char chunk[CHUNK_SIZE]; int nread; blob_path(r, r->digest); /* * Open the file to the blob. */ switch (_open(r, sp->blob_path, &fd)) { case 0: break; case ENOENT: return 1; default: _panic(r, "_open(blob) failed"); } /* * Tell the client we have the blob. */ if (write_ok(r)) { _error(r, "write_ok() failed"); goto croak; } blk_SHA1_Init(&ctx); /* * Read a chunk from the file, write chunk to client, * update incremental digest. * * In principle, we ought to first scan the blob file * before sending "ok" to the requestor. */ while ((nread = _read(r, fd, chunk, sizeof chunk)) > 0) { if (blob_write(r, chunk, nread)) { _error(r, "blob_write(blob chunk) failed"); goto croak; } /* * Update the incremental digest. */ blk_SHA1_Update(&ctx, chunk, nread); } if (nread < 0) _panic(r, "_read(blob) failed"); /* * Finalize the digest. */ blk_SHA1_Final(digest, &ctx); /* * If the calculated digest does NOT match the stored digest, * then zap the blob from storage and get panicy. * A corrupt blob is a bad, bad thang. * * Note: unfortunately we've already deceived the client * by sending "ok". Probably need to improve for * the special case when the entire blob is read * in first chunk. */ if (memcmp(sp->digest, digest, 20)) { _error2(r, "PANIC: stored blob doesn't match digest", r->digest); if (zap_blob(r)) _panic(r, "zap_blob() failed"); goto croak; } goto cleanup; croak: status = -1; cleanup: if (_close(r, &fd)) _panic(r, "_close(blob) failed"); return status; }