void BucketTest::testBucketId()
{
// Test empty (invalid) buckets
BucketId id1;
BucketId id2;
CPPUNIT_ASSERT_EQUAL(id1, id2);
CPPUNIT_ASSERT(!(id1 < id2) && !(id2 < id1));
CPPUNIT_ASSERT_EQUAL(Hex(0), Hex(id1.getId()));
CPPUNIT_ASSERT_EQUAL(Hex(0), Hex(id1.getRawId()));
CPPUNIT_ASSERT_EQUAL(vespalib::string("BucketId(0x0000000000000000)"),
id1.toString());
CPPUNIT_ASSERT_EQUAL(0u, id1.getUsedBits());
// Test bucket with a value
id2 = BucketId((BucketId::Type(16) << 58) | 0x123);
CPPUNIT_ASSERT(id1 != id2);
CPPUNIT_ASSERT((id1 < id2) && !(id2 < id1));
CPPUNIT_ASSERT_EQUAL(Hex(0x4000000000000123ull), Hex(id2.getId()));
CPPUNIT_ASSERT_EQUAL(Hex(0x4000000000000123ull), Hex(id2.getRawId()));
CPPUNIT_ASSERT_EQUAL(vespalib::string("BucketId(0x4000000000000123)"),
id2.toString());
CPPUNIT_ASSERT_EQUAL(16u, id2.getUsedBits());
// Test copy constructor and operator=
BucketId id3(id2);
CPPUNIT_ASSERT_EQUAL(id2, id3);
id3 = id1;
CPPUNIT_ASSERT(!(id2 == id3));
id3 = id2;
CPPUNIT_ASSERT_EQUAL(id2, id3);
}
bool get_metadata(char *file, MetaData *m)
{
ID3v1 id31(NULL);
ID3v2 id3(NULL);
string url("file://");
FILE *source;
unsigned char buffer[4096];
int bytes;
mp3_info mcontext;
source = fopen(file, "rb");
if (source == NULL)
return false;
mp3_init(&mcontext);
fseek(source, 0, SEEK_SET);
for(;;)
{
bytes = fread(buffer, 1, 4096, source);
if (bytes <= 0)
{
break;
}
mp3_update(&mcontext, buffer, bytes);
}
mp3_final(&mcontext);
if (mcontext.duration > 0)
m->SetTime(mcontext.duration);
url += string(file);
id31.ReadMetaData(url.c_str(), m);
return id3.ReadMetaData(url.c_str(), m);
}
void tst_QOrganizerCollection::idStringFunctions()
{
// TODO: review test
QOrganizerCollectionId id1(makeId("a", 1));
QOrganizerCollectionId id2(makeId("a", 1));
QOrganizerCollectionId id3(makeId("b", 1));
QOrganizerCollectionId id4(makeId("a", 2));
QVERIFY(qHash(id1) == qHash(id2));
QVERIFY(qHash(id1) != qHash(id4));
// note that the toString and fromString functions are
// engine and id specific. This test merely checks that
// the API is hooked up correctly.
QVERIFY(id1.toString() == id2.toString());
QVERIFY(id1.toString() != id3.toString());
QVERIFY(id1.toString() != id4.toString());
QVERIFY(id3.toString() != id4.toString());
// this should "work" -- string of the correct format
QString prebuiltidstring = QString("qtorganizer") + QString(":") + QString("a") + QString("::") + QString::number(2);
QOrganizerCollectionId rebuiltid = QOrganizerCollectionId::fromString(prebuiltidstring);
// QVERIFY(rebuiltid == id4); // -- this requires a working backend.
// this string has the right format and one parameter, but requires a working backend
prebuiltidstring = QString("qtorganizer") + QString(":") + QString("a") + QString(":") + QString("key=value") + QString(":") + QString::number(2);
rebuiltid = QOrganizerCollectionId::fromString(prebuiltidstring);
// QVERIFY(rebuiltid == id4); // -- this requires a working backend.
// this string has the right format and some parameters, but requires a working backend
prebuiltidstring = QString("qtorganizer") + QString(":") + QString("a") + QString(":") + QString("key=value&key2=value2") + QString(":") + QString::number(2);
rebuiltid = QOrganizerCollectionId::fromString(prebuiltidstring);
// QVERIFY(rebuiltid == id4); // -- this requires a working backend.
// this string has the right format but misses the value for a parameter
prebuiltidstring = QString("qtorganizer") + QString(":") + QString("a") + QString(":") + QString("key=value&key2=") + QString(":") + QString::number(2);
rebuiltid = QOrganizerCollectionId::fromString(prebuiltidstring);
// QVERIFY(rebuiltid == id4); // -- this requires a working backend.
// this string misses a field (the parameters)
prebuiltidstring = QString("qtorganizer") + QString(":") + QString("a") + QString(":") + QString::number(2);
rebuiltid = QOrganizerCollectionId::fromString(prebuiltidstring);
QVERIFY(rebuiltid == QOrganizerCollectionId()); // invalid so should be null.
// this string misses two fields (params plus manager uri)
prebuiltidstring = QString("qtorganizer") + QString(":") + QString::number(2);
rebuiltid = QOrganizerCollectionId::fromString(prebuiltidstring);
QVERIFY(rebuiltid == QOrganizerCollectionId()); // invalid so should be null.
// this string misses the prefix (qtorganizer)
prebuiltidstring = QString("notorganizer") + QString(":") + QString("a") + QString("::") + QString::number(2);
rebuiltid = QOrganizerCollectionId::fromString(prebuiltidstring);
QVERIFY(rebuiltid == QOrganizerCollectionId()); // invalid so should be null.
// this string misses the manager uri
prebuiltidstring = QString("notorganizer") + QString(":::") + QString::number(2);
rebuiltid = QOrganizerCollectionId::fromString(prebuiltidstring);
QVERIFY(rebuiltid == QOrganizerCollectionId()); // invalid so should be null.
}
int64_t u8_run_test(int64_t clos, int64_t i, int64_t acc) {
int64_t id1_clos = ((int64_t*)clos)[2];
int64_t id2_clos = ((int64_t*)clos)[3];
int64_t id3_clos = ((int64_t*)clos)[4];
int64_t (*id1)(int64_t, int64_t) =
(int64_t(*)(int64_t, int64_t)) ((int64_t*) id1_clos)[0];
int64_t (*id2)(int64_t, int64_t) =
(int64_t(*)(int64_t, int64_t)) ((int64_t*) id2_clos)[0];
int64_t (*id3)(int64_t, int64_t) =
(int64_t(*)(int64_t, int64_t)) ((int64_t*) id3_clos)[0];
int64_t tmp1 = id1(id1_clos, (1 + acc));
int64_t tmp2 = id2(id2_clos, tmp1);
return id3(id3_clos, tmp2);
}
void JobSupervisorTest::TestResubmit()
{
std::list<Arc::Job> jobs;
std::string id1("http://test.nordugrid.org/1234567890test1"),
id2("http://test.nordugrid.org/1234567890test2"),
id3("http://test.nordugrid.org/1234567890test3");
j.State = Arc::JobStateTEST(Arc::JobState::FAILED);
j.JobID = id1;
j.JobDescriptionDocument = "CONTENT";
jobs.push_back(j);
j.State = Arc::JobStateTEST(Arc::JobState::RUNNING);
j.JobID = id1;
j.JobDescriptionDocument = "CONTENT";
jobs.push_back(j);
usercfg.Broker("TEST");
Arc::ComputingServiceType cs;
Arc::ComputingEndpointType ce;
ce->URLString = "http://test2.nordugrid.org";
ce->InterfaceName = "org.nordugrid.test";
ce->Capability.insert(Arc::Endpoint::GetStringForCapability(Arc::Endpoint::JOBSUBMIT));
ce->HealthState = "ok";
cs.ComputingEndpoint.insert(std::pair<int, Arc::ComputingEndpointType>(0, ce));
cs.ComputingShare.insert(std::pair<int, Arc::ComputingShareType>(0, Arc::ComputingShareType()));
Arc::ComputingManagerType cm;
cm.ExecutionEnvironment.insert(std::pair<int, Arc::ExecutionEnvironmentType>(0, Arc::ExecutionEnvironmentType()));
cs.ComputingManager.insert(std::pair<int, Arc::ComputingManagerType>(0, cm));
Arc::TargetInformationRetrieverPluginTESTControl::targets.push_back(cs);
Arc::TargetInformationRetrieverPluginTESTControl::status = Arc::EndpointQueryingStatus::SUCCESSFUL;
Arc::BrokerPluginTestACCControl::match = true;
js = new Arc::JobSupervisor(usercfg, jobs);
std::list<Arc::Endpoint> services(1, Arc::Endpoint("http://test2.nordugrid.org", Arc::Endpoint::COMPUTINGINFO, "org.nordugrid.tirtest"));
std::list<Arc::Job> resubmitted;
CPPUNIT_ASSERT(js->Resubmit(0, services, resubmitted));
CPPUNIT_ASSERT_EQUAL(2, (int)resubmitted.size());
delete js;
}
void tst_QOrganizerCollection::idHash()
{
// TODO: review tests
QOrganizerCollectionId id1(makeId(QString(), 1));
QOrganizerCollectionId id2(makeId(QString(), 1));
QOrganizerCollectionId id3(makeId(QString(), 2));
QOrganizerCollectionId id4(makeId("a", 1));
QVERIFY(qHash(id1) == qHash(id2));
QVERIFY(qHash(id1) != qHash(id3));
// note that the hash function is dependent on the id type
// in BasicCollectionLocalId, the hash function ignores the managerUri.
QSet<QOrganizerCollectionId> set;
set.insert(id1);
set.insert(id2);
set.insert(id3);
set.insert(id4);
QCOMPARE(set.size(), 3);
}
void tst_QOrganizerCollection::idLessThan()
{
// TODO: review tests
QOrganizerCollectionId id1(makeId("a", 1));
QOrganizerCollectionId id2(makeId("a", 1));
QVERIFY(!(id1 < id2));
QVERIFY(!(id2 < id1));
QVERIFY(id1 == id2);
QOrganizerCollectionId id3(makeId("a", 2));
QOrganizerCollectionId id4(makeId("b", 1));
QOrganizerCollectionId id5(makeId(QString(), 2));
QVERIFY(id1 < id3);
QVERIFY(!(id3 < id1));
QVERIFY(id1 < id4);
QVERIFY(!(id4 < id1));
QVERIFY(id3 < id4);
QVERIFY(!(id4 < id3));
QVERIFY(id5 < id1);
QVERIFY(!(id1 < id5));
}
TEST_F(EnvironmentFactorTest, Operators) {
Id id1("env1");
EnvironmentFactor envFactor1(id1);
Id id2("env2");
EnvironmentFactor envFactor2(id2);
Id id3("a_env");
EnvironmentFactor envFactor3(id3);
EnvironmentFactor envFactor4(id1);
EXPECT_EQ(envFactor4, envFactor1);
EXPECT_FALSE(envFactor1 == envFactor2);
EXPECT_FALSE(envFactor4 == envFactor2);
EXPECT_FALSE(envFactor1 == envFactor3);
EXPECT_FALSE(envFactor4 == envFactor3);
EXPECT_FALSE(envFactor3 == envFactor2);
if(id1 < id2){
EXPECT_TRUE(envFactor1 < envFactor2);
}else{
EXPECT_TRUE(envFactor2 < envFactor1);
}
if(id1 < id3){
EXPECT_TRUE(envFactor1 < envFactor3);
}else{
EXPECT_TRUE(envFactor3 < envFactor1);
}
if(id2 < id3){
EXPECT_TRUE(envFactor2 < envFactor3);
}else{
EXPECT_TRUE(envFactor3 < envFactor2);
}
}
sp<MetaData> MP3Extractor::getMetaData() {
sp<MetaData> meta = new MetaData;
if (mInitCheck != OK) {
return meta;
}
meta->setCString(kKeyMIMEType, "audio/mpeg");
ID3 id3(mDataSource, false);
if (!id3.isValid()) {
return meta;
}
struct Map {
int key;
const char *tag1;
const char *tag2;
};
static const Map kMap[] = {
{ kKeyAlbum, "TALB", "TAL" },
{ kKeyArtist, "TPE1", "TP1" },
{ kKeyAlbumArtist, "TPE2", "TP2" },
{ kKeyComposer, "TCOM", "TCM" },
{ kKeyGenre, "TCON", "TCO" },
{ kKeyTitle, "TIT2", "TT2" },
{ kKeyYear, "TYE", "TYER" },
{ kKeyAuthor, "TXT", "TEXT" },
{ kKeyCDTrackNumber, "TRK", "TRCK" },
{ kKeyDiscNumber, "TPA", "TPOS" },
{ kKeyCompilation, "TCP", "TCMP" },
};
static const size_t kNumMapEntries = sizeof(kMap) / sizeof(kMap[0]);
for (size_t i = 0; i < kNumMapEntries; ++i) {
ID3::Iterator *it = new ID3::Iterator(id3, kMap[i].tag1);
if (it->done()) {
delete it;
it = new ID3::Iterator(id3, kMap[i].tag2);
}
if (it->done()) {
delete it;
continue;
}
String8 s;
it->getString(&s);
delete it;
meta->setCString(kMap[i].key, s);
}
size_t dataSize;
String8 mime;
const void *data = id3.getAlbumArt(&dataSize, &mime);
if (data) {
meta->setData(kKeyAlbumArt, MetaData::TYPE_NONE, data, dataSize);
meta->setCString(kKeyAlbumArtMIME, mime.string());
}
return meta;
}
void DruckerPragerModel<EvalT, Traits>::
computeState(typename Traits::EvalData workset,
std::map<std::string, Teuchos::RCP<PHX::MDField<ScalarT> > > dep_fields,
std::map<std::string, Teuchos::RCP<PHX::MDField<ScalarT> > > eval_fields)
{
// extract dependent MDFields
PHX::MDField<ScalarT> strain = *dep_fields["Strain"];
PHX::MDField<ScalarT> poissons_ratio = *dep_fields["Poissons Ratio"];
PHX::MDField<ScalarT> elastic_modulus = *dep_fields["Elastic Modulus"];
// retrieve appropriate field name strings
std::string cauchy_string = (*field_name_map_)["Cauchy_Stress"];
std::string strain_string = (*field_name_map_)["Strain"];
std::string eqps_string = (*field_name_map_)["eqps"];
std::string friction_string = (*field_name_map_)["Friction_Parameter"];
// extract evaluated MDFields
PHX::MDField<ScalarT> stress = *eval_fields[cauchy_string];
PHX::MDField<ScalarT> eqps = *eval_fields[eqps_string];
PHX::MDField<ScalarT> friction = *eval_fields[friction_string];
PHX::MDField<ScalarT> tangent = *eval_fields["Material Tangent"];
// get State Variables
Albany::MDArray strainold = (*workset.stateArrayPtr)[strain_string + "_old"];
Albany::MDArray stressold = (*workset.stateArrayPtr)[cauchy_string + "_old"];
Albany::MDArray eqpsold = (*workset.stateArrayPtr)[eqps_string + "_old"];
Albany::MDArray frictionold = (*workset.stateArrayPtr)[friction_string + "_old"];
Intrepid::Tensor<ScalarT> id(Intrepid::eye<ScalarT>(num_dims_));
Intrepid::Tensor4<ScalarT> id1(Intrepid::identity_1<ScalarT>(num_dims_));
Intrepid::Tensor4<ScalarT> id2(Intrepid::identity_2<ScalarT>(num_dims_));
Intrepid::Tensor4<ScalarT> id3(Intrepid::identity_3<ScalarT>(num_dims_));
Intrepid::Tensor4<ScalarT> Celastic (num_dims_);
Intrepid::Tensor<ScalarT> sigma(num_dims_), sigmaN(num_dims_), s(num_dims_);
Intrepid::Tensor<ScalarT> epsilon(num_dims_), epsilonN(num_dims_);
Intrepid::Tensor<ScalarT> depsilon(num_dims_);
Intrepid::Tensor<ScalarT> nhat(num_dims_);
ScalarT lambda, mu, kappa;
ScalarT alpha, alphaN;
ScalarT p, q, ptr, qtr;
ScalarT eq, eqN, deq;
ScalarT snorm;
ScalarT Phi;
//local unknowns and residual vectors
std::vector<ScalarT> X(4);
std::vector<ScalarT> R(4);
std::vector<ScalarT> dRdX(16);
for (std::size_t cell(0); cell < workset.numCells; ++cell) {
for (std::size_t pt(0); pt < num_pts_; ++pt) {
lambda = ( elastic_modulus(cell,pt) * poissons_ratio(cell,pt) )
/ ( ( 1 + poissons_ratio(cell,pt) ) * ( 1 - 2 * poissons_ratio(cell,pt) ) );
mu = elastic_modulus(cell,pt) / ( 2 * ( 1 + poissons_ratio(cell,pt) ) );
kappa = lambda + 2.0 * mu / 3.0;
// 4-th order elasticity tensor
Celastic = lambda * id3 + mu * (id1 + id2);
// previous state (the fill doesn't work for state virable)
//sigmaN.fill( &stressold(cell,pt,0,0) );
//epsilonN.fill( &strainold(cell,pt,0,0) );
for (std::size_t i(0); i < num_dims_; ++i) {
for (std::size_t j(0); j < num_dims_; ++j) {
sigmaN(i, j) = stressold(cell, pt, i, j);
epsilonN(i, j) = strainold(cell, pt, i, j);
//epsilon(i,j) = strain(cell,pt,i,j);
}
}
epsilon.fill( &strain(cell,pt,0,0) );
depsilon = epsilon - epsilonN;
alphaN = frictionold(cell,pt);
eqN = eqpsold(cell,pt);
// trial state
sigma = sigmaN + Intrepid::dotdot(Celastic,depsilon);
ptr = Intrepid::trace(sigma) / 3.0;
s = sigma - ptr * id;
snorm = Intrepid::dotdot(s,s);
if(snorm > 0) snorm = std::sqrt(snorm);
qtr = sqrt(3.0/2.0) * snorm;
// unit deviatoric tensor
if (snorm > 0){
nhat = s / snorm;
} else{
nhat = id;
}
// check yielding
Phi = qtr + alphaN * ptr - Cf_;
alpha = alphaN;
p = ptr;
q = qtr;
deq = 0.0;
if(Phi > 1.0e-12) {// plastic yielding
// initialize local unknown vector
X[0] = ptr;
X[1] = qtr;
X[2] = alpha;
X[3] = deq;
LocalNonlinearSolver<EvalT, Traits> solver;
int iter = 0;
ScalarT norm_residual0(0.0), norm_residual(0.0), relative_residual(0.0);
// local N-R loop
while (true) {
ResidualJacobian(X, R, dRdX, ptr, qtr, eqN, mu, kappa);
norm_residual = 0.0;
for (int i = 0; i < 4; i++)
norm_residual += R[i] * R[i];
norm_residual = std::sqrt(norm_residual);
if (iter == 0)
norm_residual0 = norm_residual;
if (norm_residual0 != 0)
relative_residual = norm_residual / norm_residual0;
else
relative_residual = norm_residual0;
//std::cout << iter << " "
//<< Sacado::ScalarValue<ScalarT>::eval(norm_residual)
//<< " " << Sacado::ScalarValue<ScalarT>::eval(relative_residual)
//<< std::endl;
if (relative_residual < 1.0e-11 || norm_residual < 1.0e-11)
break;
if (iter > 20)
break;
// call local nonlinear solver
solver.solve(dRdX, X, R);
iter++;
} // end of local N-R loop
// compute sensitivity information w.r.t. system parameters
// and pack the sensitivity back to X
solver.computeFadInfo(dRdX, X, R);
// update
p = X[0];
q = X[1];
alpha = X[2];
deq = X[3];
}//end plastic yielding
eq = eqN + deq;
s = sqrt(2.0/3.0) * q * nhat;
sigma = s + p * id;
eqps(cell, pt) = eq;
friction(cell,pt) = alpha;
for (std::size_t i(0); i < num_dims_; ++i) {
for (std::size_t j(0); j < num_dims_; ++j) {
stress(cell,pt,i,j) = sigma(i, j);
}
}
}// end loop over pt
} // end loop over cell
}
sp<MetaData> APEExtractor::getMetaData()
{
LOGV("APEExtractor::getMetaData()");
sp<MetaData> meta = new MetaData;
if (mInitCheck != OK)
{
return meta;
}
meta->setCString(kKeyMIMEType, "audio/ape");
ID3 id3(mDataSource);
if (id3.isValid())
{
LOGE("APEExtractor::getMetaData() ID3 id3");
struct Map
{
int key;
const char *tag1;
const char *tag2;
};
static const Map kMap[] =
{
{ kKeyAlbum, "TALB", "TAL" },
{ kKeyArtist, "TPE1", "TP1" },
{ kKeyAlbumArtist, "TPE2", "TP2" },
{ kKeyComposer, "TCOM", "TCM" },
{ kKeyGenre, "TCON", "TCO" },
{ kKeyTitle, "TIT2", "TT2" },
{ kKeyYear, "TYE", "TYER" },
{ kKeyAuthor, "TXT", "TEXT" },
{ kKeyCDTrackNumber, "TRK", "TRCK" },
{ kKeyDiscNumber, "TPA", "TPOS" },
{ kKeyCompilation, "TCP", "TCMP" },
};
static const size_t kNumMapEntries = sizeof(kMap) / sizeof(kMap[0]);
for (size_t i = 0; i < kNumMapEntries; ++i)
{
///LOGE("getMetaData() id3 kMap %d, %d", kNumMapEntries, i);
ID3::Iterator *it = new ID3::Iterator(id3, kMap[i].tag1);
if (it->done())
{
delete it;
it = new ID3::Iterator(id3, kMap[i].tag2);
}
if (it->done())
{
delete it;
continue;
}
String8 s;
it->getString(&s);
delete it;
meta->setCString(kMap[i].key, s);
}
size_t dataSize;
String8 mime;
const void *data = id3.getAlbumArt(&dataSize, &mime);
if (data)
{
meta->setData(kKeyAlbumArt, MetaData::TYPE_NONE, data, dataSize);
meta->setCString(kKeyAlbumArtMIME, mime.string());
}
return meta;
}
APETAG apetag(mDataSource);
if (apetag.isValid())
{
struct ApeMap
{
int key;
const char *tag;
uint16_t key_len;
uint32_t key_attr;
};
static const ApeMap kMap[] =
{
{ kKeyAlbum, "Album", 5, META_TAG_ATTR_ALBUM },
{ kKeyArtist, "Artist", 6, META_TAG_ATTR_ARTIST },
{ kKeyComposer, "Composer", 7, META_TAG_ATTR_AUTHOR },
{ kKeyGenre, "Genre", 5, META_TAG_ATTR_GENRE },
{ kKeyTitle, "Title", 5, META_TAG_ATTR_TITLE },
{ kKeyYear, "Year", 4, META_TAG_ATTR_YEAR },
{ kKeyCDTrackNumber, "Track", 5, META_TAG_ATTR_TRACKNUM },
};
static const size_t kNumMapEntries = sizeof(kMap) / sizeof(kMap[0]);
for (size_t i = 0; i < kNumMapEntries; ++i)
{
APETAG::Iterator *it = new APETAG::Iterator(apetag, kMap[i].tag, kMap[i].key_len);
if (it->done())
{
delete it;
continue;
}
String8 s;
it->getString(&s);
delete it;
meta->setCString(kMap[i].key, s);
}
return meta;
}
return meta;
}
void ElasticDamageModel<EvalT, Traits>::
computeState(typename Traits::EvalData workset,
std::map<std::string, Teuchos::RCP<PHX::MDField<ScalarT>>> dep_fields,
std::map<std::string, Teuchos::RCP<PHX::MDField<ScalarT>>> eval_fields)
{
//bool print = false;
//if (typeid(ScalarT) == typeid(RealType)) print = true;
//cout.precision(15);
// extract dependent MDFields
PHX::MDField<ScalarT> strain = *dep_fields["Strain"];
PHX::MDField<ScalarT> poissons_ratio = *dep_fields["Poissons Ratio"];
PHX::MDField<ScalarT> elastic_modulus = *dep_fields["Elastic Modulus"];
// retrieve appropriate field name strings
std::string cauchy_string = (*field_name_map_)["Cauchy_Stress"];
std::string energy_string = (*field_name_map_)["Matrix_Energy"];
std::string damage_string = (*field_name_map_)["Matrix_Damage"];
std::string tangent_string = (*field_name_map_)["Material Tangent"];
// extract evaluated MDFields
PHX::MDField<ScalarT> stress = *eval_fields[cauchy_string];
PHX::MDField<ScalarT> energy = *eval_fields[energy_string];
PHX::MDField<ScalarT> damage = *eval_fields[damage_string];
PHX::MDField<ScalarT> tangent;
if(compute_tangent_) {
tangent = *eval_fields[tangent_string];
}
// previous state
Albany::MDArray energy_old =
(*workset.stateArrayPtr)[energy_string + "_old"];
ScalarT mu, lame;
ScalarT alpha, damage_deriv;
// Define some tensors for use
Intrepid::Tensor<ScalarT> I(Intrepid::eye<ScalarT>(num_dims_));
Intrepid::Tensor<ScalarT> epsilon(num_dims_), sigma(num_dims_);
Intrepid::Tensor4<ScalarT> Ce(num_dims_);
Intrepid::Tensor4<ScalarT> id4(num_dims_);
Intrepid::Tensor4<ScalarT> id3(Intrepid::identity_3<ScalarT>(num_dims_));
id4 = 0.5 * (Intrepid::identity_1<ScalarT>(num_dims_)
+ Intrepid::identity_2<ScalarT>(num_dims_));
for (int cell = 0; cell < workset.numCells; ++cell) {
for (int pt = 0; pt < num_pts_; ++pt) {
// local parameters
mu = elastic_modulus(cell, pt)
/ (2.0 * (1.0 + poissons_ratio(cell, pt)));
lame = elastic_modulus(cell, pt) * poissons_ratio(cell, pt)
/ (1.0 + poissons_ratio(cell, pt))
/ (1.0 - 2.0 * poissons_ratio(cell, pt));
// small strain tensor
epsilon.fill(strain,cell, pt,0,0);
// undamaged elasticity tensor
Ce = lame * id3 + 2.0 * mu * id4;
// undamaged energy
energy(cell, pt) =
0.5 * Intrepid::dotdot(Intrepid::dotdot(epsilon, Ce), epsilon);
// undamaged Cauchy stress
sigma = Intrepid::dotdot(Ce, epsilon);
// maximum thermodynamic force
alpha = energy_old(cell, pt);
if (energy(cell, pt) > alpha) alpha = energy(cell, pt);
// damage term
damage(cell, pt) = max_damage_
* (1 - std::exp(-alpha / saturation_));
// derivative of damage w.r.t alpha
damage_deriv =
max_damage_ / saturation_ * std::exp(-alpha / saturation_);
// tangent for matrix considering damage
if(compute_tangent_) {
Ce = (1.0 - damage(cell, pt)) * Ce
- damage_deriv * Intrepid::tensor(sigma, sigma);
}
// total Cauchy stress
for (int i(0); i < num_dims_; ++i) {
for (int j(0); j < num_dims_; ++j) {
stress(cell, pt, i, j) =
(1.0 - damage(cell, pt)) * sigma(i, j);
}
}
// total tangent
if(compute_tangent_) {
for (int i(0); i < num_dims_; ++i) {
for (int j(0); j < num_dims_; ++j) {
for (int k(0); k < num_dims_; ++k) {
for (int l(0); l < num_dims_; ++l) {
tangent(cell, pt, i, j, k, l) = Ce(i, j, k, l);
}
}
}
}
}// compute_tangent_
} // pt
} // cell
}
int main(int argc, char **argv)
{
bool fail = false;
//
// now create a domain and a modelbuilder
// and build the model
//
FEM_ObjectBroker theBroker;
Domain *theDomain = new Domain();
FileDatastore *theDatabase
= new FileDatastore("/tmp/database/test1",*theDomain,theBroker);
FileDatastore &theDb = *theDatabase;
opserr << "TESTING IDs: \n";
ID id1(2);
id1(0) = 1;
id1(1) = 1;
ID id0(2);
id0(0) = 0;
id0(1) = 0;
ID id2(2);
id2(0) = 2;
id2(1) = 2;
ID id3(2);
id3(0) = 3;
id3(1) = 3;
ID id4(2);
id4(0) = 4;
id4(1) = 4;
ID id5(2);
id5(0) = 5;
id5(1) = 5;
ID id6(2);
id6(0) = 6;
id6(1) = 6;
theDb.sendID(1,1,id1);
theDb.sendID(1,2,id2);
theDb.sendID(2,1,id3);
theDb.sendID(2,2,id4);
opserr << "RESULTS\n";
ID recvID(2);
theDb.recvID(1,1,recvID);
opserr << "1: " << recvID;
theDb.recvID(1,2,recvID);
opserr << "2: " << recvID;
theDb.recvID(2,1,recvID);
opserr << "3: " << recvID;
theDb.recvID(2,2,recvID);
opserr << "4: " << recvID;
theDb.sendID(1,1,id1);
theDb.sendID(3,1,id3);
theDb.sendID(2,1,id2);
theDb.sendID(0,1,id0);
theDb.sendID(1,2,id1);
theDb.sendID(2,2,id2);
theDb.sendID(3,1,id3);
theDb.sendID(5,1,id5);
theDb.sendID(4,1,id4);
theDb.sendID(1,1,id1);
theDb.recvID(3,1,id5);
opserr << "3: " << id5;
theDb.recvID(1,1,id5);
opserr << "1: " << id5;
theDb.recvID(2,1,id5);
opserr << "2: " << id5;
theDb.recvID(1,2,id5);
opserr << "1: " << id5;
theDb.recvID(2,2,id5);
opserr << "3: " << id5;
theDb.recvID(3,1,id5);
opserr << "3: " << id5;
theDb.recvID(4,1,id5);
opserr << "4: " << id5;
theDb.recvID(5,1,id5);
opserr << "5: " << id5;
opserr << "FAILURE: " << theDb.recvID(6,1,id5) << " returned\n";
opserr << "FAILURE " << theDb.recvID(6,1,id5) << " returned\n";
theDb.recvID(0,1,id5);
opserr << "0: " << id5;
theDb.recvID(5,1,id5);
opserr << "5: " << id5;
ID id64(4);
id64(0) = 6;
id64(1) = 6;
id64(2) = 6;
id64(3) = 6;
theDb.sendID(6,1,id64);
theDb.recvID(6,1,id64);
opserr << id64;
opserr << "TESTING MATRICES: \n";
Matrix mat1(2,2);
mat1(0,0) = 1.1;
mat1(0,1) = 11.1;
mat1(1,0) = 111.1;
mat1(1,1) = 1111.1;
Matrix mat2(2,2);
mat2(0,0) = 2.2;
mat2(0,1) = 22.2;
mat2(1,0) = 222.2;
mat2(1,1) = 2222.2;
theDb.sendMatrix(2,1,mat2);
theDb.sendMatrix(1,1,mat1);
theDb.sendMatrix(3,2,mat2);
theDb.sendMatrix(3,1,mat1);
Matrix mat3(2,2);
theDb.recvMatrix(1,1,mat3);
opserr << mat1 << mat3 << endln;
theDb.recvMatrix(2,1,mat3);
opserr << mat2 << mat3 << endln;
theDb.recvMatrix(3,2,mat3);
opserr << mat2 << mat3 << endln;
theDb.recvMatrix(3,1,mat3);
opserr << mat1 << mat3 << endln;
// theDb.sendMatrix(2,1,mat1);
theDb.recvMatrix(2,1,mat3);
opserr << mat2 << mat3;
opserr << "TESTING VECTORS: \n";
Vector vect1(2);
vect1(0) = 1.1;
vect1(1) = 2.22;
Vector vect2(2);
vect2(0) = 3;
vect2(1) = 4.2;
Vector vect3(2);
vect3(0) = 5;
vect3(1) = 6;
Vector vect4(2);
vect4(0) = 7;
vect4(1) = 8.8e12;
theDb.sendVector(1,1,vect1);
theDb.sendVector(1,2,vect2);
theDb.sendVector(2,1,vect3);
theDb.sendVector(2,2,vect4);
opserr << "RESULTS\n";
Vector vect5(2);
theDb.recvVector(1,1,vect5);
opserr << vect1 << vect5 << endln;
theDb.recvVector(1,2,vect5);
opserr << vect2 << vect5 << endln;
theDb.recvVector(2,1,vect5);
opserr << vect3 << vect5 << endln;
theDb.recvVector(2,2,vect5);
opserr << vect4 << vect5 << endln;
theDb.sendVector(2,2,vect1);
theDb.sendVector(2,1,vect2);
theDb.sendVector(1,2,vect3);
theDb.sendVector(1,1,vect4);
theDb.recvVector(1,1,vect5);
opserr << vect4 << vect5 << endln;
theDb.recvVector(1,2,vect5);
opserr << vect3 << vect5 << endln;
theDb.recvVector(2,1,vect5);
opserr << vect2 << vect5 << endln;
theDb.recvVector(2,2,vect5);
opserr << vect1 << vect5 << endln;
theDb.sendVector(4,4,vect5);
theDb.recvVector(4,4,vect5);
opserr << vect5 << vect5 << endln;
theDb.recvVector(5,5,vect5);
opserr << "FAIL\n";
theDatabase->commitState(0);
/* */
/*
theDb.sendID(2,2,id1);
theDb.sendID(2,1,id2);
theDb.sendID(1,2,id3);
theDb.sendID(1,1,id4);
theDb.recvID(1,1,id5);
opserr << id5;
theDb.recvID(1,2,id5);
opserr << id5;
theDb.recvID(2,1,id5);
opserr << id5;
theDb.recvID(2,2,id5);
opserr << id5;
theDb.sendID(4,4,id5);
theDb.recvID(4,4,id5);
opserr << id5;
theDb.recvID(5,5,id5);
opserr << id5;
*/
/**************************
**************************/
/*
*/
// theModelBuilder->buildFE_Model();
// theDb.commitState(0);
// theDb.restoreState(0);
// theDb.restoreElements(0);
/*
theDb.restoreNode(1,0);
theDb.restoreNode(2,0);
theDb.restoreNode(3,0);
theDb.restoreNode(4,0);
theDb.restoreElement(0,0);
theDb.restoreElement(1,0);
theDb.restoreElement(2,0);
*/
// opserr << *theDomain;
delete theDatabase;
exit(0);
}
