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;
}
