ChatWindow::~ChatWindow()
{
delete ui;
QMapIterator<QString, Serveur*> i(serveurs);
while(i.hasNext())
{
i.next();
QMapIterator<QString, QTextEdit*> i2(i.value()->conversations);
while(i2.hasNext()) {
i2.next();
i.value()->sendData("QUIT " + i2.key() + " ");
}
}
}
double Overlap::computeCoordEnergy(node v1, node v2, const DPoint &p1, const DPoint &p2)
const
{
IntersectionRectangle i1(shape(v1)), i2(shape(v2));
i1.move(p1);
i2.move(p2);
IntersectionRectangle intersection = i1.intersection(i2);
double area = intersection.area();
if(area < 0.0) {
OGDF_ASSERT(area > -0.00001);
area = 0.0;
}
double minArea = min(i1.area(),i2.area());
double energy = area / minArea;
return energy;
}
int main()
{
try
{
Integer a,a1(10),a3,a4("123");
Integer a2(a1);
cout<<"\nConstructors\n ";
cout<<"\nDefault -a : "<<a;
cout<<"\nOne argumented -a1 : "<<a1;
cout<<"\nCopy Constructor -a2 : "<<a2;
cout<<"\nString constructor -a4 : "<<a4;
cout<<"\n\nOperations \n";
a3=a1;
cout<<"\n a3=a1: "<<a3;
a=a1+a2;
cout<<"\n a=a1+a2: "<<a;
a3=a-a2;
cout<<"\n a3=a-a2: "<<a;
cout<<"\n a3 : "<<a3;
if(a>a3)
{
cout<<"\n a>a3\n";
cout<<"\n a3-- : "<<a3--;
cout<<"\n --a3 : "<<--a3;
cout<<"\n ++a3 : "<<++a3;
cout<<"\n a3++ : "<<a3++;
cout<<"\n a3 : "<<a3<<"\n";
}
cout<<" a4 : "<<a4<<"\n";
Integer i1(-4), i2(10);
cout << "i1: " << i1 << endl;
cout << "OR : It is " << ((i1 || i2) ? "true" : "false") << endl;
cout << "AND : It is " << ((i1 && i2 ) ? "true" : "false") << endl;
cout << "NOT : It is " << ((! i1) ? "true" : "false") << endl;
cout<<"\n>>";
cin>>a3;
cout<<" \n a3 : "<<a3<<"\n";
string a5=a4.to_string();
cout<<"a5=a4.to_string() : "<<a5<<"\n";
}
catch(Integer::Invalid_argument)
{
cout<<"\nInvalid Argument \n";
}
return 0;
}
inline void filter(const std::string &prefix,F func)
{
while (!_ready) {
Thread::sleep(250);
_ready = _reload(_basePath,std::string());
}
for(std::map<std::string,_E>::iterator i(_db.lower_bound(prefix));i!=_db.end();) {
if ((i->first.length() >= prefix.length())&&(!memcmp(i->first.data(),prefix.data(),prefix.length()))) {
if (!func(i->first,get(i->first))) {
std::map<std::string,_E>::iterator i2(i); ++i2;
this->erase(i->first);
i = i2;
} else ++i;
} else break;
}
}
void ChatWindow::disconnectFromServer() {
QMapIterator<QString, Serveur*> i(serveurs);
while (i.hasNext()) {
i.next();
QMapIterator<QString, QTextEdit*> i2(i.value()->conversations);
while (i2.hasNext()) {
i2.next();
i.value()->sendData("QUIT " + i2.key() + " ");
}
}
ui->splitter->hide();
ui->hide3->show();
}
void ChatWindow::closeEvent(QCloseEvent *event)
{
(void) event;
QMapIterator<QString, Serveur*> i(serveurs);
while(i.hasNext())
{
i.next();
QMapIterator<QString, QTextEdit*> i2(i.value()->conversations);
while(i2.hasNext())
{
i2.next();
i.value()->sendData("QUIT "+i2.key() + " ");
}
}
}
static int call(I0 const& i0, F f)
{
int ct = 0;
if(f(*i0))
++ct;
typedef typename result_of::next<I0>::type I1;
I1 i1(fusion::next(i0));
if(f(*i1))
++ct;
typedef typename result_of::next<I1>::type I2;
I2 i2(fusion::next(i1));
if(f(*i2))
++ct;
return ct;
}
void testIntersect1()
{
BallTypeList b;
for(int i = 0; i < 500; ++i) {
b.push_back(BallType(VectorType::Random(), 0.5 * ei_random(0., 1.)));
}
KdBVH<double, Dim, BallType> tree(b.begin(), b.end());
VectorType pt = VectorType::Random();
BallPointStuff<Dim> i1(pt), i2(pt);
for(int i = 0; i < (int)b.size(); ++i)
i1.intersectObject(b[i]);
BVIntersect(tree, i2);
VERIFY(i1.count == i2.count);
}
int main(int argc, char **argv) {
JuGuiApp app(argc, argv);
//JuTimer timer;
JuView v;
v.setBgColor(0, 255, 255, 255);
JuImageItem i1(10, 10, 279, 204, "tv.png", &v);
JuImageItem i2(10, 150, 128, 128, "local.png", &v);
JuImageItem i3(10, 250, 128, 128, "musics.png", &v);
//app.addView(&v);
//JuRectItem r(100, 100, 800, 600, &v);
//v.addItem(&r);
v.addItem(&i1);
v.addItem(&i2);
v.addItem(&i3);
//timer.start(5000);
v.update();
return app.exec();
}
TEST(TypesTests, ValuedVectorConstructors) {
float2 f2(1.1f, -2.0f);
EXPECT_EQ(1.1f, f2.x);
EXPECT_EQ(-2.0f, f2.y);
float3 f3(1.2f, -2.0f, 4.0f);
EXPECT_EQ(1.2f, f3.x);
EXPECT_EQ(-2.0f, f3.y);
EXPECT_EQ(4.0f, f3.z);
int2 i2(-2, 3.2f);
EXPECT_EQ(-2, i2.x);
EXPECT_EQ(3, i2.y);
int3 i3(-2, 2000, 0);
EXPECT_EQ(-2, i3.x);
EXPECT_EQ(2000, i3.y);
EXPECT_EQ(0, i3.z);
}
static void tst1() {
ast_manager m;
family_id fid = m.get_basic_family_id();
sort_ref b(m.mk_bool_sort(), m);
expr_ref a(m.mk_const(symbol("a"), b.get()), m);
expr_ref c(m.mk_const(symbol("c"), b.get()), m);
expr_ref i1(m.mk_app(fid, OP_AND, a.get(), c.get()), m);
expr_ref i2(m.mk_app(fid, OP_AND, a.get(), c.get()), m);
expr_ref i3(m.mk_app(fid, OP_OR, a.get(), c.get()), m);
SASSERT(i1.get() == i2.get());
SASSERT(i1.get() != i3.get());
// TODO use smart pointers to track references
// ast_manager m;
// ast_ref<numeral_ast> n1(m.mk_numeral(rational(2,3)), m);
// ast_ref<numeral_ast> n2(m.mk_numeral(rational(2,3)), m);
// SASSERT(n1 == n2);
// ast_ref<numeral_ast> n3(m.mk_numeral(rational(1,2)), m);
// SASSERT(n1 != n3);
// ast_ref<var_ast> v1 (m.mk_var(1), m);
// ast_ref<var_ast> v2 (m.mk_var(2), m);
// ast_ref<var_ast> v3 (m.mk_var(1), m);
// SASSERT(v1 != v2);
// SASSERT(v1 == v3);
// TRACE("ast", tout << "reseting v1\n";);
// v1.reset();
// TRACE("ast", tout << "overwriting v3\n";);
// v3 = v2;
// ast_ref<type_decl_ast> t1(m.mk_type_decl(symbol("int"), 0), m);
// ast_ref<type_ast> i(m.mk_type(t1.get(), 0, 0), m);
// ast_ref<const_decl_ast> foo_decl(m.mk_const_decl(symbol("foo"), i.get(), i.get()), m);
// ast_ref<const_decl_ast> x_decl(m.mk_const_decl(symbol("x"), i.get()), m);
// ast_ref<const_ast> x(m.mk_const(x_decl.get()), m);
// ast_ref<const_ast> foo_x(m.mk_const(foo_decl.get(), x.get()), m);
// ast_ref<const_ast> foo_foo_x(m.mk_const(foo_decl.get(), foo_x.get()), m);
// ast_ref<const_ast> foo_foo_x2(m.mk_const(foo_decl.get(), m.mk_const(foo_decl.get(), m.mk_const(x_decl.get()))), m);
// SASSERT(foo_foo_x2 == foo_foo_x);
}
void readable_iterator_test(const Iterator i1, T v)
{
Iterator i2(i1); // Copy Constructible
typedef typename detail::iterator_traits<Iterator>::reference ref_t;
ref_t r1 = *i1;
ref_t r2 = *i2;
T v1 = r1;
T v2 = r2;
assert(v1 == v);
assert(v2 == v);
# if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
readable_iterator_traversal_test(i1, v, detail::is_postfix_incrementable<Iterator>());
// I think we don't really need this as it checks the same things as
// the above code.
BOOST_STATIC_ASSERT(is_readable_iterator<Iterator>::value);
# endif
}
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static int call(I0 const& i0, F f)
{
int ct = 0;
if(f(*i0))
++ct;
typedef typename result_of::next<I0>::type I1;
I1 i1(fusion::next(i0));
if(f(*i1))
++ct;
typedef typename result_of::next<I1>::type I2;
I2 i2(fusion::next(i1));
if(f(*i2))
++ct;
return ct;
}
Real32 interpolatedNoise(const Pnt2f& t, UInt32 & octave, UInt32 UInt32, bool Smoothing)
{
Real32 intX(osgFloor(t[0])), intY(osgFloor(t[1]));
Real32 fractionX = t[0] - intX;
Real32 fractionY = t[1] - intY;
Real32 i1(0.0f), i2(0.0f), returnValue(0.0f);
if(Smoothing)
{
if(UInt32 == PERLIN_INTERPOLATE_COSINE)
{
i1 = interpolateCosine(smoothNoise(intX, intY, octave),smoothNoise(intX + 1.0f, intY, octave), fractionX);
intY += 1.0f;
i2 = interpolateCosine(smoothNoise(intX, intY, octave),smoothNoise(intX + 1.0f, intY, octave), fractionX);
returnValue = interpolateCosine(i1 , i2 , fractionY);
}
else if (UInt32 == PERLIN_INTERPOLATE_LINEAR)
{
i1 = interpolateLinear(smoothNoise(intX, intY, octave),smoothNoise(intX + 1.0f, intY, octave), fractionX);
intY += 1.0f;
i2 = interpolateLinear(smoothNoise(intX, intY, octave),smoothNoise(intX + 1.0f, intY, octave), fractionX);
returnValue = interpolateLinear(i1 , i2 , fractionY);
}
} else
{
if(UInt32 == PERLIN_INTERPOLATE_COSINE)
{
i1 = interpolateCosine(getNoise(intX, intY, octave),getNoise(intX + 1.0f, intY, octave), fractionX);
intY += 1.0f;
i2 = interpolateCosine(getNoise(intX, intY, octave),getNoise(intX + 1.0f, intY, octave), fractionX);
returnValue = interpolateCosine(i1 , i2 , fractionY);
}
else if (UInt32 == PERLIN_INTERPOLATE_LINEAR)
{
i1 = interpolateLinear(getNoise(intX, intY, octave),getNoise(intX + 1.0f, intY, octave), fractionX);
intY += 1.0f;
i2 = interpolateLinear(getNoise(intX, intY, octave),getNoise(intX + 1.0f, intY, octave), fractionX);
returnValue = interpolateLinear(i1 , i2 , fractionY);
}
}
return returnValue;
}
QList<QPair<QByteArray, QByteArray> > from(lua_State* L, int index)
{
object obj(luabind::from_stack(L,index));
QList<QPair<QByteArray, QByteArray> > res;
for(iterator i(obj),e; i!=e; ++i){
if(type(*i) == LUA_TTABLE){
object p1,p2;
QPair<QByteArray, QByteArray> arr;
for(iterator i2(*i),e2; i2!=e2; ++i2){
if(!p1) p1 = *i2;
else if(!p2) p2 = *i2;
else break;
}
if(p1 && p1 && type(p1) == LUA_TTABLE && type(p2) == LUA_TTABLE){
res.append(QPair<QByteArray, QByteArray>(byteArrayFromObject(p1),byteArrayFromObject(p2)));
}
}
}
return res;
}
QList<QPair<T1, T2> > from(lua_State* L, int index)
{
object obj(luabind::from_stack(L,index));
QList<QPair<T1, T2> > res;
for(iterator i(obj),e; i!=e; ++i){
if(type(*i) == LUA_TTABLE){
object p1,p2;
QPair<T1, T2> arr;
for(iterator i2(*i),e2; i2!=e2; ++i2){
if(!p1) p1 = *i2;
else if(!p2) p2 = *i2;
else break;
}
if(p1 && p1 && is_class<T1>(p1) && is_class<T2>(p2)){
res.append(QPair<T1, T2>(object_cast<T1>(p1), object_cast<T2>(p2)));
}
}
}
return res;
}
void non_const_lvalue_iterator_test(Iterator i, T v1, T v2)
{
Iterator i2(i);
typedef typename detail::iterator_traits<Iterator>::value_type value_type;
typedef typename detail::iterator_traits<Iterator>::reference reference;
BOOST_STATIC_ASSERT((is_same<value_type&, reference>::value));
T& v3 = *i2;
assert(v1 == v3);
// A non-const lvalue iterator is not neccessarily writable, but we
// are assuming the value_type is assignable here
*i = v2;
T& v4 = *i2;
assert(v2 == v4);
# ifndef BOOST_NO_LVALUE_RETURN_DETECTION
BOOST_STATIC_ASSERT(is_lvalue_iterator<Iterator>::value);
BOOST_STATIC_ASSERT(is_non_const_lvalue_iterator<Iterator>::value);
# endif
}
void testMinimize1()
{
BallTypeList b;
for(int i = 0; i < 500; ++i) {
b.push_back(BallType(VectorType::Random(), 0.01 * ei_random(0., 1.)));
}
KdBVH<double, Dim, BallType> tree(b.begin(), b.end());
VectorType pt = VectorType::Random();
BallPointStuff<Dim> i1(pt), i2(pt);
double m1 = std::numeric_limits<double>::max(), m2 = m1;
for(int i = 0; i < (int)b.size(); ++i)
m1 = std::min(m1, i1.minimumOnObject(b[i]));
m2 = BVMinimize(tree, i2);
VERIFY_IS_APPROX(m1, m2);
}
TEST(TypesTests, VectorNormalize) {
float2 f2(-2.0, 1.0);
float2 f2_n = f2.normalize();
EXPECT_FLOAT_EQ(1.0, f2_n.length());
EXPECT_FLOAT_EQ(-0.894427191, f2_n.x);
EXPECT_FLOAT_EQ(0.4472135955, f2_n.y);
// f2 is unchanged?
EXPECT_FLOAT_EQ(-2.0, f2.x);
EXPECT_FLOAT_EQ(1.0, f2.y);
float3 f3(-2.0, 1.0, 2.4);
float3 f3_n = f3.normalize();
EXPECT_FLOAT_EQ(1.0, f3_n.length());
EXPECT_FLOAT_EQ(-0.6097107608, f3_n.x);
EXPECT_FLOAT_EQ(0.3048553804, f3_n.y);
EXPECT_FLOAT_EQ(0.731652913, f3_n.z);
// f3 is unchanged?
EXPECT_FLOAT_EQ(-2.0, f3.x);
EXPECT_FLOAT_EQ(1.0, f3.y);
EXPECT_FLOAT_EQ(2.4, f3.z);
int2 i2(-2,1);
float2 i2_n = i2.normalize();
EXPECT_FLOAT_EQ(1.0, i2_n.length());
EXPECT_FLOAT_EQ(-0.894427191, i2_n.x);
EXPECT_FLOAT_EQ(0.4472135955, i2_n.y);
// f2 is unchanged?
EXPECT_EQ(-2, i2.x);
EXPECT_EQ(1, i2.y);
int3 i3(-2, 1, 2);
float3 i3_n = i3.normalize();
EXPECT_FLOAT_EQ(1.0, i3_n.length());
EXPECT_FLOAT_EQ(-0.6666666667, i3_n.x);
EXPECT_FLOAT_EQ(0.3333333333, i3_n.y);
EXPECT_FLOAT_EQ(0.6666666667, i3_n.z);
// f3 is unchanged?
EXPECT_EQ(-2, i3.x);
EXPECT_EQ(1, i3.y);
EXPECT_EQ(2, i3.z);
}
int main(){
//value | weight
Item i1(2,4);
Item i2(4,6);
Item i3(5,7);
std::vector<Item> items;
items.push_back(i1);
items.push_back(i2);
items.push_back(i3);
int available_weight = 10;
WeightMap weights(available_weight+1,0);
BestValueMap best_value_map(items.size(),weights);
std::cout<<"KS"<<std::endl;
int result = KSrecursive(items,best_value_map,items.size()-1,available_weight);
std::cout<<"Best value :"<<result<<std::endl;
//system("PAUSE");
}
void Node::debugPrint()
{
if (name == "")
{
printf("Not printing debug information because 'name' wasn't set.\n");
return;
}
QHashIterator<QString, QSet<Node*>*> i(*connections);
while(i.hasNext())
{
i.next();
QString string = i.key();
QSet<Node*>* set = i.value();
printf("%s FORWARD ON %s -> [ ", this->name.toStdString().c_str(), string.toStdString().c_str());
QSetIterator<Node*> j(*set);
while (j.hasNext())
{
printf("%s ", j.next()->name.toStdString().c_str());
}
printf("]\n");
}
QHashIterator<QString, QSet<Node*>*> i2(*reverseConnections);
while(i2.hasNext())
{
i2.next();
QString string2 = i2.key();
QSet<Node*>* set2 = i2.value();
printf("%s BACKWARD ON %s -> [ ", this->name.toStdString().c_str(), string2.toStdString().c_str());
QSetIterator<Node*> j2(*set2);
while (j2.hasNext())
{
printf("%s ", j2.next()->name.toStdString().c_str());
}
printf("]\n");
}
}
void tst_pods::testMarshalling()
{
QByteArray ba;
QDataStream ds(&ba, QIODevice::ReadWrite);
{
PodI i1(1), i2(2), i3(3), iDeadBeef(0xdeadbeef);
ds << i1 << i2 << i3 << iDeadBeef;
}
ds.device()->seek(0);
{
PodI i1, i2, i3, iDeadBeef;
ds >> i1 >> i2 >> i3 >> iDeadBeef;
QCOMPARE(i1.i(), 1);
QCOMPARE(i2.i(), 2);
QCOMPARE(i3.i(), 3);
QCOMPARE(iDeadBeef.i(), int(0xdeadbeef));
}
}
void AuctionAction::doAuction(){
qDebug () << "AuctionAction::doAuction# ";
QMapIterator<quint16, AuctionPlayerModel*> i(auctionPlayers);
while (i.hasNext()) {
i.next();
qDebug() << i.key() << " -> " << *(i.value()->getGamePlayer()->getPlayerModel()->getName()) << endl;
}
AuctionPlayerModel* resultPlayer = NULL;
while ((resultPlayer = getCurrentBetPlayer()) != NULL && auctionPlayers.size() > 1) {
game->emitSendMessage(MessageBuilder::buildYourTurnMessage(),resultPlayer->getGamePlayer()->getPlayerModel());
MsvClientMessage* message = getPlayerMessage(resultPlayer);
processAuctionMessage(message,resultPlayer);
game->sendMessage(*(players),bank,cardsInTable);
}
QMapIterator<quint16, AuctionPlayerModel*> i2(auctionPlayers);
while (i2.hasNext()) {
i2.next();
i2.value()->getGamePlayer()->setRoundMoney(0);
}
qDebug() << "AuctionAction::doAuction# auction finished" << endl;
}
int main()
{
ObjIeeeIndexManager im;
ObjFactory f(&im);
ObjFile *fi = MakeData(f);
fi->ResolveSymbols(&f);
std::fstream a("hi.txt", std::fstream::trunc | std::fstream::out);
ObjIeee i("hi");
i.SetTranslatorName("Link32");
i.SetDebugInfoFlag(true);
ObjSection *sect = codeSection;
ObjExpression *left = f.MakeExpression(sect);
ObjExpression *right = f.MakeExpression(10);
ObjExpression *sa = f.MakeExpression(ObjExpression::eAdd, left, right);
i.SetStartAddress(sa);
i.Write(a, fi, &f);
a.close();
// ObjFile *fi = i->Read(a, ObjIeee::eAll, f);
ObjIeeeIndexManager im1;
ObjFactory fact1(&im1);
std::fstream b("hi.txt", std::fstream::in);
ObjIeee i1("hi");
ObjFile *fi1 = i.Read(b, ObjIeee::eAll, &fact1);
a.close();
std::fstream c("hi2.txt", std::fstream::trunc | std::fstream::out);
ObjIeee i2("hi");
i.SetTranslatorName("Link32");
i.SetDebugInfoFlag(true);
i.Write(c, fi1, &fact1);
c.close();
}
void input()
{
char buffer[100];
strcpy(buffer, "xy 1234567890 \nabc");
istrstream is(buffer, strlen(buffer));
istrstream i2(buffer, strlen(buffer));
String s1("1234");
cout << "input" << endl;
is >> s1;
assert(s1 == "xy" && is != 0);
is >> s1;
assert(s1 == "1234567890" && is != 0);
is >> s1;
assert(s1 == "abc" && is != 0);
is >> s1;
assert(s1 == "" && is == 0 && is.eof() != 0);
getline(i2, s1);
assert(s1 == "xy 1234567890 ");
assert(i2 != 0);
getline(i2, s1);
assert(s1 == "abc");
assert(i2 != 0);
}
static int call(I0 const& i0, F f)
{
int ct = unrolled_count_if<n-4>::
call(fusion::advance_c<4>(i0), f);
if(f(*i0))
++ct;
typedef typename result_of::next<I0>::type I1;
I1 i1(fusion::next(i0));
if(f(*i1))
++ct;
typedef typename result_of::next<I1>::type I2;
I2 i2(fusion::next(i1));
if(f(*i2))
++ct;
typedef typename result_of::next<I2>::type I3;
I3 i3(fusion::next(i2));
if(f(*i3))
++ct;
return ct;
}
bool InternalStrictTotalOrder(
const LispEnvironment& env,
const LispPtr& e1,
const LispPtr& e2)
{
if (e1.ptr() == e2.ptr())
return false;
if (!e1.ptr() && e2.ptr())
return true;
if (e1.ptr() && !e2.ptr())
return false;
BigNumber* n1 = e1->Number(env.Precision());
BigNumber* n2 = e2->Number(env.Precision());
if (n1 && !n2)
return true;
if (!n1 && n2)
return false;
if (n1 && n2) {
if (n1->LessThan(*n2))
return true;
if (!n1->Equals(*n2))
return false;
return InternalStrictTotalOrder(env, e1->Nixed(), e2->Nixed());
}
const LispString* s1 = e1->String();
const LispString* s2 = e2->String();
if (s1 && !s2)
return true;
if (!s1 && s2)
return false;
if (s1 && s2) {
const int c = s1->compare(*s2);
if (c)
return c < 0;
return InternalStrictTotalOrder(env, e1->Nixed(), e2->Nixed());
}
LispPtr* l1 = e1->SubList();
LispPtr* l2 = e2->SubList();
if (!l1 && l2)
return true;
if (l1 && !l2)
return false;
if (l1 && l2) {
LispIterator i1(*l1);
LispIterator i2(*l2);
while (i1.getObj() && i2.getObj()) {
const LispPtr& p1 = *i1;
const LispPtr& p2 = *i2;
if (InternalEquals(env, p1, p2)) {
++i1;
++i2;
continue;
}
return InternalStrictTotalOrder(env, p1, p2);
}
if (i1.getObj())
return false;
if (i2.getObj())
return true;
return false;
}
// FIXME: deal with generics
// GenericClass* g1 = e1->Generic();
// GenericClass* g2 = e2->Generic();
//
return false;
}
void Polar::setPolarName(QString fname)
{
isCsv=true;
loaded=false;
clearPolar();
if(this->mainWindow->getSelectedBoat() && this->mainWindow->getSelectedBoat()->get_boatType()==BOAT_REAL)
coeffPolar=Settings::getSetting("polarEfficiency",100).toInt()/100.0;
else
coeffPolar=1.0;
//qWarning() << "Opening polar" << fname<<"with coeff"<<coeffPolar;
name=fname;
QString nameF = appFolder.value("polar")+fname+".csv";
QFile file(nameF);
if (fname.endsWith(".csv",Qt::CaseInsensitive) || fname.endsWith(".pol",Qt::CaseInsensitive))
{
nameF=appFolder.value("polar")+fname;
file.setFileName(nameF);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text ))
{
QMessageBox::warning(0,QObject::tr("Lecture de polaire"),
QString(QObject::tr("Impossible d'ouvrir le fichier %1")).arg(name));
return;
}
isCsv=fname.endsWith("csv",Qt::CaseInsensitive);
}
else
{
if (!file.open(QIODevice::ReadOnly | QIODevice::Text ))
{
isCsv=false;
nameF = appFolder.value("polar")+fname+".pol";
file.setFileName(nameF);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text ))
{
QMessageBox::warning(0,QObject::tr("Lecture de polaire"),
QString(QObject::tr("Impossible d'ouvrir le fichier %1 (ni en .csv ni en .pol)")).arg(name));
return;
}
}
}
QTextStream stream(&file);
QString line;
QStringList list;
/* read first line to see line length */
line=stream.readLine();
line.remove("\"");
if(line.isNull())
{
QMessageBox::warning(0,QObject::tr("Lecture de polaire"),
QString(QObject::tr("Fichier %1 vide")).arg(fname));
file.close();
return;
}
if(isCsv)
list = line.split(';');
else
list = line.split('\t');
if(list[0].toUpper() != "TWA\\TWS" && list[0].toUpper() != "TWA/TWS" && list[0].toUpper() != "TWA")
{
QMessageBox::warning(0,QObject::tr("Lecture de polaire"),
QString(QObject::tr("Fichier %1 invalide (doit commencer par TWA\\TWS et non '%2')"))
.arg(fname)
.arg(list[0]));
file.close();
return;
}
int i;
for(i=1;i<list.count();++i)
{
if(!tws.isEmpty() && list[i].toDouble()<=tws.last()) break;
tws.append(list[i].toDouble());
}
bool missingTws0=false;
if(tws.first()!=0.0)
{
missingTws0=true;
}
bool firstTWA=true;
while(true)
{
line=stream.readLine();
if(line.isNull()) break;
line.remove("\"");
if (isCsv)
list = line.split(";");
else
list = line.split("\t");
if(firstTWA)
{
firstTWA=false;
if(list.first().toDouble()!=0.0)
{
for(int t=0;t<tws.count();++t)
{
polar_data.append(0);
}
if(missingTws0)
polar_data.append(0);
twa.append(0.0);
}
}
twa.append(list[0].toDouble());
if(missingTws0)
polar_data.append(0);
for(i=1;i<list.count();++i)
{
if(i>tws.count()) break;
polar_data.append(list[i].toDouble()*this->coeffPolar);
}
while(i<=tws.count())
polar_data.append(0);
}
if(missingTws0)
tws.prepend(0.0);
#if 0
qWarning()<<"polar data for"<<nameF;
QString debug="xxx.x ";
foreach(double dd,tws)
debug+=QString().sprintf("%04.1f ",dd);
qWarning()<<debug;
QListIterator<double> i1(polar_data);
QListIterator<double> i2(twa);
while(i2.hasNext())
{
debug=QString().sprintf("%05.1f ",i2.next());
for(int nn=0;nn<tws.count();++nn)
debug+=QString().sprintf("%04.1f ",i1.next());
qWarning()<<debug;
}
#endif
mid_twa=qRound(twa.count()/2.0);
mid_tws=qRound(tws.count()/2.0);
/* polaire chargee */
/* pre-calculate B-VMG for every tws at 0.1 precision with a twa step of 1 and then .1 */
double ws=0.0;
double wa=0.0;
double bvmg,bvmg_d,bvmg_u,wa_u,wa_d,wa_limit;
maxSpeed=0.0;
do
{
wa_u=0.0;
wa_d=180.0;
bvmg_u=bvmg_d=0;
double speed;
do
{
speed=myGetSpeed(ws,wa,true);
if(speed>maxSpeed) maxSpeed=speed;
bvmg=speed*cos(degToRad(wa));
if(bvmg_u<bvmg) //bvmg is positive here
{
bvmg_u=bvmg;
wa_u=wa;
}
if(bvmg_d>bvmg) //bvmg is negative here
{
bvmg_d=bvmg;
wa_d=wa;
}
wa=qRound(wa+1);
} while(wa<181.00);
wa=wa_u-1;
wa_limit=wa_u+1;
if(wa<0) wa=0.0;
if(wa_limit<1) wa_limit=1.0;
if(wa_limit>180) wa_limit=180.0;
bvmg_u=0.0;
do
{
speed=myGetSpeed(ws,wa,true);
if(speed>maxSpeed) maxSpeed=speed;
bvmg=speed*cos(degToRad(wa));
if(bvmg_u<bvmg)
{
bvmg_u=bvmg;
wa_u=wa;
}
wa=wa+0.1;
} while(wa<(wa_limit+0.1000));
wa=wa_d-1;
wa_limit=wa_d+1;
if(wa<0) wa=0.0;
if(wa_limit<1) wa_limit=1.0;
if(wa_limit>180) wa_limit=180.0;
bvmg_d=0.0;
do
{
speed=myGetSpeed(ws,wa,true);
if(speed>maxSpeed) maxSpeed=speed;
bvmg=speed*cos(degToRad(wa));
if(bvmg_d>bvmg)
{
bvmg_d=bvmg;
wa_d=wa;
}
wa=wa+0.1;
}while(wa<wa_limit+0.1);
best_vmg_up.append(wa_u);
best_vmg_down.append(wa_d);
wa=0.0;
ws=ws+.1;
}while(ws<60.1);
loaded=true;
QFileInfo fi(file.fileName());
QString nameFVmg = appFolder.value("polar")+fi.baseName()+".vmg";
fileVMG.setFileName(nameFVmg);
if (fileVMG.open(QIODevice::ReadOnly | QIODevice::Text ))
{
if(fileVMG.size()<4329500 || fileVMG.size()>4329700)
fileVMG.remove();
else
{
QFileInfo info1(fileVMG);
QFileInfo info2(file);
if(this->mainWindow->isStartingUp && info1.lastModified()<info2.lastModified())
fileVMG.remove();
else
{
file.close();
return;
}
}
}
file.close();
//precalculate regular VMGs
//qWarning() << "Start computing vmg";
fileVMG.open(QIODevice::WriteOnly | QIODevice::Text );
double vmg=0;
QTextStream sVmg(&fileVMG);
QString ssVmg;
QProgressDialog * progress;
progress=new QProgressDialog((QWidget*)mainWindow);
progress->setWindowModality(Qt::ApplicationModal);
progress->setLabelText(tr("Pre-calcul des valeurs de VMG pour ")+fname);
progress->setMaximum(600);
progress->setMinimum(0);
progress->setCancelButton(NULL);
progress->setMaximumHeight(100);
progress->show();
for (int tws=0;tws<601;tws++)
{
progress->setValue(tws);
for (int twa=0;twa<1801;twa++)
{
bvmgWind((double) twa/10.0,(double) tws/10.0,&vmg);
ssVmg.sprintf("%.4d",qRound(A360(vmg)*10.0));
sVmg<<ssVmg;
}
}
fileVMG.close();
if(!fileVMG.open(QIODevice::ReadOnly | QIODevice::Text ))
qWarning()<<"fileVMG could not be re-opened!";
progress->close();
delete progress;
}
void run ()
{
testcase ("add/traverse");
beast::Journal const j; // debug journal
tests::TestFamily f(j);
// h3 and h4 differ only in the leaf, same terminal node (level 19)
uint256 h1, h2, h3, h4, h5;
h1.SetHex ("092891fe4ef6cee585fdc6fda0e09eb4d386363158ec3321b8123e5a772c6ca7");
h2.SetHex ("436ccbac3347baa1f1e53baeef1f43334da88f1f6d70d963b833afd6dfa289fe");
h3.SetHex ("b92891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8");
h4.SetHex ("b92891fe4ef6cee585fdc6fda2e09eb4d386363158ec3321b8123e5a772c6ca8");
h5.SetHex ("a92891fe4ef6cee585fdc6fda0e09eb4d386363158ec3321b8123e5a772c6ca7");
SHAMap sMap (SHAMapType::FREE, f);
SHAMapItem i1 (h1, IntToVUC (1)), i2 (h2, IntToVUC (2)), i3 (h3, IntToVUC (3)), i4 (h4, IntToVUC (4)), i5 (h5, IntToVUC (5));
unexpected (!sMap.addItem (i2, true, false), "no add");
unexpected (!sMap.addItem (i1, true, false), "no add");
auto i = sMap.begin();
auto e = sMap.end();
unexpected (i == e || (*i != i1), "bad traverse");
++i;
unexpected (i == e || (*i != i2), "bad traverse");
++i;
unexpected (i != e, "bad traverse");
sMap.addItem (i4, true, false);
sMap.delItem (i2.key());
sMap.addItem (i3, true, false);
i = sMap.begin();
e = sMap.end();
unexpected (i == e || (*i != i1), "bad traverse");
++i;
unexpected (i == e || (*i != i3), "bad traverse");
++i;
unexpected (i == e || (*i != i4), "bad traverse");
++i;
unexpected (i != e, "bad traverse");
testcase ("snapshot");
SHAMapHash mapHash = sMap.getHash ();
std::shared_ptr<SHAMap> map2 = sMap.snapShot (false);
unexpected (sMap.getHash () != mapHash, "bad snapshot");
unexpected (map2->getHash () != mapHash, "bad snapshot");
unexpected (!sMap.delItem (sMap.begin()->key()), "bad mod");
unexpected (sMap.getHash () == mapHash, "bad snapshot");
unexpected (map2->getHash () != mapHash, "bad snapshot");
testcase ("build/tear");
{
std::vector<uint256> keys(8);
keys[0].SetHex ("b92891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8");
keys[1].SetHex ("b92881fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8");
keys[2].SetHex ("b92691fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8");
keys[3].SetHex ("b92791fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8");
keys[4].SetHex ("b91891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8");
keys[5].SetHex ("b99891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8");
keys[6].SetHex ("f22891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8");
keys[7].SetHex ("292891fe4ef6cee585fdc6fda1e09eb4d386363158ec3321b8123e5a772c6ca8");
std::vector<uint256> hashes(8);
hashes[0].SetHex ("B7387CFEA0465759ADC718E8C42B52D2309D179B326E239EB5075C64B6281F7F");
hashes[1].SetHex ("FBC195A9592A54AB44010274163CB6BA95F497EC5BA0A8831845467FB2ECE266");
hashes[2].SetHex ("4E7D2684B65DFD48937FFB775E20175C43AF0C94066F7D5679F51AE756795B75");
hashes[3].SetHex ("7A2F312EB203695FFD164E038E281839EEF06A1B99BFC263F3CECC6C74F93E07");
hashes[4].SetHex ("395A6691A372387A703FB0F2C6D2C405DAF307D0817F8F0E207596462B0E3A3E");
hashes[5].SetHex ("D044C0A696DE3169CC70AE216A1564D69DE96582865796142CE7D98A84D9DDE4");
hashes[6].SetHex ("76DCC77C4027309B5A91AD164083264D70B77B5E43E08AEDA5EBF94361143615");
hashes[7].SetHex ("DF4220E93ADC6F5569063A01B4DC79F8DB9553B6A3222ADE23DEA02BBE7230E5");
SHAMap map (SHAMapType::FREE, f);
expect (map.getHash() == zero, "bad initial empty map hash");
for (int i = 0; i < keys.size(); ++i)
{
SHAMapItem item (keys[i], IntToVUC (i));
map.addItem (item, true, false);
expect (map.getHash().as_uint256() == hashes[i], "bad buildup map hash");
}
for (int i = keys.size() - 1; i >= 0; --i)
{
expect (map.getHash().as_uint256() == hashes[i], "bad teardown hash");
map.delItem (keys[i]);
}
expect (map.getHash() == zero, "bad final empty map hash");
}
}
void WriteTETFormat (const Mesh & mesh,
const string & filename)//, const string& problemType )
{
string problemType = "";
if(!mesh.PureTetMesh())
throw NgException("Can only export pure tet mesh in this format");
cout << "starting .tet export to file " << filename << endl;
ARRAY<int> point_ids,edge_ids,face_ids;
ARRAY<int> elnum(mesh.GetNE());
elnum = -1;
ARRAY<int> userdata_int;
ARRAY<double> userdata_double;
ARRAY<int> ports;
ARRAY<int> uid_to_group_3D, uid_to_group_2D, uid_to_group_1D, uid_to_group_0D;
int pos_int = 0;
int pos_double = 0;
bool haveuserdata =
(mesh.GetUserData("TETmesh:double",userdata_double) &&
mesh.GetUserData("TETmesh:int",userdata_int) &&
mesh.GetUserData("TETmesh:ports",ports) &&
mesh.GetUserData("TETmesh:point_id",point_ids,PointIndex::BASE) &&
mesh.GetUserData("TETmesh:uid_to_group_3D",uid_to_group_3D) &&
mesh.GetUserData("TETmesh:uid_to_group_2D",uid_to_group_2D) &&
mesh.GetUserData("TETmesh:uid_to_group_1D",uid_to_group_1D) &&
mesh.GetUserData("TETmesh:uid_to_group_0D",uid_to_group_0D));
int version,subversion;
if(haveuserdata)
{
version = int(userdata_double[0]);
subversion = int(10*(userdata_double[0] - version));
pos_double++;
}
else
{
version = 2;
subversion = 0;
}
if(version >= 2)
{
// test if ids are disjunct, if not version 2.0 not possible
int maxbc(-1),mindomain(-1);
for(ElementIndex i=0; i<mesh.GetNE(); i++)
if(i==0 || mesh[i].GetIndex() < mindomain)
mindomain = mesh[i].GetIndex();
for(int i=1; i<=mesh.GetNFD(); i++)
if(i==1 || mesh.GetFaceDescriptor(i).BCProperty() > maxbc)
maxbc = mesh.GetFaceDescriptor(i).BCProperty();
if(maxbc >= mindomain)
{
cout << "WARNING: writing version " << version << "." << subversion << " tetfile not possible, ";
version = 1; subversion = 1;
cout << "using version " << version << "." << subversion << endl;
}
}
int startsize = point_ids.Size();
point_ids.SetSize(mesh.GetNP()+1);
for(int i=startsize; i<point_ids.Size(); i++)
point_ids[i] = -1;
for(int i=0; i<PointIndex::BASE; i++)
point_ids[i] = -1;
INDEX_2_CLOSED_HASHTABLE<int> edgenumbers(6*mesh.GetNE()+3*mesh.GetNSE());;
INDEX_3_CLOSED_HASHTABLE<int> facenumbers(4*mesh.GetNE()+mesh.GetNSE());
ARRAY<INDEX_2> edge2node;
ARRAY<INDEX_3> face2edge;
ARRAY<INDEX_4> element2face;
int numelems(0),numfaces(0),numedges(0),numnodes(0);
for(SegmentIndex si = 0; si < mesh.GetNSeg(); si++)
{
const Segment & seg = mesh[si];
INDEX_2 i2(seg.p1,seg.p2);
i2.Sort();
if(edgenumbers.Used(i2))
continue;
numedges++;
edgenumbers.Set(i2,numedges);
edge2node.Append(i2);
edge_ids.Append(seg.edgenr);
if(point_ids[seg.p1] == -1)
point_ids[seg.p1] = (version >= 2) ? seg.edgenr : 0;
if(point_ids[seg.p2] == -1)
point_ids[seg.p2] = (version >= 2) ? seg.edgenr : 0;
}
for(SurfaceElementIndex si = 0; si < mesh.GetNSE(); si++)
{
if(mesh[si].IsDeleted())
continue;
const Element2d & elem = mesh[si];
numfaces++;
INDEX_3 i3(elem[0], elem[1], elem[2]);
int min = i3[0];
int minpos = 0;
for(int j=1; j<3; j++)
if(i3[j] < min)
{
min = i3[j]; minpos = j;
}
if(minpos == 1)
{
int aux = i3[0]; i3[0] = i3[1]; i3[1] = i3[2]; i3[2] = aux;
}
else if(minpos == 2)
{
int aux = i3[0]; i3[0] = i3[2]; i3[2] = i3[1]; i3[1] = aux;
}
facenumbers.Set(i3,numfaces);
int bc = mesh.GetFaceDescriptor(elem.GetIndex()).BCProperty();
face_ids.Append(bc);
for(int j=0; j<3; j++)
if(point_ids[elem[j]] == -1)
point_ids[elem[j]] = (version >= 2) ? bc : 0;
INDEX_2 i2a,i2b;
INDEX_3 f_to_n;
for(int j=0; j<3; j++)
{
i2a = INDEX_2(i3[j],i3[(j+1)%3]);
i2b[0] = i2a[1]; i2b[1] = i2a[0];
if(edgenumbers.Used(i2a))
f_to_n[j] = edgenumbers.Get(i2a);
else if(edgenumbers.Used(i2b))
f_to_n[j] = -edgenumbers.Get(i2b);
else
{
numedges++;
edgenumbers.Set(i2a,numedges);
edge2node.Append(i2a);
f_to_n[j] = numedges;
if(version >= 2)
edge_ids.Append(bc);
else
edge_ids.Append(0);
}
}
face2edge.Append(f_to_n);
}
for(ElementIndex ei = 0; ei < mesh.GetNE(); ei++)
{
const Element & el = mesh[ei];
if(el.IsDeleted())
continue;
numelems++;
elnum[ei] = numelems;
static int tetfaces[4][3] =
{ { 0, 2, 1 },
{ 0, 1, 3 },
{ 1, 2, 3 },
{ 2, 0, 3 } };
for(int j=0; j<4; j++)
if(point_ids[el[j]] == -1)
point_ids[el[j]] = (version >= 2) ? el.GetIndex() : 0;
INDEX_4 e_to_f;
for(int i = 0; i < 4; i++)
{
INDEX_3 i3a(el[tetfaces[i][0]],el[tetfaces[i][1]],el[tetfaces[i][2]]);
int min = i3a[0];
int minpos = 0;
for(int j=1; j<3; j++)
if(i3a[j] < min)
{
min = i3a[j]; minpos = j;
}
if(minpos == 1)
{
int aux = i3a[0]; i3a[0] = i3a[1]; i3a[1] = i3a[2]; i3a[2] = aux;
}
else if(minpos == 2)
{
int aux = i3a[0]; i3a[0] = i3a[2]; i3a[2] = i3a[1]; i3a[1] = aux;
}
INDEX_3 i3b(i3a[0],i3a[2],i3a[1]);
if(facenumbers.Used(i3a))
e_to_f[i] = facenumbers.Get(i3a);
else if(facenumbers.Used(i3b))
e_to_f[i] = -facenumbers.Get(i3b);
else
{
numfaces++;
facenumbers.Set(i3a,numfaces);
e_to_f[i] = numfaces;
if(version >= 2)
face_ids.Append(el.GetIndex());
else
face_ids.Append(0);
INDEX_2 i2a,i2b;
INDEX_3 f_to_n;
for(int j=0; j<3; j++)
{
i2a = INDEX_2(i3a[j],i3a[(j+1)%3]);
i2b[0] = i2a[1]; i2b[1] = i2a[0];
if(edgenumbers.Used(i2a))
f_to_n[j] = edgenumbers.Get(i2a);
else if(edgenumbers.Used(i2b))
f_to_n[j] = -edgenumbers.Get(i2b);
else
{
numedges++;
edgenumbers.Set(i2a,numedges);
edge2node.Append(i2a);
f_to_n[j] = numedges;
if(version >= 2)
edge_ids.Append(el.GetIndex());
else
edge_ids.Append(0);
}
}
face2edge.Append(f_to_n);
}
}
element2face.Append(e_to_f);
}
ofstream outfile(filename.c_str());
outfile.precision(16);
int unitcode;
double tolerance;
double dS1,dS2, alphaDeg;
double x3D,y3D,z3D;
int modelverts(0), modeledges(0), modelfaces(0), modelcells(0);
int numObj0D,numObj1D,numObj2D,numObj3D;
int numports = ports.Size();
ARRAY<int> nodenum(point_ids.Size()+1);
nodenum = -1;
numnodes = 0;
for(int i=0; i<point_ids.Size(); i++)
{
if(point_ids[i] != -1)
{
numnodes++;
nodenum[i] = numnodes;
}
}
if(haveuserdata)
{
unitcode = userdata_int[pos_int];
pos_int++;
tolerance = userdata_double[pos_double];
pos_double++;
dS1 = userdata_double[pos_double];
pos_double++;
dS2 = userdata_double[pos_double];
pos_double++;
alphaDeg = userdata_double[pos_double];
pos_double++;
x3D = userdata_double[pos_double];
pos_double++;
y3D = userdata_double[pos_double];
pos_double++;
z3D = userdata_double[pos_double];
pos_double++;
if(version == 2)
{
modelverts = userdata_int[pos_int];
pos_int++;
modeledges = userdata_int[pos_int];
pos_int++;
modelfaces = userdata_int[pos_int];
pos_int++;
modelcells = userdata_int[pos_int];
pos_int++;
}
numObj3D = userdata_int[pos_int];
pos_int++;
numObj2D = userdata_int[pos_int];
pos_int++;
numObj1D = userdata_int[pos_int];
pos_int++;
numObj0D = userdata_int[pos_int];
pos_int++;
}
else
{
unitcode = 3;
tolerance = 1e-5;
dS1 = dS2 = alphaDeg = 0;
x3D = y3D = z3D = 0;
modelverts = modeledges = modelfaces = modelcells = 0;
numObj3D = numObj2D = numObj1D = numObj0D = 0;
}
string uidpid;
if(version == 1)
uidpid = "PID";
else if (version == 2)
uidpid = "UID";
ARRAY< ARRAY<int,PointIndex::BASE>* > idmaps;
for(int i=1; i<=mesh.GetIdentifications().GetMaxNr(); i++)
{
if(mesh.GetIdentifications().GetType(i) == Identifications::PERIODIC)
{
idmaps.Append(new ARRAY<int,PointIndex::BASE>);
mesh.GetIdentifications().GetMap(i,*idmaps.Last(),true);
}
}
ARRAY<int> id_num,id_type;
ARRAY< ARRAY<int> *> id_groups;
// sst 2008-03-12: Write problem class...
{
std::string block;
block = "// CST Tetrahedral ";
block += !problemType.empty() ? problemType : "High Frequency";
block += " Mesh, Version no.:\n";
size_t size = block.size()-3;
block += "// ";
block.append( size, '^' );
block += "\n";
outfile
<< block
<< version << "." << subversion << "\n\n";
}
outfile
<< "// User Units Code (1=CM 2=MM 3=M 4=MIC 5=NM 6=FT 7=IN 8=MIL):\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" \
<< unitcode << "\n\n" \
<< "// Geometric coord \"zero\" tolerance threshold:\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" \
<< tolerance << "\n\n" \
<< "// Periodic UnitCell dS1 , dS2 , alphaDeg:\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" \
<< dS1 << " " << dS2 << " " << alphaDeg <<"\n\n" \
<< "// Periodic UnitCell origin in global coords (x3D,y3D,z3D):\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" \
<< x3D << " " << y3D << " " << z3D << "\n" << endl;
if(version == 2)
{
outfile << "// Model entity count: Vertices, Edges, Faces, Cells:\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" \
<< modelverts << " " << modeledges << " " << modelfaces << " " << modelcells << endl << endl;
}
outfile << "// Topological mesh-entity counts (#elements,#faces,#edges,#nodes):\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
outfile << numelems << " "
<< numfaces << " "
<< numedges << " "
<< numnodes << endl << endl;
outfile << "// NodeID, X, Y, Z, Type (0=Reg 1=PMaster 2=PSlave 3=CPMaster 4=CPSlave), "<< uidpid <<":\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
id_num.SetSize(mesh.GetNP()+1);
id_type.SetSize(mesh.GetNP()+1);
id_num = 0;
id_type = 0;
int n2,n4,n8;
n2 = n4 = n8 = 0;
for(int i=PointIndex::BASE; i<mesh.GetNP()+PointIndex::BASE; i++)
{
if(id_num[i] != 0)
continue;
if(nodenum[i] == -1)
continue;
ARRAY<int> group;
group.Append(i);
for(int j=0; j<idmaps.Size(); j++)
{
startsize = group.Size();
for(int k=0; k<startsize; k++)
{
int id = (*idmaps[j])[group[k]];
if(id != 0 && !group.Contains(id) && nodenum[id] != -1)
{
group.Append(id);
id_num[id] = j+1+id_num[group[k]];
}
}
}
if(group.Size() > 1)
{
id_groups.Append(new ARRAY<int>(group));
if(group.Size() == 2)
{
id_type[i] = 1;
id_type[group[1]] = 2;
n2++;
}
else if(group.Size() == 4)
{
id_type[i] = 3;
for(int j=1; j<group.Size(); j++)
id_type[group[j]] = 4;
n4++;
}
else if(group.Size() == 8)
{
id_type[i] = 5;
for(int j=1; j<group.Size(); j++)
id_type[group[j]] = 6;
n8++;
}
else
cerr << "ERROR: Identification group size = " << group.Size() << endl;
}
}
for(PointIndex i=PointIndex::BASE; i<mesh.GetNP()+PointIndex::BASE; i++)
{
if(nodenum[i] == -1)
continue;
outfile << nodenum[i] << " "
<< mesh[i](0) << " "
<< mesh[i](1) << " "
<< mesh[i](2) << " " << id_type[i] << " ";
if(i-PointIndex::BASE < point_ids.Size())
outfile << point_ids[i];
else
outfile << "0";
outfile << "\n";
}
outfile << endl;
outfile << "\n// Number of Periodic Master Nodes:\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" \
<< n2 << "\n" \
<< "\n" \
<< "// MasterNodeID, SlaveNodeID, TranslCode (1=dS1 2=dS2 3=dS1+dS2):\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
for(int i=0; i<id_groups.Size(); i++)
{
if(id_groups[i]->Size() != 2)
continue;
for(int j=0; j<id_groups[i]->Size(); j++)
outfile << nodenum[(*id_groups[i])[j]] << " ";
for(int j=1; j<id_groups[i]->Size(); j++)
outfile << id_num[(*id_groups[i])[j]] << " ";
outfile << "\n";
delete id_groups[i];
id_groups[i] = NULL;
}
outfile << endl;
outfile << "// Number of Corner Periodic Master Nodes:\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" \
<< n4 << "\n" \
<< "\n" \
<< "// MasterNodeID, 3-SlaveNodeID's, 3-TranslCodes (1=dS1 2=dS2 3=dS1+dS2):\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
for(int i=0; i<id_groups.Size(); i++)
{
if(!id_groups[i] || id_groups[i]->Size() != 4)
continue;
for(int j=0; j<id_groups[i]->Size(); j++)
outfile << nodenum[(*id_groups[i])[j]] << " ";
for(int j=1; j<id_groups[i]->Size(); j++)
{
outfile << id_num[(*id_groups[i])[j]] << " ";
}
outfile << "\n";
delete id_groups[i];
id_groups[i] = NULL;
}
outfile << endl;
outfile << "// Number of Cubic Periodic Master Nodes:\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" \
<< n8 << "\n" \
<< "\n" \
<< "// MasterNodeID, 7-SlaveNodeID's, TranslCodes:\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
for(int i=0; i<id_groups.Size(); i++)
{
if(!id_groups[i] || id_groups[i]->Size() != 8)
continue;
for(int j=0; j<id_groups[i]->Size(); j++)
outfile << nodenum[(*id_groups[i])[j]] << " ";
for(int j=1; j<id_groups[i]->Size(); j++)
outfile << id_num[(*id_groups[i])[j]] << " ";
outfile << "\n";
delete id_groups[i];
id_groups[i] = NULL;
}
outfile << endl;
outfile << "// EdgeID, NodeID0, NodeID1, Type (0=Reg 1=PMaster 2=PSlave 3=CPMaster 4=CPSlave), "<<uidpid<<":\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
ARRAY< ARRAY<int>* > vertex_to_edge(mesh.GetNP()+1);
for(int i=0; i<=mesh.GetNP(); i++)
vertex_to_edge[i] = new ARRAY<int>;
ARRAY< ARRAY<int,PointIndex::BASE>* > idmaps_edge(idmaps.Size());
for(int i=0; i<idmaps_edge.Size(); i++)
{
idmaps_edge[i] = new ARRAY<int,PointIndex::BASE>(numedges);
(*idmaps_edge[i]) = 0;
}
ARRAY<int> possible;
for(int i=0; i<edge2node.Size(); i++)
{
const INDEX_2 & v = edge2node[i];
for(int j=0; j<idmaps.Size(); j++)
{
INDEX_2 vid((*idmaps[j])[v[0]], (*idmaps[j])[v[1]]);
if(vid[0] != 0 && vid[0] != v[0] && vid[1] != 0 && vid[1] != v[1])
{
Intersection(*vertex_to_edge[vid[0]],*vertex_to_edge[vid[1]],possible);
if(possible.Size() == 1)
{
(*idmaps_edge[j])[possible[0]] = i+1;
(*idmaps_edge[j])[i+1] = possible[0];
}
else if(possible.Size() > 0)
{
cerr << "ERROR: too many possible edge identifications" << endl;
(*testout) << "ERROR: too many possible edge identifications" << endl
<< "*vertex_to_edge["<<vid[0]<<"] " << *vertex_to_edge[vid[0]] << endl
<< "*vertex_to_edge["<<vid[1]<<"] " << *vertex_to_edge[vid[1]] << endl
<< "possible " << possible << endl;
}
}
}
vertex_to_edge[v[0]]->Append(i+1);
vertex_to_edge[v[1]]->Append(i+1);
}
for(int i=0; i<vertex_to_edge.Size(); i++)
delete vertex_to_edge[i];
id_groups.SetSize(0);
id_num.SetSize(numedges+1);
id_num = 0;
id_type.SetSize(numedges+1);
id_type = 0;
n2 = n4 = n8 = 0;
for(int i=1; i<=edge2node.Size(); i++)
{
if(id_num[i] != 0)
continue;
ARRAY<int> group;
group.Append(i);
for(int j=0; j<idmaps_edge.Size(); j++)
{
startsize = group.Size();
for(int k=0; k<startsize; k++)
{
int id = (*idmaps_edge[j])[group[k]];
if(id != 0 && !group.Contains(id))
{
group.Append(id);
id_num[id] = j+1+id_num[group[k]];
}
}
}
if(group.Size() > 1)
{
id_num[i] = 1;
id_groups.Append(new ARRAY<int>(group));
if(group.Size() == 2)
{
id_type[i] = 1;
id_type[group[1]] = 2;
n2++;
}
else if(group.Size() == 4)
{
id_type[i] = 3;
for(int j=1; j<group.Size(); j++)
id_type[group[j]] = 4;
n4++;
}
else
{
cerr << "ERROR: edge identification group size = " << group.Size() << endl;
(*testout) << "edge group " << group << endl;
for(int j=0; j<idmaps_edge.Size(); j++)
{
(*testout) << "edge id map " << j << endl << *idmaps_edge[j] << endl;
}
}
}
}
for(int i=1; i<=edge2node.Size(); i++)
{
if(id_num[i] != 0)
continue;
ARRAY<int> group;
group.Append(i);
for(int j=0; j<idmaps_edge.Size(); j++)
{
startsize = group.Size();
for(int k=0; k<startsize; k++)
{
int id = (*idmaps_edge[j])[group[k]];
if(id != 0 && !group.Contains(id))
{
group.Append(id);
id_num[id] = j+1+id_num[group[k]];
}
}
}
if(group.Size() > 1)
{
id_num[i] = 1;
id_groups.Append(new ARRAY<int>(group));
if(group.Size() == 2)
{
id_type[i] = 1;
id_type[group[1]] = 2;
n2++;
}
else if(group.Size() == 4)
{
id_type[i] = 3;
for(int j=1; j<group.Size(); j++)
id_type[group[j]] = 4;
n4++;
}
else
{
cerr << "ERROR: edge identification group size = " << group.Size() << endl;
(*testout) << "edge group " << group << endl;
for(int j=0; j<idmaps_edge.Size(); j++)
{
(*testout) << "edge id map " << j << endl << *idmaps_edge[j] << endl;
}
}
}
}
for(int i=0; i<edge2node.Size(); i++)
outfile << i+1 << " " << nodenum[edge2node[i][0]] << " " << nodenum[edge2node[i][1]]
<< " " << id_type[i+1] << " " << edge_ids[i] << "\n";
outfile << endl;
outfile << "// Number of Periodic Master Edges:\n"\
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n"\
<< n2 << "\n" \
<< "\n"\
<< "// MasterEdgeID, SlaveEdgeID, TranslCode (1=dS1 2=dS2 3=dS1+dS2):\n"\
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
for(int i=0; i<id_groups.Size(); i++)
{
if(id_groups[i]->Size() != 2)
continue;
for(int j=0; j<id_groups[i]->Size(); j++)
outfile << (*id_groups[i])[j] << " ";
for(int j=1; j<id_groups[i]->Size(); j++)
outfile << id_num[(*id_groups[i])[j]] << " ";
outfile << "\n";
delete id_groups[i];
id_groups[i] = NULL;
}
outfile << endl;
outfile << "// Number of Corner Periodic Master Edges:\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n"\
<< n4 << "\n" \
<< "\n"\
<< "// MasterEdgeID, 3 SlaveEdgeID's, 3 TranslCode (1=dS1 2=dS2 3=dS1+dS2):\n"\
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
for(int i=0; i<id_groups.Size(); i++)
{
if(!id_groups[i] || id_groups[i]->Size() != 4)
continue;
for(int j=0; j<id_groups[i]->Size(); j++)
outfile << (*id_groups[i])[j] << " ";
for(int j=1; j<id_groups[i]->Size(); j++)
outfile << id_num[(*id_groups[i])[j]] << " ";
outfile << "\n";
delete id_groups[i];
id_groups[i] = NULL;
}
outfile << endl;
outfile << "// FaceID, EdgeID0, EdgeID1, EdgeID2, FaceType (0=Reg 1=PMaster 2=PSlave), "<<uidpid<<":\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
ARRAY< ARRAY<int>* > edge_to_face(numedges+1);
for(int i=0; i<edge_to_face.Size(); i++)
edge_to_face[i] = new ARRAY<int>;
for(int i=0; i<idmaps.Size(); i++)
{
idmaps[i]->SetSize(numfaces);
(*idmaps[i]) = 0;
}
for(int i=0; i<face2edge.Size(); i++)
{
for(int j=0; j<idmaps_edge.Size(); j++)
{
int e1id,e2id,e3id;
e1id = (*idmaps_edge[j])[abs(face2edge[i][0])];
e2id = (*idmaps_edge[j])[abs(face2edge[i][1])];
e3id = (*idmaps_edge[j])[abs(face2edge[i][2])];
if(e1id != 0 && e1id != abs(face2edge[i][0]) &&
e2id != 0 && e2id != abs(face2edge[i][1]) &&
e3id != 0 && e3id != abs(face2edge[i][2]))
{
Intersection(*edge_to_face[e1id],*edge_to_face[e2id],*edge_to_face[e3id],possible);
if(possible.Size() == 1)
{
(*idmaps[j])[possible[0]] = i+1;
(*idmaps[j])[i+1] = possible[0];
}
else if(possible.Size() > 0)
cerr << "ERROR: too many possible face identifications" << endl;
}
}
edge_to_face[abs(face2edge[i][0])]->Append(i+1);
edge_to_face[abs(face2edge[i][1])]->Append(i+1);
edge_to_face[abs(face2edge[i][2])]->Append(i+1);
}
for(int i=0; i<edge_to_face.Size(); i++)
delete edge_to_face[i];
for(int i=0; i<idmaps_edge.Size(); i++)
delete idmaps_edge[i];
id_groups.SetSize(0);
id_num.SetSize(numfaces+1);
id_num = 0;
n2 = n4 = n8 = 0;
for(int i=1; i<=numfaces; i++)
{
if(id_num[i] != 0)
continue;
ARRAY<int> group;
group.Append(i);
for(int j=0; j<idmaps.Size(); j++)
{
startsize = group.Size();
for(int k=0; k<startsize; k++)
{
int id = (*idmaps[j])[group[k]];
if(id != 0 && !group.Contains(id))
{
group.Append(id);
id_num[id] = j+1+id_num[group[k]];
}
}
}
if(group.Size() > 1)
{
id_num[i] = -1;
id_groups.Append(new ARRAY<int>(group));
if(group.Size() == 2)
n2++;
else
cerr << "ERROR: face identification group size = " << group.Size() << endl;
}
}
for(int i=0; i<idmaps.Size(); i++)
delete idmaps[i];
for(int i=0; i<face2edge.Size(); i++)
{
outfile << i+1 << " ";
for(int j=0; j<3; j++)
outfile << face2edge[i][j] << " ";
if(id_num[i+1] == 0)
outfile << 0;
else if(id_num[i+1] == -1)
outfile << 1;
else
outfile << 2;
outfile << " " << face_ids[i] <<"\n";
}
outfile << endl;
outfile << "// Number of Periodic Master Faces:\n"\
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n"\
<< n2 << "\n" \
<< "\n"\
<< "// MasterFaceID, SlaveFaceID, TranslCode (1=dS1 2=dS2):\n"\
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
for(int i=0; i<id_groups.Size(); i++)
{
if(id_groups[i]->Size() != 2)
continue;
for(int j=0; j<id_groups[i]->Size(); j++)
outfile << (*id_groups[i])[j] << " ";
for(int j=1; j<id_groups[i]->Size(); j++)
outfile << id_num[(*id_groups[i])[j]] << " ";
outfile << "\n";
delete id_groups[i];
}
outfile << endl;
outfile << "// ElemID, FaceID0, FaceID1, FaceID2, FaceID3, "<<uidpid<<":\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
for(ElementIndex i=0; i<mesh.GetNE(); i++)
{
if(elnum[i] >= 0)
{
outfile << elnum[i] << " ";
for(int j=0; j<4; j++)
outfile << element2face[elnum[i]-1][j] << " ";
outfile << mesh[i].GetIndex() << "\n";
}
}
outfile << endl;
outfile << "// ElemID, NodeID0, NodeID1, NodeID2, NodeID3:\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
for(ElementIndex i=0; i<mesh.GetNE(); i++)
{
if(elnum[i] >= 0)
outfile << elnum[i] << " "
<< nodenum[mesh[i][1]] << " " << nodenum[mesh[i][0]] << " " << nodenum[mesh[i][2]] << " " << nodenum[mesh[i][3]] << "\n";
}
outfile << endl;
outfile << "// Physical Object counts (#Obj3D,#Obj2D,#Obj1D,#Obj0D):\n"
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n"
<< " "<< numObj3D << " " << numObj2D << " " << numObj1D << " " << numObj0D << "\n" \
<< "\n" \
<< "// Number of Ports (Ports are a subset of Object2D list):\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n" \
<< numports << "\n" \
<< endl;
ARRAY< ARRAY<int> * > groups;
int maxg = -1;
for(int i = 0; i<uid_to_group_3D.Size(); i++)
if(uid_to_group_3D[i] > maxg)
maxg = uid_to_group_3D[i];
for(int i = 0; i<uid_to_group_2D.Size(); i++)
if(uid_to_group_2D[i] > maxg)
maxg = uid_to_group_2D[i];
for(int i = 0; i<uid_to_group_1D.Size(); i++)
if(uid_to_group_1D[i] > maxg)
maxg = uid_to_group_1D[i];
for(int i = 0; i<uid_to_group_0D.Size(); i++)
if(uid_to_group_0D[i] > maxg)
maxg = uid_to_group_0D[i];
groups.SetSize(maxg+1);
for(int i=0; i<groups.Size(); i++)
groups[i] = new ARRAY<int>;
for(ElementIndex i=0; i<mesh.GetNE(); i++)
if(uid_to_group_3D[mesh[i].GetIndex()] >= 0)
groups[uid_to_group_3D[mesh[i].GetIndex()]]->Append(i+1);
outfile << "// Object3D GroupID, #Elems <immediately followed by> ElemID List:\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
for(int i=0; i<numObj3D; i++)
{
outfile << i << " " << groups[i]->Size() << "\n";
for(int j=0; j<groups[i]->Size(); j++)
outfile << (*groups[i])[j] << "\n";
}
for(int i=0; i<groups.Size(); i++)
groups[i]->SetSize(0);
for(int i=0; i<face_ids.Size(); i++)
if(uid_to_group_2D[face_ids[i]] >= 0)
groups[uid_to_group_2D[face_ids[i]]]->Append(i+1);
outfile << "// Object2D GroupID, #Faces <immediately followed by> FaceID List:\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
for(int i=0; i<numObj2D; i++)
{
outfile << i << " " << groups[i]->Size() << "\n";
for(int j=0; j<groups[i]->Size(); j++)
{
outfile << (*groups[i])[j];
if(ports.Contains(face_ids[(*groups[i])[j]-1]))
outfile << " P";
outfile << "\n";
}
}
outfile << endl;
for(int i=0; i<groups.Size(); i++)
groups[i]->SetSize(0);
for(int i=0; i<edge_ids.Size(); i++)
if(uid_to_group_1D[edge_ids[i]] >= 0)
groups[uid_to_group_1D[edge_ids[i]]]->Append(i+1);
outfile << "// Object1D GroupID, #Edges <immediately followed by> EdgeID List:\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
for(int i=0; i<numObj1D; i++)
{
outfile << i << " " << groups[i]->Size() << "\n";
for(int j=0; j<groups[i]->Size(); j++)
outfile << (*groups[i])[j] << "\n";
}
outfile << endl;
for(int i=0; i<groups.Size(); i++)
groups[i]->SetSize(0);
for(PointIndex i=PointIndex::BASE; i<mesh.GetNP()+PointIndex::BASE; i++)
{
if(i-PointIndex::BASE < point_ids.Size())
{
if(uid_to_group_0D[point_ids[i]] >= 0)
groups[uid_to_group_0D[point_ids[i]]]->Append(i+1-PointIndex::BASE);
}
else
groups[uid_to_group_0D[0]]->Append(i+1-PointIndex::BASE);
}
outfile << "// Object0D GroupID, #Nodes <immediately followed by> NodeID List:\n" \
<< "// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n";
for(int i=0; i<numObj0D; i++)
{
outfile << i << " " << groups[i]->Size() << "\n";
for(int j=0; j<groups[i]->Size(); j++)
outfile << (*groups[i])[j] << "\n";
}
outfile << endl;
for(int i=0; i<groups.Size(); i++)
delete groups[i];
outfile.close();
cout << ".tet export done" << endl;
}
