TEST(UNIQUE_PTR, object_int)
{
std::unique_ptr<int> val1(new int(1));
msgpack::object obj(val1);
std::unique_ptr<int> val2 = obj.as<std::unique_ptr<int>>();
EXPECT_TRUE(*val1 == *val2);
}
TEST(SHARED_PTR, object_int)
{
std::shared_ptr<int> val1(new int(1));
msgpack::object obj(val1);
std::shared_ptr<int> val2 = obj.as<std::shared_ptr<int>>();
EXPECT_TRUE(*val1 == *val2);
}
Node* IfEqualNodeFactory::do_getNode( const QString &tagContent, Parser *p, bool negate ) const
{
QStringList expr = smartSplit( tagContent );
if ( expr.size() != 3 ) {
throw Grantlee::Exception( TagSyntaxError, QString::fromLatin1( "%1 tag takes two arguments." ).arg( expr.first() ) );
}
QStringList vars;
FilterExpression val1( expr.at( 1 ), p );
FilterExpression val2( expr.at( 2 ), p );
IfEqualNode *n = new IfEqualNode( val1 , val2, negate, p );
const QString endTag( QLatin1String( "end" ) + expr.first() );
NodeList trueList = p->parse( n, QStringList() << QLatin1String( "else" ) << endTag );
n->setTrueList( trueList );
NodeList falseList;
if ( p->takeNextToken().content.trimmed() == QLatin1String( "else" ) ) {
falseList = p->parse( n, QStringList() << endTag );
n->setFalseList( falseList );
p->removeNextToken();
} // else empty falseList.
return n;
}
TEUCHOS_UNIT_TEST( Stokhos_LegendreBasis, EvaluateBasesAndDerivatives ) {
double x = 0.1234;
Teuchos::Array<double> val1(setup.p+1), deriv1(setup.p+1),
val2(setup.p+1), deriv2(setup.p+1);
setup.basis.evaluateBasesAndDerivatives(x, val1, deriv1);
// evaluate bases and derivatives using formula:
// P_0(x) = 1
// P_1(x) = x
// P_i(x) = (2*i-1)/i*x*P_{i-1}(x) - (i-1)/i*P_{i-2}(x), i=2,3,...
// P_0'(x) = 0
// P_1'(x) = 1
// P_i'(x) = i*P_{i-1}(x) + x*P_{i-1}'(x), i=2,3,...
val2[0] = 1.0;
if (setup.p >= 1)
val2[1] = x;
for (int i=2; i<=setup.p; i++)
val2[i] = (2.0*i-1.0)/i*x*val2[i-1] - (i-1.0)/i*val2[i-2];
deriv2[0] = 0.0;
if (setup.p >= 1)
deriv2[1] = 1.0;
for (int i=2; i<=setup.p; i++)
deriv2[i] = i*val2[i-1] + x*deriv2[i-1];
success = Stokhos::compareArrays(val1, "val1", val2, "val2",
setup.rtol, setup.atol, out);
success = success &&
Stokhos::compareArrays(deriv1, "deriv1", deriv2, "deriv2",
setup.rtol, setup.atol, out);
}
TEUCHOS_UNIT_TEST( Stokhos_NormalizedHermiteBasis, EvaluateBasesAndDerivatives ) {
double x = 0.1234;
Teuchos::Array<double> val1(setup.p+1), deriv1(setup.p+1),
val2(setup.p+1), deriv2(setup.p+1);
setup.basis.evaluateBasesAndDerivatives(x, val1, deriv1);
// evaluate bases and derivatives using formula:
// He_0(x) = 1
// He_1(x) = x
// He_i(x) = (x*He_{i-1}(x) - sqrt(i-1)*He_{i-2}(x))/sqrt(i), i=2,3,...
val2[0] = 1.0;
if (setup.p >= 1)
val2[1] = x;
for (int i=2; i<=setup.p; i++)
val2[i] = (x*val2[i-1] - std::sqrt(i-1.0)*val2[i-2])/std::sqrt(1.0*i);
deriv2[0] = 0.0;
if (setup.p >= 1)
deriv2[1] = 1.0;
for (int i=2; i<=setup.p; i++)
deriv2[i] = (val2[i-1] + x*deriv2[i-1] - std::sqrt(i-1.0)*deriv2[i-2]) /
std::sqrt(1.0*i);
success = Stokhos::compareArrays(val1, "val1", val2, "val2",
setup.rtol, setup.atol, out);
success = success &&
Stokhos::compareArrays(deriv1, "deriv1", deriv2, "deriv2",
setup.rtol, setup.atol, out);
}
bool SimpleKeyAgreementValidate(SimpleKeyAgreementDomain &d)
{
if (d.GetCryptoParameters().Validate(GlobalRNG(), 3))
cout << "passed simple key agreement domain parameters validation" << endl;
else
{
cout << "FAILED simple key agreement domain parameters invalid" << endl;
return false;
}
SecByteBlock priv1(d.PrivateKeyLength()), priv2(d.PrivateKeyLength());
SecByteBlock pub1(d.PublicKeyLength()), pub2(d.PublicKeyLength());
SecByteBlock val1(d.AgreedValueLength()), val2(d.AgreedValueLength());
d.GenerateKeyPair(GlobalRNG(), priv1, pub1);
d.GenerateKeyPair(GlobalRNG(), priv2, pub2);
memset(val1.begin(), 0x10, val1.size());
memset(val2.begin(), 0x11, val2.size());
if (!(d.Agree(val1, priv1, pub2) && d.Agree(val2, priv2, pub1)))
{
cout << "FAILED simple key agreement failed" << endl;
return false;
}
if (!VerifyBufsEqual(val1.begin(), val2.begin(), d.AgreedValueLength()))
{
cout << "FAILED simple agreed values not equal" << endl;
return false;
}
cout << "passed simple key agreement" << endl;
return true;
}
void object::test<2>()
{
set_test_name("operator new");
struct test_type
: public utility::new_delete_base_t<test_type>
{
int val_;
test_type()
: val_(0)
{}
test_type(int val)
: val_(val)
{}
operator int() const
{
return val_;
}
};
std::auto_ptr<test_type> val1(new test_type);
}
void object::test<1>()
{
set_test_name("object_factory_test");
struct test_type
{
int val_;
test_type()
: val_(0)
{}
test_type(int val)
: val_(val)
{}
operator int() const
{
return val_;
}
};
typedef std::shared_ptr<test_type> test_type_ptr;
typedef utility::object_factory_t<test_type> type_factory;
test_type_ptr val1(utility::object_allocate<test_type>(), utility::object_deallocate<test_type>);
test_type_ptr val2(utility::object_allocate<test_type>(1), utility::object_deallocate<test_type>);
ensure("val1", *val1 == 0);
ensure("val2", *val2 == 1);
}
int main(int argc, char **argv)
{
typedef my::MyServiceClient client_type;
typedef tht::TSocket socket_type;
typedef tht::TFramedTransport transp_type;
typedef thp::TBinaryProtocol prot_type;
typedef boost::shared_ptr<tht::TSocket> socket_ptr_type;
typedef boost::shared_ptr<tht::TTransport> transp_ptr_type;
typedef boost::shared_ptr<thp::TProtocol> prot_ptr_type;
const int port_num = 9999;
const std::string address("localhost");
socket_ptr_type socket (new socket_type(address, port_num));
transp_ptr_type transport(new transp_type(socket) );
prot_ptr_type protocol (new prot_type(transport));
client_type client(protocol);
try
{
transport->open();
my::MyValue res;
std::string key1("key-1");
std::string val1("value-1");
client.myPut(res, key1, val1);
std::cout
<< std::boolalpha
<< "response: "
<< '(' << res.exists << ',' << res.content << ')'
<< std::endl;
client.myGet(res, key1);
std::cout
<< std::boolalpha
<< "response: "
<< '(' << res.exists << ',' << res.content << ')'
<< std::endl;
}
catch(const thr::TException& e)
{
std::cerr << "error: " << e.what() << std::endl;
}
catch(const std::exception& e)
{
std::cerr << "error: " << e.what() << std::endl;
}
catch(...)
{
std::cerr << "error: " << "unknown" << std::endl;
}
transport->close();
return 0;
}
TEST(MSGPACK_BOOST, object_strinf_view)
{
std::string s = "ABC";
boost::string_view val1(s);
msgpack::object obj(val1);
boost::string_view val2 = obj.as<boost::string_view>();
EXPECT_TRUE(val1 == val2);
}
int main() {
my_type val1("val1");
std::string str1 = std::move(val1);
std::string str2 = a_func_that_returns_my_type();
std::cout << "str1: " << str1 << std::endl;
std::cout << "str2: " << str2 << std::endl;
}
TEST(MSGPACK_BOOST, object_with_zone_string_view)
{
msgpack::zone z;
std::string s = "ABC";
boost::string_view val1(s);
msgpack::object obj(val1, z);
boost::string_view val2 = obj.as<boost::string_view>();
EXPECT_TRUE(val1 == val2);
}
TEST(UNIQUE_PTR, pack_convert_int)
{
std::stringstream ss;
std::unique_ptr<int> val1(new int(1));
msgpack::pack(ss, val1);
msgpack::object_handle oh =
msgpack::unpack(ss.str().data(), ss.str().size());
std::unique_ptr<int> val2 = oh.get().as<std::unique_ptr<int>>();
EXPECT_TRUE(*val1 == *val2);
}
TEST(SHARED_PTR, pack_convert_int)
{
std::stringstream ss;
std::shared_ptr<int> val1(new int(1));
msgpack::pack(ss, val1);
msgpack::unpacked ret;
msgpack::unpack(ret, ss.str().data(), ss.str().size());
std::shared_ptr<int> val2 = ret.get().as<std::shared_ptr<int>>();
EXPECT_TRUE(*val1 == *val2);
}
TEST(MSGPACK_REFERENCE_WRAPPER, object_const)
{
const int i1 = 42;
std::reference_wrapper<const int> val1(i1);
msgpack::object o(val1);
int i2 = 0;
std::reference_wrapper<int> val2(i2);
o.convert(val2);
EXPECT_EQ(i1, i2);
}
TEST(MSGPACK_REFERENCE_WRAPPER, object_with_zone_const)
{
const std::string s1 = "ABC";
std::reference_wrapper<const std::string> val1(s1);
msgpack::zone z;
msgpack::object o(val1, z);
std::string s2 = "DE";
std::reference_wrapper<std::string> val2(s2);
o.convert(val2);
EXPECT_EQ(s1, s2);
}
TEST(MSGPACK_REFERENCE_WRAPPER, pack_convert_const)
{
const int i1 = 42;
std::reference_wrapper<const int> val1(i1);
std::stringstream ss;
msgpack::pack(ss, val1);
msgpack::object_handle oh = msgpack::unpack(ss.str().data(), ss.str().size());
int i2 = 0;
std::reference_wrapper<int> val2(i2);
oh.get().convert(val2);
EXPECT_EQ(i1, i2);
}
TEST(MSGPACK_BOOST, pack_convert_string_view)
{
std::stringstream ss;
std::string s = "ABC";
boost::string_view val1(s);
msgpack::pack(ss, val1);
msgpack::object_handle oh;
msgpack::unpack(oh, ss.str().data(), ss.str().size());
boost::string_view val2 = oh.get().as<boost::string_view>();
EXPECT_TRUE(val1 == val2);
}
int main()
{
RMB val1(2, 50);
RMB val2(2, 48);
if(val1 > val2){
cout << "val1 is more than val2\n";
}
val1 = val1 + val2;
val1.display();
return 0;
}
BigNum<T> Game<T>::connections(T num1, T num2)
{
if (num2 - num1 <= 1)
{
return BigNum<T>("1");
}
/*
if (vecConnections_[num2-num1] > 0)
{
return vecConnections_[num2-num1];
}
*/
if (vecConnections_[num2-num1] == BigNum<T>("0"))
{
BigNum<T> val("0");
T numMid = num1+1;
while (numMid <= num2)
{
BigNum<T> val1("1");
if (num1+1 < numMid)
{
val1 = connections(num1+1,numMid-1);
}
BigNum<T> val2("1");
if (numMid < num2)
{
val2 = connections(numMid+1,num2);
}
val += val1*val2;
numMid += 2;
}
//if (vecConnections_[num2-num1] == 0)
//{
vecConnections_[num2-num1] = val;
//}
return val;
}
else
{
return vecConnections_[num2-num1];
}
}
PRBool
nsAttrValue::Contains(nsIAtom* aValue, nsCaseTreatment aCaseSensitive) const
{
switch (BaseType()) {
case eAtomBase:
{
nsIAtom* atom = GetAtomValue();
if (aCaseSensitive == eCaseMatters) {
return aValue == atom;
}
// For performance reasons, don't do a full on unicode case insensitive
// string comparison. This is only used for quirks mode anyway.
return
nsContentUtils::EqualsIgnoreASCIICase(nsDependentAtomString(aValue),
nsDependentAtomString(atom));
}
default:
{
if (Type() == eAtomArray) {
AtomArray* array = GetAtomArrayValue();
if (aCaseSensitive == eCaseMatters) {
return array->IndexOf(aValue) != AtomArray::NoIndex;
}
nsDependentAtomString val1(aValue);
for (nsCOMPtr<nsIAtom> *cur = array->Elements(),
*end = cur + array->Length();
cur != end; ++cur) {
// For performance reasons, don't do a full on unicode case
// insensitive string comparison. This is only used for quirks mode
// anyway.
if (nsContentUtils::EqualsIgnoreASCIICase(val1,
nsDependentAtomString(*cur))) {
return PR_TRUE;
}
}
}
}
}
return PR_FALSE;
}
TEUCHOS_UNIT_TEST( Stokhos_NormalizedLegendreBasis, EvaluateBasesAndDerivatives ) {
double x = 0.1234;
Teuchos::Array<double> val1(setup.p+1), deriv1(setup.p+1),
val2(setup.p+1), deriv2(setup.p+1);
setup.basis.evaluateBasesAndDerivatives(x, val1, deriv1);
// evaluate bases and derivatives using formula:
// P_0(x) = 1
// P_1(x) = sqrt(3)*x
// P_i(x) = (x*P_{i-1}(x) - b[i-1]*P_{i-2}(x))/b[i], i=2,3,...
// where b[i] = std::sqrt((i*i)/((2.0*i+1.0)*(2.0*i-1.0)))
// P_0'(x) = 0
// P_1'(x) = sqrt(3)
// P_i'(x) = (P_{i-1}(x) + x*P_{i-1}'(x) - b[i-1]*P_{i-2}')/b[i], i=2,3,...
double b1, b2;
b2 = std::sqrt(1.0/3.0);
b1 = b2;
val2[0] = 1.0;
if (setup.p >= 1)
val2[1] = x/b1;
for (int i=2; i<=setup.p; i++) {
b1 = std::sqrt((i*i)/((2.0*i+1.0)*(2.0*i-1.0)));
val2[i] = (x*val2[i-1] - b2*val2[i-2])/b1;
b2 = b1;
}
b2 = std::sqrt(1.0/3.0);
b1 = b2;
deriv2[0] = 0.0;
if (setup.p >= 1)
deriv2[1] = 1.0/b1;
for (int i=2; i<=setup.p; i++) {
b1 = std::sqrt((i*i)/((2.0*i+1.0)*(2.0*i-1.0)));
deriv2[i] = (val2[i-1] + x*deriv2[i-1] - b2*deriv2[i-2])/b1;
b2 = b1;
}
success = Stokhos::compareArrays(val1, "val1", val2, "val2",
setup.rtol, setup.atol, out);
success = success &&
Stokhos::compareArrays(deriv1, "deriv1", deriv2, "deriv2",
setup.rtol, setup.atol, out);
}
bool AuthenticatedKeyAgreementValidate(PK_AuthenticatedKeyAgreementDomain &d)
{
LC_RNG rng(5235);
if (d.ValidateDomainParameters(rng))
cout << "passed authenticated key agreement domain parameters validation" << endl;
else
{
cout << "FAILED authenticated key agreement domain parameters invalid" << endl;
return false;
}
SecByteBlock spriv1(d.StaticPrivateKeyLength()), spriv2(d.StaticPrivateKeyLength());
SecByteBlock epriv1(d.EphemeralPrivateKeyLength()), epriv2(d.EphemeralPrivateKeyLength());
SecByteBlock spub1(d.StaticPublicKeyLength()), spub2(d.StaticPublicKeyLength());
SecByteBlock epub1(d.EphemeralPublicKeyLength()), epub2(d.EphemeralPublicKeyLength());
SecByteBlock val1(d.AgreedValueLength()), val2(d.AgreedValueLength());
d.GenerateStaticKeyPair(rng, spriv1, spub1);
d.GenerateStaticKeyPair(rng, spriv2, spub2);
d.GenerateEphemeralKeyPair(rng, epriv1, epub1);
d.GenerateEphemeralKeyPair(rng, epriv2, epub2);
memset(val1.ptr, 0x10, val1.size);
memset(val2.ptr, 0x11, val2.size);
if (!(d.Agree(val1, spriv1, epriv1, spub2, epub2) && d.Agree(val2, spriv2, epriv2, spub1, epub1)))
{
cout << "FAILED authenticated key agreement failed" << endl;
return false;
}
if (memcmp(val1.ptr, val2.ptr, d.AgreedValueLength()))
{
cout << "FAILED authenticated agreed values not equal" << endl;
return false;
}
cout << "passed authenticated key agreement" << endl;
return true;
}
bool AuthenticatedKeyAgreementValidate(AuthenticatedKeyAgreementDomain &d)
{
if (d.GetCryptoParameters().Validate(GlobalRNG(), 3))
cout << "passed authenticated key agreement domain parameters validation" << endl;
else
{
cout << "FAILED authenticated key agreement domain parameters invalid" << endl;
return false;
}
SecByteBlock spriv1(d.StaticPrivateKeyLength()), spriv2(d.StaticPrivateKeyLength());
SecByteBlock epriv1(d.EphemeralPrivateKeyLength()), epriv2(d.EphemeralPrivateKeyLength());
SecByteBlock spub1(d.StaticPublicKeyLength()), spub2(d.StaticPublicKeyLength());
SecByteBlock epub1(d.EphemeralPublicKeyLength()), epub2(d.EphemeralPublicKeyLength());
SecByteBlock val1(d.AgreedValueLength()), val2(d.AgreedValueLength());
d.GenerateStaticKeyPair(GlobalRNG(), spriv1, spub1);
d.GenerateStaticKeyPair(GlobalRNG(), spriv2, spub2);
d.GenerateEphemeralKeyPair(GlobalRNG(), epriv1, epub1);
d.GenerateEphemeralKeyPair(GlobalRNG(), epriv2, epub2);
memset(val1.begin(), 0x10, val1.size());
memset(val2.begin(), 0x11, val2.size());
if (!(d.Agree(val1, spriv1, epriv1, spub2, epub2) && d.Agree(val2, spriv2, epriv2, spub1, epub1)))
{
cout << "FAILED authenticated key agreement failed" << endl;
return false;
}
if (!VerifyBufsEqual(val1.begin(), val2.begin(), d.AgreedValueLength()))
{
cout << "FAILED authenticated agreed values not equal" << endl;
return false;
}
cout << "passed authenticated key agreement" << endl;
return true;
}
// ----------------------------------------------------------------------
ConstPropertyHandle
PropertySmoothVecTask::
create_property( shawn::SimulationController& sc )
throw( std::runtime_error )
{
shawn::Vec val1( sc.environment().required_double_param("start_x"),
sc.environment().required_double_param("start_y"),
sc.environment().optional_double_param("start_z",0.0) );
shawn::Vec val2( sc.environment().required_double_param("end_x"),
sc.environment().required_double_param("end_y"),
sc.environment().optional_double_param("end_z", 0.0) );
double tim1 = param_start(sc);
double tim3 = param_end(sc);
double tim2 = sc.environment().optional_double_param("reach_time",tim3);
Transition tr = transition(sc.environment().required_string_param("transition"));
PropertySmoothVec* pc = new PropertySmoothVec(val1,val2,tim2,tr);
pc->set_start( tim1 );
pc->set_end( tim3 );
pc->set_priority( param_prio(sc) );
return pc;
}
bool SimpleKeyAgreementValidate(PK_SimpleKeyAgreementDomain &d)
{
LC_RNG rng(5234);
if (d.ValidateDomainParameters(rng))
cout << "passed simple key agreement domain parameters validation" << endl;
else
{
cout << "FAILED simple key agreement domain parameters invalid" << endl;
return false;
}
SecByteBlock priv1(d.PrivateKeyLength()), priv2(d.PrivateKeyLength());
SecByteBlock pub1(d.PublicKeyLength()), pub2(d.PublicKeyLength());
SecByteBlock val1(d.AgreedValueLength()), val2(d.AgreedValueLength());
d.GenerateKeyPair(rng, priv1, pub1);
d.GenerateKeyPair(rng, priv2, pub2);
memset(val1.ptr, 0x10, val1.size);
memset(val2.ptr, 0x11, val2.size);
if (!(d.Agree(val1, priv1, pub2) && d.Agree(val2, priv2, pub1)))
{
cout << "FAILED simple key agreement failed" << endl;
return false;
}
if (memcmp(val1.ptr, val2.ptr, d.AgreedValueLength()))
{
cout << "FAILED simple agreed values not equal" << endl;
return false;
}
cout << "passed simple key agreement" << endl;
return true;
}
TPZCompMesh * ComputationalElasticityMesh3D(TPZGeoMesh *gmesh,int pOrder)
{
// Getting mesh dimension
const int dim = 3;
TPZCompMesh * cmesh = new TPZCompMesh(gmesh);
cmesh->SetDefaultOrder(pOrder);
cmesh->SetDimModel(dim);
{//material da chapa
const REAL Ey = 205000.;
const REAL poisson = 0.3;
const int matid = matchapa;
TPZManVector<STATE,3> fx(3,0.);
TPZElasticity3D * mat = new TPZElasticity3D(matid,Ey,poisson,fx);
mat->SetVonMises(300.);
cmesh->InsertMaterialObject(mat);
}
{//material da trilho1
const REAL Ey = 205000.;
const REAL poisson = 0.3;
const int matid = mattrilho1;
TPZManVector<STATE,3> fx(3,0.);
TPZElasticity3D * mat = new TPZElasticity3D(matid,Ey,poisson,fx);
mat->SetVonMises(690.);
cmesh->InsertMaterialObject(mat);
//int bcsidex = 9;
TPZFNMatrix<9,STATE> val1(3,3,0.), val2(3,1,0.);
val2(0,0) = 1.;
cmesh->InsertMaterialObject(mat->CreateBC(mat, bctrilho1, 3, val1, val2));
}
if(1)
{//material da trilho2
const REAL Ey = 205000.;
const REAL poisson = 0.3;
const int matid = mattrilho2;
TPZManVector<STATE,3> fx(3,0.);
TPZElasticity3D * mat = new TPZElasticity3D(matid,Ey,poisson,fx);
mat->SetVonMises(690.);
cmesh->InsertMaterialObject(mat);
//int bcsidex = 9;
TPZFNMatrix<9,STATE> val1(3,3,0.), val2(3,1,0.);
val2(0,0) = 1.;
cmesh->InsertMaterialObject(mat->CreateBC(mat, bctrilho2, 3, val1, val2));
}
REAL percTracao = 0.1;
{//material do concreto de 40 MPa
const REAL Ey = 35417.;
const REAL poisson = 0.2;
const int matid = matgraut;
TPZManVector<STATE,3> fx(3,0.);
TPZElasticity3D * mat = new TPZElasticity3D(matid,Ey,poisson,fx);
mat->SetMohrCoulomb(40.,percTracao*40.);
cmesh->InsertMaterialObject(mat);
}
{//material do concreto de 30 MPa
const REAL Ey = 27000;
const REAL poisson = 0.2;
const int matid = matenchimento;
TPZManVector<STATE,3> fx(3,0.);
TPZElasticity3D * mat = new TPZElasticity3D(matid,Ey,poisson,fx);
mat->SetMohrCoulomb(30.,percTracao*30.);
cmesh->InsertMaterialObject(mat);
//c.c.
//int bcbottom = 8;
TPZFNMatrix<9,STATE> val1(3,3,0.), val2(3,1,0.);
// val1(0,0) = 1.e-3;
// val1(1,1) = 1.e-3;
// val1(2,2) = 1.e12;
val2(2) = 1.;
cmesh->InsertMaterialObject(mat->CreateBC(mat, bcbottom, 3, val1, val2));
val1.Zero();
val2.Zero();
//int bcsidex = 9;
val2.Zero();
val2(0,0) = 1.;
cmesh->InsertMaterialObject(mat->CreateBC(mat, bcsidex, 3, val1, val2));
//int bcsidey = 10;
val1.Zero();
val2.Zero();
val2(1,0) = 1.;
cmesh->InsertMaterialObject(mat->CreateBC(mat, bcsidey, 3, val1, val2));
//int bcloadtop = 11;
val2.Zero();
val2(2,0) = -800000./120.;
cmesh->InsertMaterialObject(mat->CreateBC(mat, bcloadtop, 1, val1, val2));
// somente para teste de tensao uniforme
// cmesh->InsertMaterialObject(mat->CreateBC(mat, bcloadtopTESTE, 1, val1, val2));//toto
}
cmesh->SetAllCreateFunctionsContinuous();
cmesh->AutoBuild();
return cmesh;
}
TPZCompMesh *ComputationalElasticityMesh2D(TPZAutoPointer<TPZGeoMesh> gmesh,int pOrder)
{
// remove some connectivities 3, 5
TPZGeoEl *gel = gmesh->Element(0);
TPZGeoElSide gelside(gel,3);
gelside.RemoveConnectivity();
gelside.SetSide(5);
gelside.RemoveConnectivity();
gelside.SetSide(4);
TPZGeoElSide neighbour = gelside.NNeighbours();
int matid = neighbour.Element()->MaterialId();
gel->SetMaterialId(matid);
neighbour.Element()->RemoveConnectivities();
int64_t index = neighbour.Element()->Index();
delete neighbour.Element();
gmesh->ElementVec()[index] = 0;
// Plane strain assumption
int planestress = 0;
// Getting mesh dimension
int dim = 2;
TPZMatElasticity2D *materialConcrete;
materialConcrete = new TPZMatElasticity2D(EMatConcrete);
TPZMatElasticity2D *materialSteel;
materialSteel = new TPZMatElasticity2D(EMatSteel);
// Setting up paremeters
materialConcrete->SetfPlaneProblem(planestress);
materialConcrete->SetElasticity(25.e6, 0.25);
materialSteel->SetElasticity(205.e6, 0.25);
//material->SetBiotAlpha(Alpha);cade o metodo?
TPZCompMesh * cmesh = new TPZCompMesh(gmesh);
cmesh->SetDefaultOrder(pOrder);
cmesh->SetDimModel(dim);
TPZFMatrix<STATE> val1(2,2,0.), val2(2,1,0.);
val2(0,0) = 0.0;
val2(1,0) = 0.0;
val1(1,1) = 1.e12;
TPZMaterial * BCond2 = materialConcrete->CreateBC(materialConcrete,EBottom,3, val1, val2);
val2(0,0) = 0.0;
val2(1,0) = 0.0;
val1.Zero();
val1(0,0) = 1.e12;
TPZMaterial * BCond3 = materialConcrete->CreateBC(materialConcrete,ELateral,3, val1, val2);
val2(0,0) = 0.0;
val2(1,0) = -1000.0;
val1.Zero();
TPZMaterial * BCond4 = materialSteel->CreateBC(materialSteel,EBeam,1, val1, val2);
cmesh->SetAllCreateFunctionsContinuous();
cmesh->InsertMaterialObject(materialConcrete);
cmesh->InsertMaterialObject(materialSteel);
cmesh->InsertMaterialObject(BCond2);
cmesh->InsertMaterialObject(BCond3);
cmesh->InsertMaterialObject(BCond4);
cmesh->AutoBuild();
return cmesh;
}
void Constraint<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Apply(const Matrix& P, Matrix& Projected) const {
// We check only row maps. Column may be different.
TEUCHOS_TEST_FOR_EXCEPTION(!P.getRowMap()->isSameAs(*Projected.getRowMap()), Exceptions::Incompatible,
"Row maps are incompatible");
const size_t NSDim = X_->getNumVectors();
const size_t numRows = P.getNodeNumRows();
const Map& colMap = *P.getColMap();
const Map& PColMap = *Projected.getColMap();
Projected.resumeFill();
Teuchos::ArrayView<const LO> indices, pindices;
Teuchos::ArrayView<const SC> values, pvalues;
Teuchos::Array<SC> valuesAll(colMap.getNodeNumElements()), newValues;
LO invalid = Teuchos::OrdinalTraits<LO>::invalid();
LO oneLO = Teuchos::OrdinalTraits<LO>::one();
SC zero = Teuchos::ScalarTraits<SC> ::zero();
SC one = Teuchos::ScalarTraits<SC> ::one();
std::vector<const SC*> Xval(NSDim);
for (size_t j = 0; j < NSDim; j++)
Xval[j] = X_->getData(j).get();
for (size_t i = 0; i < numRows; i++) {
P .getLocalRowView(i, indices, values);
Projected.getLocalRowView(i, pindices, pvalues);
size_t nnz = indices.size(); // number of nonzeros in the supplied matrix
size_t pnnz = pindices.size(); // number of nonzeros in the constrained matrix
newValues.resize(pnnz);
// Step 1: fix stencil
// Projected *must* already have the correct stencil
// Step 2: copy correct stencil values
// The algorithm is very similar to the one used in the calculation of
// Frobenius dot product, see src/Transfers/Energy-Minimization/Solvers/MueLu_CGSolver_def.hpp
// NOTE: using extra array allows us to skip the search among indices
for (size_t j = 0; j < nnz; j++)
valuesAll[indices[j]] = values[j];
for (size_t j = 0; j < pnnz; j++) {
LO ind = colMap.getLocalElement(PColMap.getGlobalElement(pindices[j])); // FIXME: we could do that before the full loop just once
if (ind != invalid)
// index indices[j] is part of template, copy corresponding value
newValues[j] = valuesAll[ind];
else
newValues[j] = zero;
}
for (size_t j = 0; j < nnz; j++)
valuesAll[indices[j]] = zero;
// Step 3: project to the space
Teuchos::SerialDenseMatrix<LO,SC>& XXtInv = XXtInv_[i];
Teuchos::SerialDenseMatrix<LO,SC> locX(NSDim, pnnz, false);
for (size_t j = 0; j < pnnz; j++)
for (size_t k = 0; k < NSDim; k++)
locX(k,j) = Xval[k][pindices[j]];
Teuchos::SerialDenseVector<LO,SC> val(pnnz, false), val1(NSDim, false), val2(NSDim, false);
for (size_t j = 0; j < pnnz; j++)
val[j] = newValues[j];
Teuchos::BLAS<LO,SC> blas;
// val1 = locX * val;
blas.GEMV(Teuchos::NO_TRANS, NSDim, pnnz,
one, locX.values(), locX.stride(),
val.values(), oneLO,
zero, val1.values(), oneLO);
// val2 = XXtInv * val1
blas.GEMV(Teuchos::NO_TRANS, NSDim, NSDim,
one, XXtInv.values(), XXtInv.stride(),
val1.values(), oneLO,
zero, val2.values(), oneLO);
// val = X^T * val2
blas.GEMV(Teuchos::CONJ_TRANS, NSDim, pnnz,
one, locX.values(), locX.stride(),
val2.values(), oneLO,
zero, val.values(), oneLO);
for (size_t j = 0; j < pnnz; j++)
newValues[j] -= val[j];
Projected.replaceLocalValues(i, pindices, newValues);
}
Projected.fillComplete(Projected.getDomainMap(), Projected.getRangeMap()); //FIXME: maps needed?
}
int main() {
//malha geometrica
TPZGeoMesh *firstmesh = new TPZGeoMesh;
firstmesh->SetName("Malha Geometrica : Nós e Elementos");
firstmesh->NodeVec().Resize(10);
TPZVec<REAL> coord(2); //,coordtrans(2);
// REAL ct,st,PI=3.141592654;
// cout << "\nEntre rotacao do eixo n1 (graus) -> ";
// REAL g;
// cin >> g;
// g = g*PI/180.;
// ct = cos(g);
// st = sin(g);
//ct = 1.;
//st = 0.;
//nos geometricos
//no 0
coord[0] = 0;
coord[1] = 0;
// coordtrans[0] = ct*coord[0]-st*coord[1];
// coordtrans[1] = st*coord[0]+ct*coord[1];
firstmesh->NodeVec()[0].Initialize(coord,*firstmesh);
//no 1
coord[0] = 1.;
coord[1] = 0;
// coordtrans[0] = ct*coord[0]-st*coord[1];
// coordtrans[1] = st*coord[0]+ct*coord[1];
firstmesh->NodeVec()[1].Initialize(coord,*firstmesh);
//no 2
coord[0] = 2.;
coord[1] = 0.;
// coordtrans[0] = ct*coord[0]-st*coord[1];
// coordtrans[1] = st*coord[0]+ct*coord[1];
firstmesh->NodeVec()[2].Initialize(coord,*firstmesh);
//no 3
coord[0] = 3.;
coord[1] = 0.;
// coordtrans[0] = ct*coord[0]-st*coord[1];
// coordtrans[1] = st*coord[0]+ct*coord[1];
firstmesh->NodeVec()[3].Initialize(coord,*firstmesh);
//no 4
coord[0] = 4;
coord[1] = 0.;
// coordtrans[0] = ct*coord[0]-st*coord[1];
// coordtrans[1] = st*coord[0]+ct*coord[1];
firstmesh->NodeVec()[4].Initialize(coord,*firstmesh);
//no 5
coord[0] = 0;
coord[1] = 1;
// coordtrans[0] = ct*coord[0]-st*coord[1];
// coordtrans[1] = st*coord[0]+ct*coord[1];
firstmesh->NodeVec()[5].Initialize(coord,*firstmesh);
//no 6
coord[0] = 1.;
coord[1] = 1.;
// coordtrans[0] = ct*coord[0]-st*coord[1];
// coordtrans[1] = st*coord[0]+ct*coord[1];
firstmesh->NodeVec()[6].Initialize(coord,*firstmesh);
//no 7
coord[0] = 2.;
coord[1] = 1.;
// coordtrans[0] = ct*coord[0]-st*coord[1];
// coordtrans[1] = st*coord[0]+ct*coord[1];
firstmesh->NodeVec()[7].Initialize(coord,*firstmesh);
//no 8
coord[0] = 3.;
coord[1] = 1;
// coordtrans[0] = ct*coord[0]-st*coord[1];
// coordtrans[1] = st*coord[0]+ct*coord[1];
firstmesh->NodeVec()[8].Initialize(coord,*firstmesh);
//no 9
coord[0] = 4;
coord[1] = 1;
// coordtrans[0] = ct*coord[0]-st*coord[1];
// coordtrans[1] = st*coord[0]+ct*coord[1];
firstmesh->NodeVec()[9].Initialize(coord,*firstmesh);
/*
TPZVec<int> nodeindexes(3);
nodeindexes[0] = 0;
nodeindexes[1] = 1;
nodeindexes[2] = 2;
//elementos geometricos
TPZGeoElT2d *elg0 = new TPZGeoElT2d(nodeindexes,1,*firstmesh);
nodeindexes[0] = 0;
nodeindexes[1] = 2;
nodeindexes[2] = 3;
TPZGeoElT2d *elg1 = new TPZGeoElT2d(nodeindexes,1,*firstmesh);
nodeindexes[0] = 0;
nodeindexes[1] = 1;
nodeindexes[2] = 2;
TPZGeoElT2d *elg2 = new TPZGeoElT2d(nodeindexes,2,*firstmesh);
nodeindexes[0] = 0;
nodeindexes[1] = 2;
nodeindexes[2] = 3;
TPZGeoElT2d *elg3 = new TPZGeoElT2d(nodeindexes,2,*firstmesh);
*/
TPZVec<int> nodeindexes(4);
//elementos geometricos
TPZGeoEl *elg[4];
nodeindexes[0] = 0;
nodeindexes[1] = 1;
nodeindexes[2] = 6;
nodeindexes[3] = 5;
elg[0] = new TPZGeoElQ2d(nodeindexes,1,*firstmesh);
nodeindexes[0] = 1;
nodeindexes[1] = 2;
nodeindexes[2] = 7;
nodeindexes[3] = 6;
elg[1] = new TPZGeoElQ2d(nodeindexes,1,*firstmesh);
nodeindexes[0] = 2;
nodeindexes[1] = 3;
nodeindexes[2] = 8;
nodeindexes[3] = 7;
elg[2] = new TPZGeoElQ2d(nodeindexes,1,*firstmesh);
nodeindexes[0] = 3;
nodeindexes[1] = 4;
nodeindexes[2] = 9;
nodeindexes[3] = 8;
elg[3] = new TPZGeoElQ2d(nodeindexes,1,*firstmesh);
//Arquivos de saida
ofstream outgm1("outgm1.dat");
ofstream outcm1("outcm1.dat");
ofstream outcm2("outcm2.dat");
//montagem de conectividades entre elementos
firstmesh->BuildConnectivity();
//malha computacional
TPZCompMesh *secondmesh = new TPZCompMesh(firstmesh);
secondmesh->SetName("Malha Computacional : Conectividades e Elementos");
//material
TPZMaterial *pl = LerMaterial("flavio.dat");
secondmesh->InsertMaterialObject(pl);
// pl = LerMaterial("placa2.dat");
// secondmesh->InsertMaterialObject(pl);
// pl = LerMaterial("placa3.dat");
// secondmesh->InsertMaterialObject(pl);
// carregamento hidrostatico no plano vertica xz
pl->SetForcingFunction(PressaoHid);
//CC : condicões de contorno
TPZBndCond *bc;
REAL big = 1.e12;
TPZFMatrix val1(6,6,0.),val2(6,1,0.);
// engastes nos lados 4 e 7 do elemento 0
TPZGeoElBC(elg[0],4,-2,*firstmesh);
TPZGeoElBC(elg[0],7,-2,*firstmesh);
// engaste no lado 4 do elemento 1
TPZGeoElBC(elg[1],4,-2,*firstmesh);
// engaste no lado 4 do elemento 2
TPZGeoElBC(elg[2],4,-2,*firstmesh);
// engaste no lado 4 do elemento 3
TPZGeoElBC(elg[3],4,-2,*firstmesh);
// imposicao do valor zero associado a condicao -2 (engaste)
bc = pl->CreateBC(-2,0,val1,val2);
secondmesh->InsertMaterialObject(bc);
// imposicao da condicao de simetria no lado 5 do elemento 4
val1(0,0)=big;
val1(1,1)=0.;
val1(2,2)=0.;
val1(3,3)=0.;
val1(4,4)=big;
val1(5,5)=big;
TPZGeoElBC(elg[3],5,-3,*firstmesh);
bc = pl->CreateBC(-3,2,val1,val2);
secondmesh->InsertMaterialObject(bc);
//ordem de interpolacao
int ord;
cout << "Entre ordem 1,2,3,4,5 : ";
cin >> ord;
// TPZCompEl::gOrder = ord;
firstmesh.SetDefaultOrder(order);
//construção malha computacional
TPZVec<int> csub(0);
TPZManVector<TPZGeoEl *> pv(4);
int n1=1,level=0;
cout << "\nDividir ate nivel ? ";
int resp;
cin >> resp;
int nelc = firstmesh->ElementVec().NElements();
int el;
TPZGeoEl *cpel;
for(el=0;el<firstmesh->ElementVec().NElements();el++) {
cpel = firstmesh->ElementVec()[el];
if(cpel && cpel->Level() < resp)
cpel->Divide(pv);
}
cout << "\nDividir o elemento esquerdo superior quantas vezes? ";
cin >> resp;
cpel = firstmesh->ElementVec()[0];
for(el=0; el<resp; el++) {
cpel->Divide(pv);
cpel = pv[3];
}
//analysis
secondmesh->AutoBuild();
firstmesh->Print(outgm1);
outgm1.flush();
secondmesh->AdjustBoundaryElements();
secondmesh->InitializeBlock();
secondmesh->Print(outcm1);
TPZAnalysis an(secondmesh,outcm1);
int numeq = secondmesh->NEquations();
secondmesh->Print(outcm1);
outcm1.flush();
TPZVec<int> skyline;
secondmesh->Skyline(skyline);
TPZSkylMatrix *stiff = new TPZSkylMatrix(numeq,skyline);
an.SetMatrix(stiff);
an.Solver().SetDirect(ECholesky);
secondmesh->SetName("Malha Computacional : Connects e Elementos");
// Posprocessamento
an.Run(outcm2);
TPZVec<char *> scalnames(5);
scalnames[0] = "Mn1";
scalnames[1] = "Mn2";
scalnames[2] = "Vn1";
scalnames[3] = "Vn2";
scalnames[4] = "Deslocz";
TPZVec<char *> vecnames(0);
char plotfile[] = "placaPos.pos";
char pltfile[] = "placaView.plt";
an.DefineGraphMesh(2, scalnames, vecnames, plotfile);
an.Print("FEM SOLUTION ",outcm1);
an.PostProcess(3);
an.DefineGraphMesh(2, scalnames, vecnames, pltfile);
an.PostProcess(2);
firstmesh->Print(outgm1);
outgm1.flush();
delete secondmesh;
delete firstmesh;
return 0;
}
