コード例 #1
0
ファイル: spider.cpp プロジェクト: KDE/kpat
QPointF Spider::randomPos()
{
    QRectF rect = sceneRect();
    qreal x = rect.left() + qreal(KRandom::random()) / RAND_MAX * (rect.width() - deck()->cardWidth());
    qreal y = rect.top() + qreal(KRandom::random()) / RAND_MAX * (rect.height() - deck()->cardHeight());
    return QPointF( x, y );
}
コード例 #2
0
ファイル: mirror_grid.cpp プロジェクト: chflo/opm-core
int main(int argc, char** argv)
{
    // Set output precision
    int decimals = 16;

    // Process input parameters
    if (argc != 3) {
        std::cout << "Usage: mirror_grid filename.grdecl direction" << std::endl;
        std::cout << "(replace direction with either x or y)" << std::endl;
        exit(1);
    }
    const char* eclipsefilename = argv[1];
    std::string direction(argv[2]);
    if ( ! ((direction == "x") || (direction == "y")) ) {
        std::cerr << "Unrecognized input parameter for direction: '" << direction 
                  << "'. Should be either x or y (maybe also z later)." << std::endl;
        exit(1);
    }

    // Parse grdecl file
    std::cout << "Parsing grid file '" << eclipsefilename << "' ..." << std::endl;
    Opm::ParserPtr parser(new Opm::Parser);
    Opm::ParseContext parseContext;
    Opm::DeckConstPtr deck(parser->parseFile(eclipsefilename , parseContext));
    if ( ! (deck->hasKeyword("SPECGRID") && deck->hasKeyword("COORD") && deck->hasKeyword("ZCORN")) ) {
        std::cerr << "Grid file " << eclipsefilename << "are missing keywords SPECGRID, COORD or ZCORN!" << std::endl;
        exit(1);
    }

    // Create new grid file
    std::string mirrored_eclipsefilename = std::string(eclipsefilename);
    std::string::size_type last_dot = mirrored_eclipsefilename.find_last_of('.');
    mirrored_eclipsefilename = mirrored_eclipsefilename.substr(0, last_dot) + "_mirrored-" + direction + ".grdecl";
    std::ofstream outfile;
    outfile.open(mirrored_eclipsefilename.c_str(), std::ios::out | std::ios::trunc);
    if (!outfile) {
        std::cerr << "Can't open output file " << mirrored_eclipsefilename << std::endl;
        exit(1);
    }
    outfile.precision(decimals);
    outfile.setf(std::ios::fixed);

    // Print init message
    printInitMessage(outfile, eclipsefilename, direction);
    
    // Mirror keywords
    mirror_mapaxes(deck, direction, outfile);
    mirror_specgrid(deck, direction, outfile);
    mirror_coord(deck, direction, outfile);
    mirror_zcorn(deck, direction, outfile);
    mirror_celldata<int>("ACTNUM", deck, direction, outfile);
    mirror_celldata<double>("PERMX", deck, direction, outfile);
    mirror_celldata<double>("PERMY", deck, direction, outfile);
    mirror_celldata<double>("PERMZ", deck, direction, outfile);
    mirror_celldata<double>("PORO", deck, direction, outfile);
    mirror_celldata<int>("SATNUM", deck, direction, outfile);
    mirror_celldata<double>("NTG", deck, direction, outfile);
    mirror_celldata<double>("SWCR", deck, direction, outfile);
    mirror_celldata<double>("SOWCR", deck, direction, outfile);
}
コード例 #3
0
QList<T> Utilities::shuffleList(const QList<T>& list)
{
    static bool init = false;
    if ( !init ) {
        QTime midnight( 0, 0, 0 );
        srand( midnight.secsTo(QTime::currentTime()) );
        init = true;
    }

    // Take pointers from input list to an array for shuffling
    uint N = list.size();
    AutoDeletedArray<const T*> deck(N);
    const T** p = deck;
    for (typename QList<T>::const_iterator i = list.begin();
         i != list.end(); ++i) {
        *p = &(*i);
        ++p;
    }

    // Shuffle the array of pointers
    for (uint i = 0; i < N; i++) {
        uint r = i + static_cast<uint>(static_cast<double>(N - i) * rand() /
                                       static_cast<double>(RAND_MAX));
        std::swap(deck[r], deck[i]);
    }

    // Create new list from the array
    QList<T> result;
    const T** const onePastLast = deck + N;
    for (p = deck; p != onePastLast; ++p)
        result.push_back(**p);

    return result;
}
コード例 #4
0
ファイル: topswop_perm.cpp プロジェクト: tjd/sqlite_cpp
int try_all_perm_random_restart(int n, int restart_at, int stop_after) {
  int curr_best = get_current_score(n, dbname);
  int n1_score = get_current_score(n-1, dbname);
  perm deck(n), best(n);
  init_deck(deck);
  shuffle_no_fix(deck);
  int highest_count_so_far = 0;
  int count = 0;
  int iterations = 0;
  // while (next_perm_swap1(deck)) {
  //while (next_perm_rand_swap2(deck)) {
  while (next_permutation(deck.begin(), deck.end())) {
  //while (next_perm_seq_pair(deck)) {
  //while (next_perm_all_pair(deck)) {
  //while (next_perm_all_pair_rev(deck)) {
    ++iterations;
    if (iterations >= stop_after) return highest_count_so_far;

    ++count;

    if (deck[0] == 1) {
      shuffle_no_fix(deck);
      count = 0;
      ping('1');
    }

    if (count >= restart_at) {
      count = 0;
      shuffle_no_fix(deck);
      ping('.');
    }

    const int score = do_all_top_swops_copy(deck);

    /*
    // Heuristic cut-off: if the last number is home, then re-start if
    // the previous perm's best score plus the current score is less
    // than the highest score so far.
    if (deck.back() == n && n1_score + score < highest_count_so_far) {
      count = 0;
      shuffle_no_fix(deck);
      ping('c');
    }
    */

    if (score > highest_count_so_far) {
      highest_count_so_far = score;
      best = deck;
      if (highest_count_so_far > curr_best) {
        ping('!');
        //int diff = highest_count_so_far - curr_best;
        curr_best = highest_count_so_far;
        set_current_perm(n, best, dbname);
      }
    }
  }
  //  cout << best << " (n=" << n << ", optimal_count=" << highest_count_so_far 
  //       << ")" << endl;
  return highest_count_so_far;
}
コード例 #5
0
ファイル: fortyeight.cpp プロジェクト: KDE/kpat
void Fortyeight::restart( const QList<KCard*> & cards )
{
    lastdeal = false;

    QList<KCard*> cardList = cards;

    for ( int r = 0; r < 4; ++r )
    {
        for ( int column = 0; column < 8; ++column )
        {
            QPointF initPos = stack[column]->pos() - QPointF( 0, 2 * deck()->cardHeight() );
            addCardForDeal( stack[column], cardList.takeLast(), true, initPos );
        }
    }

    while ( !cardList.isEmpty() )
    {
        KCard * c = cardList.takeFirst();
        c->setPos( talon->pos() );
        c->setFaceUp( false );
        talon->add( c );
    }

    startDealAnimation();

    flipCardToPile( talon->topCard(), pile, DURATION_MOVE );

    emit newCardsPossible( true );
}
コード例 #6
0
ファイル: mainc.cpp プロジェクト: MakSim345/cpp
int main( int argc, char *argv[] )
{
    //char *suit[4] = {"4epBu", "6y6HbI", "TpeFbI", "nuku"};
    
    std::string suit[4] = {"4epBu", "6y6HbI", "TpeFbI", "nuku"};

    std::string face[13] = {"Ty3", "gBojka", "Tpojka", "4eTBepka", 
                      "nqTepka", "wecTepka", "ceMepka", "BocMepka",
                      "geBqTka", "gecqTka", "BaLeT", "gaMa", "KopoLb"};
    
    // int deck[4][13] = {0};
    
    srand (time(NULL));
    
    // shuffle (deck);
    deck _deck = deck();
    _deck.shuffle();

    my_time _mt;
    _mt.ms = 134;
    _mt._name = "test";
    printf ("name: %s\n", _mt._name);
    print_my_struct(&_mt);
    std::cout << Timestamp() << "\n";
    _deck.print_deck();
    system("PAUSE");
    return 0;   
}
コード例 #7
0
std::shared_ptr<const Opm::Deck> createSingleRecordDeckWithVd() {
    const char *deckData =
        "RUNSPEC\n"
        "ENDSCALE\n"
        "2* 1 2 /\n"
        "PROPS\n"
        "TABDIMS\n"
        " 2 /\n"
        "\n"
        "SWFN\n"
        "0.22 .0   7.0 \n"
        "0.3  .0   4.0 \n"
        "0.5  .24  2.5 \n"
        "0.8  .65  1.0 \n"
        "0.9  .83  .5  \n"
        "1.0  1.00 .0 /\n"
        "/\n"
        "IMPTVD\n"
        "3000.0 6*0.1 0.31 1*0.1\n"
        "9000.0 6*0.1 0.32 1*0.1/\n"
        "ENPTVD\n"
        "3000.0 0.20 0.20 1.0 0.0 0.04 1.0 0.18 0.22\n"
        "9000.0 0.22 0.22 1.0 0.0 0.04 1.0 0.18 0.22 /";

    Opm::ParserPtr parser(new Opm::Parser);
    Opm::DeckConstPtr deck(parser->parseString(deckData, Opm::ParseContext()));
    return deck;
}
コード例 #8
0
Response::ResponseCode ServerSocketInterface::cmdDeckUpload(const Command_DeckUpload &cmd, ResponseContainer &rc)
{
    if (authState != PasswordRight)
        return Response::RespFunctionNotAllowed;

    if (!cmd.has_deck_list())
        return Response::RespInvalidData;

    sqlInterface->checkSql();

    QString deckStr = QString::fromStdString(cmd.deck_list());
    DeckList deck(deckStr);

    QString deckName = deck.getName();
    if (deckName.isEmpty())
        deckName = "Unnamed deck";

    if (cmd.has_path()) {
        int folderId = getDeckPathId(QString::fromStdString(cmd.path()));
        if (folderId == -1)
            return Response::RespNameNotFound;

        QSqlQuery query(sqlInterface->getDatabase());
        query.prepare("insert into " + servatrice->getDbPrefix() + "_decklist_files (id_folder, id_user, name, upload_time, content) values(:id_folder, :id_user, :name, NOW(), :content)");
        query.bindValue(":id_folder", folderId);
        query.bindValue(":id_user", userInfo->id());
        query.bindValue(":name", deckName);
        query.bindValue(":content", deckStr);
        sqlInterface->execSqlQuery(query);

        Response_DeckUpload *re = new Response_DeckUpload;
        ServerInfo_DeckStorage_TreeItem *fileInfo = re->mutable_new_file();
        fileInfo->set_id(query.lastInsertId().toInt());
        fileInfo->set_name(deckName.toStdString());
        fileInfo->mutable_file()->set_creation_time(QDateTime::currentDateTime().toTime_t());
        rc.setResponseExtension(re);
    } else if (cmd.has_deck_id()) {
        QSqlQuery query(sqlInterface->getDatabase());
        query.prepare("update " + servatrice->getDbPrefix() + "_decklist_files set name=:name, upload_time=NOW(), content=:content where id = :id_deck and id_user = :id_user");
        query.bindValue(":id_deck", cmd.deck_id());
        query.bindValue(":id_user", userInfo->id());
        query.bindValue(":name", deckName);
        query.bindValue(":content", deckStr);
        sqlInterface->execSqlQuery(query);

        if (query.numRowsAffected() == 0)
            return Response::RespNameNotFound;

        Response_DeckUpload *re = new Response_DeckUpload;
        ServerInfo_DeckStorage_TreeItem *fileInfo = re->mutable_new_file();
        fileInfo->set_id(cmd.deck_id());
        fileInfo->set_name(deckName.toStdString());
        fileInfo->mutable_file()->set_creation_time(QDateTime::currentDateTime().toTime_t());
        rc.setResponseExtension(re);
    } else
        return Response::RespInvalidData;

    return Response::RespOk;
}
コード例 #9
0
ファイル: Durak.cpp プロジェクト: kennysandbum/Durak
int main() {
  int WindowX, WindowY;

  std::string str("Cards/cardback1.png");

  std::cout << str << std::endl;

  if (!back.loadFromFile(str)) { // TODO error
    std::cout << "Couldn't load cardback img" << std::endl;
  }
  WindowX = 700;
  WindowY = 500;
  //Card c(Card::Seven, Card::Spade, true);
  //c.rotate(90.0f);
  Deck deck(true);
  Hand h(true, false, sf::FloatRect(100.0f, 100.0f, static_cast<float>(WindowX / 5), static_cast<float>(WindowY)), Hand::down, deck.getKozer());
  //h.takeCard(c);
  
  // Create the main window
  sf::VideoMode v = sf::VideoMode::getDesktopMode();

  sf::RenderWindow window(sf::VideoMode(v.width, v.height), "SFML window");
  WindowX = v.width;
  WindowY = v.height;
  //c.scale(WindowX, WindowY);
  //c.rotate(90.0f);
  //c.setPos(50.0f, 50.0f);
  deck.scale(WindowX, WindowY);
  deck.setPos(WindowX / 1.5, WindowY / 1.5);
  while (window.isOpen()) {
    // Process events
    sf::Event event;
    while (window.pollEvent(event)) {
      // Close window : exit
      if (event.type == sf::Event::Closed)
        window.close();
      if(event.type == sf::Event::KeyPressed){
	 
	  switch(event.key.code){
	  case sf::Keyboard::Space:
	      if(!deck.empty()){
		  Card temp = deck.takeTop();
		  h.takeCard(temp);
	      }
	      break;
	      
	  default:
	      break;
	  }
      }
    }
    // Clear screen
    window.clear(sf::Color(85, 120, 47, 160));
    window.draw(h);
    window.draw(deck);
    window.display();
  }
  return EXIT_SUCCESS;
}
コード例 #10
0
ファイル: topswop_perm.cpp プロジェクト: tjd/sqlite_cpp
void test_perm() {
  vector<int> deck(4);
  init_deck(deck);
  while (next_permutation(deck.begin(), deck.end())) {
    cout << deck << endl;
  }
  cout << "done\n";
}
コード例 #11
0
void DeckView::reloadIndexes()
{
    if(mCurrentDeck != NULL)
    {
        for (unsigned int i = 0; i < mCards.size(); i++)
        {
            mCards[i].card = deck()->getCard(i);
        }
    }
}
コード例 #12
0
void Grandf::deal( const QList<KCard*> & cardsToDeal )
{
    setKeyboardModeActive( false );

    QList<KCard*> cards = cardsToDeal;

    QPointF initPos( 1.4 * 3 * deck()->cardWidth(), 1.2 * deck()->cardHeight() );

    int start = 0;
    int stop = 7-1;
    int dir = 1;

    for (int round=0; round < 7; round++)
    {
        int i = start;
        do
        {
            if (!cards.isEmpty())
                addCardForDeal( store[i], cards.takeLast(), (i == start), initPos );
            i += dir;
        } while ( i != stop + dir);
        int t = start;
        start = stop;
        stop = t+dir;
        dir = -dir;
    }

    int i = 0;
    while (!cards.isEmpty())
    {
        addCardForDeal( store[i+1], cards.takeLast(), true, initPos );
        i = (i+1)%6;
    }

    for (int round=0; round < 7; round++)
    {
        KCard *c = store[round]->topCard();
        if (c)
            c->setFaceUp(true);
    }

    startDealAnimation();
}
コード例 #13
0
void TabDeckStorage::downloadFinished(const Response &r, const CommandContainer &/*commandContainer*/, const QVariant &extraData)
{
    if (r.response_code() != Response::RespOk)
        return;
    
    const Response_DeckDownload &resp = r.GetExtension(Response_DeckDownload::ext);
    QString filePath = extraData.toString();
    
    DeckLoader deck(QString::fromStdString(resp.deck()));
    deck.saveToFile(filePath, DeckLoader::CockatriceFormat);
}
コード例 #14
0
ファイル: Parser.cpp プロジェクト: PETECLAM/opm-parser
    DeckPtr Parser::parse(const std::string &dataFileName, bool strictParsing) const {
        DeckPtr deck(new Deck());
        boost::filesystem::path dataFile(dataFileName);
        boost::filesystem::path rootPath;

        if (dataFile.is_absolute())
            rootPath = dataFile.parent_path();
        else
            rootPath = boost::filesystem::current_path() / dataFile.parent_path();

        parseFile(deck, dataFile, rootPath , strictParsing);
        return deck;
    }
コード例 #15
0
inline std::shared_ptr<const Opm::Deck> createSWOFDeck() {
    const char *deckData =
        "TABDIMS\n"
        " 2 /\n"
        "\n"
        "SWOF\n"
        " 1 2 3 4\n"
        " 5 6 7 8 /\n"
        " 9 10 11 12 /\n";

    Opm::Parser parser;
    Opm::DeckConstPtr deck(parser.parseString(deckData, Opm::ParseContext()));
    return deck;
}
コード例 #16
0
std::shared_ptr<const Opm::Deck> createSingleRecordDeck() {
    const char *deckData =
        "TABDIMS\n"
        " 2 /\n"
        "\n"
        "SWOF\n"
        " 1 2 3 4\n"
        " 5 6 7 8 /\n"
        " 9 10 11 12 /\n";

    Opm::ParserPtr parser(new Opm::Parser);
    Opm::DeckConstPtr deck(parser->parseString(deckData, Opm::ParseContext()));
    return deck;
}
コード例 #17
0
ファイル: spider.cpp プロジェクト: KDE/kpat
void Spider::setSuits(int suits)
{
    if ( suits != m_suits )
    {
        m_suits = suits;

        stopDemo();
        clearHighlightedItems();
        setKeyboardModeActive( false );

        int cardWidth = deck()->cardWidth();
        createDeck();
        deck()->setCardWidth( cardWidth );

        Settings::setSpiderSuitCount( m_suits );

        if ( m_suits == 1 )
            options->setCurrentItem( 0 );
        else if ( m_suits == 2 )
            options->setCurrentItem( 1 );
        else
            options->setCurrentItem( 2 );
    }
}
コード例 #18
0
ファイル: deck.cpp プロジェクト: chasemartin/final
Deck::Deck(){ //initilizes a vector for deck
thrust::host_vector<int> deck(52);
        deck[0]=2;    deck[1]=2;    deck[2]=2;    deck[3]=2;
        deck[4]=3;    deck[5]=3;    deck[6]=3;    deck[7]=3;
        deck[8]=4;    deck[9]=4;    deck[10]=4;   deck[11]=4;
        deck[12]=5;   deck[13]=5;   deck[14]=5;   deck[15]=5;
        deck[16]=6;   deck[17]=6;   deck[18]=6;   deck[19]=6;
        deck[20]=7;   deck[21]=7;   deck[22]=7;   deck[23]=7;
        deck[24]=8;   deck[25]=8;   deck[26]=8;   deck[27]=8;
        deck[28]=9;   deck[29]=9;   deck[30]=9;   deck[31]=9;
        deck[32]=10;  deck[33]=10;  deck[34]=10;  deck[35]=10;
        deck[36]=10;  deck[37]=10;  deck[38]=10;  deck[39]=10;
        deck[40]=10;  deck[41]=10;  deck[42]=10;  deck[43]=10;
        deck[44]=10;  deck[45]=10;  deck[46]=10;  deck[47]=10;
        deck[48]=1;   deck[49]=1;   deck[50]=1;   deck[51]=1;
};        
コード例 #19
0
ファイル: Deck.cpp プロジェクト: MegatronX/KHMPOld
			void Test(Engine* engine)
			{
				Deck deck(engine);
				
				for (int i = 0; i < 50; ++i)
				{
					card_ptr card(new Card("Test" + boost::lexical_cast<std::string>(i)));
					deck.AddCard(card);
				}
				for (int i = 0; i < 20; ++i)
				{
					deck.Shuffle();
					Hand myHand(deck.DrawCards(10, false, false, 0));
					myHand.Print(std::cout);
				}
			}
コード例 #20
0
ファイル: util.cpp プロジェクト: sm88/gcc_715
void util::ThreadedParser::run(){
    srtl_driver* driver = util::getDriver(m_argc, m_args);
    std::map<std::string, Pattern*> tab = driver->getSymTab();
    for(std::map<std::string, Pattern*>::iterator iter = tab.begin(); iter != tab.end(); iter++){
        ConcretePattern* p = dynamic_cast<ConcretePattern*>(tab[iter->first]);
        AbstPattern* ap = dynamic_cast<AbstPattern*>(tab[iter->first]);
        if(p != NULL){
            Node* tree = p->getTree();
            p->trav(tree);
            cerr << p->getName() << " " << p->getLineStart() << " " << endl;//p->getLineEnd() << endl;
            util::NodeMap::display(tree);

            std::vector<Operand> opVec = p->getOperands();
            std::deque<Operand> deck(opVec.begin(), opVec.end());
            util::NodeMap::setOpDeque(deck);
            util::NodeMap::createNodeMap(tree);
            std::map<int, std::vector<BNode*> > nodeMap = util::NodeMap::getNodeMap();
            std::map<int, std::vector<BNode*> > tempMap(nodeMap.begin(), nodeMap.end());    //copy the map

            PatternDTO* dto = new PatternDTO();
            dto->setMap(tempMap);
            dto->setName(p->getName());
            dto->setLineStart(p->getLineStart());
            util::NodeMap::m_mapVec.push_back(dto);
            dfsFlag = 0;
            util::NodeMap::doDepthFirstSearch(tree);
        }
        if(ap!=NULL && ap->resolved){
            Node* tree = ap->getTree();
            //cerr << "++++++"<<ap->getPatName() << " " << ap->getLineStart() << " " << endl;//p->getLineEnd() << endl;
            util::NodeMap::display(tree);
            util::NodeMap::createNodeMap(tree);
            std::map<int, std::vector<BNode*> > nodeMap = util::NodeMap::getNodeMap();
            std::map<int, std::vector<BNode*> > tempMap(nodeMap.begin(), nodeMap.end());    //copy the map

            PatternDTO* dto = new PatternDTO();
            dto->setMap(tempMap);
            dto->setName(ap->getPatName());
            dto->setLineStart(ap->getLineStart());
            util::NodeMap::m_mapVec.push_back(dto);
        }
    }
}
コード例 #21
0
ファイル: class_deck.cpp プロジェクト: s171212/cpp_blackjack
	// teller hvor mange deck er
	deck::deck(int deckCount)
	{
		deckCount = deck();
	
	}
コード例 #22
0
ファイル: setupGridAndProps.hpp プロジェクト: OPM/opm-porsol
    inline void setupGridAndProps(const Opm::parameter::ParameterGroup& param,
                                  Dune::CpGrid& grid,
                                  ResProp<3>& res_prop)
    {
        // Initialize grid and reservoir properties.
        // Parts copied from Dune::CpGrid::init().
        std::string fileformat = param.getDefault<std::string>("fileformat", "cartesian");
        if (fileformat == "sintef_legacy") {
            std::string grid_prefix = param.get<std::string>("grid_prefix");
            grid.readSintefLegacyFormat(grid_prefix);
            OPM_MESSAGE("Warning: We do not yet read legacy reservoir properties. Using defaults.");
            res_prop.init(grid.size(0));
        } else if (fileformat == "eclipse") {
            std::string ecl_file = param.get<std::string>("filename");

            Opm::ParseContext parseContext;
            Opm::ParserPtr parser(new Opm::Parser());
            Opm::DeckConstPtr deck(parser->parseFile(ecl_file , parseContext));
            if (param.has("z_tolerance")) {
                std::cerr << "****** Warning: z_tolerance parameter is obsolete, use PINCH in deck input instead\n";
            }
            bool periodic_extension = param.getDefault<bool>("periodic_extension", false);
            bool turn_normals = param.getDefault<bool>("turn_normals", false);
            grid.processEclipseFormat(deck, periodic_extension, turn_normals);
            // Save EGRID file in case we are writing ECL output.
            if (param.getDefault("output_ecl", false)) {
                OPM_THROW(std::runtime_error, "Saving to EGRID files is not yet implemented");
                /*
                boost::filesystem::path ecl_path(ecl_file);
                const std::vector<int>& globalCell = grid.globalCell();
                ecl_path.replace_extension(".EGRID");
                parser.saveEGRID(ecl_path.string() , (int) globalCell.size() , &globalCell[0]);
                */
            }
            double perm_threshold_md = param.getDefault("perm_threshold_md", 0.0);
            double perm_threshold = Opm::unit::convert::from(perm_threshold_md, Opm::prefix::milli*Opm::unit::darcy);
            std::string rock_list = param.getDefault<std::string>("rock_list", "no_list");
            std::string* rl_ptr = (rock_list == "no_list") ? 0 : &rock_list;
            bool use_j = param.getDefault("use_jfunction_scaling", useJ<ResProp<3> >());
            double sigma = 1.0;
            double theta = 0.0;
            if (use_j) {
                sigma = param.getDefault("sigma", sigma);
                theta = param.getDefault("theta", theta);
            }
            if (param.has("viscosity1") || param.has("viscosity2")) {
                double v1 = param.getDefault("viscosity1", 0.001);
                double v2 = param.getDefault("viscosity2", 0.003);
                res_prop.setViscosities(v1, v2);
            }
            res_prop.init(deck, grid.globalCell(), perm_threshold, rl_ptr,
                          use_j, sigma, theta);
        } else if (fileformat == "cartesian") {
            std::array<int, 3> dims = {{ param.getDefault<int>("nx", 1),
                                    param.getDefault<int>("ny", 1),
                                    param.getDefault<int>("nz", 1) }};
            std::array<double, 3> cellsz = {{ param.getDefault<double>("dx", 1.0),
                                         param.getDefault<double>("dy", 1.0),
                                         param.getDefault<double>("dz", 1.0) }};
            grid.createCartesian(dims, cellsz);
            double default_poro = param.getDefault("default_poro", 0.2);
            double default_perm_md = param.getDefault("default_perm_md", 100.0);
            double default_perm = Opm::unit::convert::from(default_perm_md, Opm::prefix::milli*Opm::unit::darcy);
            OPM_MESSAGE("Warning: For generated cartesian grids, we use uniform reservoir properties.");
            res_prop.init(grid.size(0), default_poro, default_perm);
        } else {
            OPM_THROW(std::runtime_error, "Unknown file format string: " << fileformat);
        }
        if (param.getDefault("use_unique_boundary_ids", false)) {
            grid.setUniqueBoundaryIds(true);
        }
    }
コード例 #23
0
void DeckView::renderCard(int index, int alpha, bool asThumbnail, bool addWHborder)
{
    WFont * mFont = WResourceManager::Instance()->GetWFont(Fonts::MAIN_FONT);

    const CardRep& cardPosition = mCards[index];

    if (!cardPosition.card) return;

    if (!WResourceManager::Instance()->IsThreaded())
    {
        JQuadPtr backQuad = WResourceManager::Instance()->GetQuad(kGenericCardID);
        JQuadPtr quad;

        int cacheError = CACHE_ERROR_NONE;

        if (!options[Options::DISABLECARDS].number)
        {
            quad = WResourceManager::Instance()->RetrieveCard(cardPosition.card, RETRIEVE_EXISTING);
            cacheError = WResourceManager::Instance()->RetrieveError();
            if (!quad.get() && cacheError != CACHE_ERROR_404)
            {
                if (last_user_activity > (abs(2 - index) + 1) * no_user_activity_show_card_delay)
                    quad = WResourceManager::Instance()->RetrieveCard(cardPosition.card);
                else
                {
                    quad = backQuad;
                }
            }
        }

        if (quad.get())
        {
            if (quad == backQuad)
            {
                quad->SetColor(ARGB(255,255,255,255));
                float _scale = cardPosition.scale * (285 / quad->mHeight);
                JRenderer::GetInstance()->RenderQuad(quad.get(), cardPosition.x, cardPosition.y, 0.0f, _scale, _scale);
            }
            else
            {
                Pos pos = Pos(cardPosition.x, cardPosition.y, cardPosition.scale * 285 / 250, 0.0, 255);
                CardGui::DrawCard(cardPosition.card, pos, asThumbnail, true);
            }
        }
        else
        {
            Pos pos = Pos(cardPosition.x, cardPosition.y, cardPosition.scale * 285 / 250, 0.0, 255);
            CardGui::DrawCard(cardPosition.card, pos, DrawMode::kText, asThumbnail, true);
        }
    }
    else
    {//NORMAL VIEW WITH IMAGES
        int mode = !options[Options::DISABLECARDS].number ? DrawMode::kNormal : DrawMode::kText;
        float modx = addWHborder ? 2.0f:0.0f;
        //border for editor && others???
        string cardsetname = setlist[cardPosition.card->setId].c_str();
        if(cardsetname == "2ED"||cardsetname == "RV"||cardsetname == "4ED"||cardsetname == "5ED"||cardsetname == "6ED"||cardsetname == "7ED"||cardsetname == "8ED"||cardsetname == "9ED"||cardsetname == "CHR"||cardsetname == "DM")
        {
            JRenderer::GetInstance()->FillRoundRect((cardPosition.x - cardPosition.scale * 100.0f)-(5.f+modx),(cardPosition.y - cardPosition.scale * 142.5f)-(5.f+modx),cardPosition.scale * 200.0f,cardPosition.scale * 285.0f,5.f+modx,ARGB(255,248,248,255));
            JRenderer::GetInstance()->DrawRoundRect((cardPosition.x - cardPosition.scale * 100.0f)-(5.f+modx),(cardPosition.y - cardPosition.scale * 142.5f)-(5.f+modx),cardPosition.scale * 200.0f,cardPosition.scale * 285.0f,5.f+modx,ARGB(150,20,20,20));
        }
        else
        {
            JRenderer::GetInstance()->FillRoundRect((cardPosition.x - cardPosition.scale * 100.0f)-(5.f+modx),(cardPosition.y - cardPosition.scale * 142.5f)-(5.f+modx),cardPosition.scale * 200.0f,cardPosition.scale * 285.0f,5.f+modx,ARGB(255,10,10,10));
            JRenderer::GetInstance()->DrawRoundRect((cardPosition.x - cardPosition.scale * 100.0f)-(5.f+modx),(cardPosition.y - cardPosition.scale * 142.5f)-(5.f+modx),cardPosition.scale * 200.0f,cardPosition.scale * 285.0f,5.f+modx,ARGB(50,240,240,240));
        }
        Pos pos = Pos(cardPosition.x, cardPosition.y, cardPosition.scale * 285 / 250, 0.0, 255);
        CardGui::DrawCard(cardPosition.card, pos, mode, asThumbnail, true);
    }
    int quadAlpha = alpha;
    if (!deck()->count(cardPosition.card)) quadAlpha /= 2;
    quadAlpha = 255 - quadAlpha;
    if (quadAlpha > 0)
    {
        JRenderer::GetInstance()->FillRect(cardPosition.x - cardPosition.scale * 100.0f, cardPosition.y - cardPosition.scale * 142.5f, cardPosition.scale * 200.0f, cardPosition.scale * 285.0f,
                                           ARGB(quadAlpha,0,0,0));
    }
    if (last_user_activity < 3)
    {
        int fontAlpha = alpha;
        float qtY = cardPosition.y - 135 * cardPosition.scale;
        float qtX = cardPosition.x + 40 * cardPosition.scale;
        char buffer[4096];
        sprintf(buffer, "x%i", deck()->count(cardPosition.card));
        WFont * font = mFont;
        font->SetScale(1.4f);
        font->SetColor(ARGB(fontAlpha/2,0,0,0));
        JRenderer::GetInstance()->FillRect(qtX, qtY, font->GetStringWidth(buffer) + 6, 18, ARGB(fontAlpha/2,0,0,0));
        JRenderer::GetInstance()->DrawRect(qtX, qtY, font->GetStringWidth(buffer) + 6, 18, ARGB(fontAlpha/2,240,240,240));
        font->DrawString(buffer, qtX + 5, qtY + 3);
        font->SetColor(ARGB(fontAlpha,255,255,255));
        font->DrawString(buffer, qtX + 4, qtY + 2);
        font->SetColor(ARGB(255,255,255,255));
        font->SetScale(1.0f);
    }
}
コード例 #24
0
void Gypsy::restart( const QList<KCard*> & cards )
{
    QList<KCard*> cardList = cards;

    for ( int round = 0; round < 8; ++round )
        addCardForDeal(store[round], cardList.takeLast(), false, store[round]->pos() + QPointF(-2*deck()->cardWidth(),-1.1*deck()->cardHeight()));

    for ( int round = 0; round < 8; ++round )
        addCardForDeal(store[round], cardList.takeLast(), true, store[round]->pos() + QPointF(-3*deck()->cardWidth(),-1.6*deck()->cardHeight()));

    for ( int round = 0; round < 8; ++round )
        addCardForDeal(store[round], cardList.takeLast(), true, store[round]->pos() + QPointF(-4*deck()->cardWidth(),-2.1*deck()->cardHeight()));

    while ( !cardList.isEmpty() )
    {
        KCard * c = cardList.takeFirst();
        c->setPos( talon->pos() );
        c->setFaceUp( false );
        talon->add( c );
    }

    startDealAnimation();

    emit newCardsPossible(true);
}
コード例 #25
0
ファイル: cpregularize.cpp プロジェクト: laods/opm-upscaling
int main(int argc, char** argv)
try
{
   if (argc == 1) {
        std::cout << "Usage: cpregularize gridfilename=filename.grdecl [ires=5] [jres=5] [zres=5] " << std::endl;
        std::cout << "       [imin=] [imax=] [jmin=] [jmax=] [zmin=] [zmax=] " << std::endl;
        std::cout << "       [z_tolerance=0.0] [minperm=1e-9] " << std::endl;
        std::cout << "       [resultgrid=regularizedgrid.grdecl]" << std::endl;
        exit(1);
    }

    Dune::MPIHelper::instance(argc, argv);
  
    Opm::parameter::ParameterGroup param(argc, argv);
    std::string gridfilename = param.get<std::string>("gridfilename");
    Opm::CornerPointChopper ch(gridfilename);

    // The cells with i coordinate in [imin, imax) are included, similar for j.
    // The z limits may be changed inside the chopper to match actual min/max z.
    const int* dims = ch.dimensions();
    int imin = param.getDefault("imin", 0);
    int imax = param.getDefault("imax", dims[0]);
    int jmin = param.getDefault("jmin", 0);
    int jmax = param.getDefault("jmax", dims[1]);
    double zmin = param.getDefault("zmin", ch.zLimits().first);
    double zmax = param.getDefault("zmax", ch.zLimits().second);
    int ires = param.getDefault("ires", 1);
    int jres = param.getDefault("jres", 1);
    int zres = param.getDefault("zres", 1);

    std::string resultgrid = param.getDefault<std::string>("resultgrid", "regularizedgrid.grdecl");

    double minperm = param.getDefault("minperm", 1e-9);
    double minpermSI = Opm::unit::convert::from(minperm, Opm::prefix::milli*Opm::unit::darcy);
    double z_tolerance = param.getDefault("z_tolerance", 1e-8);
    double residual_tolerance = param.getDefault("residual_tolerance", 1e-8);
    double linsolver_verbosity = param.getDefault("linsolver_verbosity", 0);
    double linsolver_type = param.getDefault("linsolver_type", 1);

    // Check for unused parameters (potential typos).
    if (param.anyUnused()) {
	std::cout << "*****     WARNING: Unused parameters:     *****\n";
	param.displayUsage();
    }

    // Check that we do not have any user input 
    // that goes outside the coordinates described in
    // the cornerpoint file (runtime-exception will be thrown in case of error)
    // (ilen, jlen and zlen set to zero, does not apply here)
    ch.verifyInscribedShoebox(imin, 0, imax, 
			      jmin, 0, jmax,
			      zmin, 0, zmax);

    
    // Storage for properties for regularized cells
    std::vector<double> poro;
    std::vector<double> permx;
    std::vector<double> permy;
    std::vector<double> permz;


    // Original x/y resolution in terms of coordinate values (not indices)
    Opm::ParserPtr parser(new Opm::Parser);
    Opm::DeckConstPtr deck(parser->parseFile(gridfilename)); // TODO: REFACTOR!!!! it is stupid to parse this again
    Opm::EclipseGridInspector gridinspector(deck);
    std::array<double, 6> gridlimits=gridinspector.getGridLimits();
    double finegridxresolution = (gridlimits[1]-gridlimits[0])/dims[0];
    double finegridyresolution = (gridlimits[3]-gridlimits[2])/dims[1];

    // Construct mapping from coarse i and j indices to fine
    // and COORDS values for regularized pillars.
    std::vector<int> iidx_f, jidx_f;
    std::vector<double> newcoords_x;
    int finesprcoarse_i = floor(dims[0] / ires);
    int remainder_i = dims[0] - ires*finesprcoarse_i;
    for (int iidx_c=0; iidx_c < remainder_i+1; ++iidx_c) {
        iidx_f.push_back(iidx_c*(finesprcoarse_i + 1));  // Spread remainder evenly
    }
    for (int iidx_c=remainder_i + 1; iidx_c < ires; ++iidx_c) {
        iidx_f.push_back(iidx_c*finesprcoarse_i + remainder_i);
    }
    iidx_f.push_back(imax); // endpoint needed below

    int finesprcoarse_j = floor(dims[1] / jres);
    int remainder_j = dims[1] - jres*finesprcoarse_j;
    for (int jidx_c=0; jidx_c < remainder_j+1; ++jidx_c) {
        jidx_f.push_back(jidx_c*(finesprcoarse_j + 1)); // Spread remainder evenly
    }
    for (int jidx_c=remainder_j + 1; jidx_c < jres; ++jidx_c) {
        jidx_f.push_back(jidx_c*finesprcoarse_j + remainder_j);
    }
    jidx_f.push_back(jmax); // endpoint needed below

    // Construct new ZCORN for regular grid
    std::vector<double> zcorn_c;
    for (int zidx_c=0; zidx_c < zres; ++zidx_c) {
	zcorn_c.push_back(zmin + zidx_c * (zmax-zmin)/zres);
    }
    zcorn_c.push_back(zmax);
    


    // Run through the new regular grid to find its properties
    for (int zidx_c=0; zidx_c < zres; ++zidx_c) {
        for (int jidx_c=0; jidx_c < jres; ++jidx_c) {
            for (int iidx_c=0; iidx_c < ires; ++iidx_c) {
                ch.chop(iidx_f[iidx_c], iidx_f[iidx_c+1],
                        jidx_f[jidx_c], jidx_f[jidx_c+1],
                        zcorn_c[zidx_c], zcorn_c[zidx_c+1],
                        false);

                OPM_THROW(std::logic_error, "Sub-decks not are not implemented by opm-parser. Refactor the calling code!?");
		try {
		    Opm::DeckConstPtr subdeck = ch.subDeck();
		    Opm::SinglePhaseUpscaler upscaler;
		    upscaler.init(subdeck, Opm::SinglePhaseUpscaler::Fixed, minpermSI, z_tolerance,
				  residual_tolerance, linsolver_verbosity, linsolver_type, false);
            
		    Opm::SinglePhaseUpscaler::permtensor_t upscaled_K = upscaler.upscaleSinglePhase();
		    upscaled_K *= (1.0/(Opm::prefix::milli*Opm::unit::darcy));
		    poro.push_back(upscaler.upscalePorosity());
		    permx.push_back(upscaled_K(0,0));
		    permy.push_back(upscaled_K(1,1));
		    permz.push_back(upscaled_K(2,2)); 
		}
		catch (...) {
		    std::cout << "Warning: Upscaling for cell failed to convert, values set to zero\n";
		    poro.push_back(0.0);
		    permx.push_back(0.0);
		    permy.push_back(0.0);
		    permz.push_back(0.0);
		}
	    }
        }
    }
    // Write regularized grid to outputfile
    std::ofstream out(resultgrid.c_str());
    if (!out) {
        std::cerr << "Could not open file " << resultgrid << "\n";
        throw std::runtime_error("Could not open output file.");
    }
    out << "SPECGRID\n" << ires << ' ' << jres << ' ' << zres 
                << " 1 F\n/\n\n";

    out << "COORD\n";
    for (int j = 0; j <= jres; ++j) {
        for (int i = 0; i <= ires; ++i) {
	    out << finegridxresolution*iidx_f[i] << " " << finegridyresolution*jidx_f[j] << " " << zmin << " "
                << finegridxresolution*iidx_f[i] << " " << finegridyresolution*jidx_f[j] << " " << zmax << "\n";
        }
    }
    out << "/\n\n";

    /*
     Write ZCORN, that is the Z-coordinates along the pillars, specifying
     the eight corners of each cell. Each corner is specified for each
     cell, even though it is the same corner that is used in other
     cells. 

     We loop over corners in each grid cell, directions: z, y, x (x innermost).
     The code here *IS* redundant, but the grid is also very redundant
     for a grid that is really regular..
   */ 
    out << "ZCORN\n";
    double zlen = zmax-zmin;
    for (int zidx=0; zidx < zres; ++zidx) {
	for (int j = 0; j < jres; ++j) {
	    for (int i = 0; i < ires; ++i) {
		out << zlen/zres*zidx << "  " << zlen/zres*zidx << "  ";
	    }
	    out << "\n";
	    for (int i = 0; i < ires; ++i) {
		out << zlen/zres*zidx << "  " << zlen/zres*zidx << "  ";
	    }
	}
	for (int j = 0; j < jres; ++j) {
	    for (int i = 0; i < ires; ++i) {
		out << zlen/zres*(zidx+1) << "  " << zlen/zres*(zidx+1) << "  ";
	    }
	    out << "\n";
	    for (int i = 0; i < ires; ++i) {
		out << zlen/zres*(zidx+1) << "  " << zlen/zres*(zidx+1) << "  ";
	    }
	}
    }
    out << "/\n\n";
    
    out << "PORO\n";
    for (size_t idx=0; idx < (size_t)poro.size(); ++idx) {
	out << poro[idx] << std::endl;
    }
    out << "/\n\n";
    
    out << "PERMX\n";
    for (size_t idx=0; idx < (size_t)permx.size(); ++idx) {
	out << permx[idx] << std::endl;
    }
    out << "/\n\n";
    
    out << "PERMY\n\n";
    for (size_t idx=0; idx < (size_t)permy.size(); ++idx) {
	out << permy[idx] << std::endl;
    }
    out << "/\n\n";
    
    out << "PERMZ\n\n";
    for (size_t idx=0; idx < (size_t)permz.size(); ++idx) {
	out << permz[idx] << std::endl;
    }
    out << "/\n";
    
    out.close();
}
catch (const std::exception &e) {
    std::cerr << "Program threw an exception: " << e.what() << "\n";
    throw;
}
コード例 #26
0
ファイル: server.cpp プロジェクト: wgorman1/setProject
main (int argc, char *argv[])
{

  int    timeout;
  portNumber = atoi(argv[1]);
  Deck deck(cardArray);
  if (argv[2] == NULL)
	  {
	    timer = 15;
	  }  
  else{
    timer = atoi(argv[2]);
  }


  std:: cout << "Timer = " << timer << "\n";

  pthread_create(&threadA[1], NULL, timerTask, NULL);
 
  /* initialize random seed: */
  srand (time(NULL));

  /* generate secret number between 1 and 10: */
  deckSeed = rand() % 100 + 1; 
  
 std::cout<<"SEED: " << deckSeed << "\n";
  

  /* Create an AF_INET6 stream socket to receive incoming */
  listen_sd = socket(AF_INET6, SOCK_STREAM, 0);
  if (listen_sd < 0)
    {
      perror("socket() failed");
      exit(-1);
    }
  rc = setsockopt(listen_sd, SOL_SOCKET,  SO_REUSEADDR,
                  (char *)&on, sizeof(on));
  if (rc < 0)
    {
      perror("setsockopt() failed");
      close(listen_sd);
      exit(-1);
    }
  rc = ioctl(listen_sd, FIONBIO, (char *)&on);
  if (rc < 0)
    {
      perror("ioctl() failed");
      close(listen_sd);
      exit(-1);
    }
  memset(&addr, 0, sizeof(addr));
  addr.sin6_family      = AF_INET6;
  memcpy(&addr.sin6_addr, &in6addr_any, sizeof(in6addr_any));
  addr.sin6_port        = htons(portNumber);
  rc = bind(listen_sd,
            (struct sockaddr *)&addr, sizeof(addr));
  if (rc < 0)
    {
      perror("bind() failed");
      close(listen_sd);
      exit(-1);
    }
  rc = listen(listen_sd, 32);
  if (rc < 0)
    {
      perror("listen() failed");
      close(listen_sd);
      exit(-1);
    }
  memset(fds, 0 , sizeof(fds));
  fds[0].fd = listen_sd;
  fds[0].events = POLLIN;
  timeout = (3 * 60 * 1000);
  do
    {
      rc = poll(fds, nfds, timeout);
      if (rc < 0)
	{
	  perror("  poll() failed");
	  break;
	}

      if (rc == 0)
	{
	  printf("  poll() timed out.  End program.\n");
	  break;
	}

      current_size = nfds;
      for (i = 0; i < current_size; i++)
	{
	  if(fds[i].revents == 0)
	    continue;
	  if(fds[i].revents != POLLIN)
	    {
	      printf("  Error! revents = %d\n", fds[i].revents);
	      end_server = TRUE;
	      break;

	    }
	  if (fds[i].fd == listen_sd)
	    {
        do
	  {
	   
	    new_sd = accept(listen_sd, NULL, NULL);
	    if (new_sd < 0)
	      {
		if (errno != EWOULDBLOCK)
		  {
		    perror("  accept() failed");
		    end_server = TRUE;
		  }
		break;
	      }

	    printf("  New incoming connection - %d\n", new_sd);
	   
	    fds[nfds].fd = new_sd;
	    fds[nfds].events = POLLIN;
	   
	     if(vectorSize < 12)
	      {
	    		std:: string success = "SUCCESS";
	      send(fds[nfds].fd, success.c_str(), success.size(), 0);

		
		clientCount = clientCount + 1;
		std::cout << "CLIENTCOUNT = " << clientCount << "\n";

		for(int m = 0; m < 80; m++)
		  {
		    buffer2[m] = '\0';
		  }

		for(int m =0; m < 12; m++)
		  {
		    nameBuffer[m] = '\0';
		  }
    
	    	   
		std:: string appendedName;
		
		recv(new_sd, buffer2, sizeof(buffer2), 0);
		
		for(int b = 0; b<12; b++)
		  {
		    nameBuffer[b] = buffer2[b];
		  }	    
		std:: string appendage = "1";
	    
		std:: string name = (nameBuffer + '\0');
       
		int result = 1;
		int counter = 1;

		while(result == 1)
		  {
		    result = 0;
		    for(int j=0; j<12;j++)
		      {
			if(name == nameArray[j])
			  {
			    name = name + to_string(counter);
			    counter = counter + 1;
			    result = 1;
			    //printf("name appended");
			  }
		      }

		
		  }
		send(fds[nfds].fd, name.c_str(), name.size(), 0);
	    
		nameArray[current_size] = name;
		for(int j=0; j <= current_size; j++)
		  {
		    std::cout << nameArray[j] << "\n";
		  }
		
		Player p1(name);
		playerVector.push_back(p1);
		vectorSize = playerVector.size();
		std::cout << "VECTOR SIZE = " << vectorSize << "\n";
		
		if(vectorSize == 3)
		  {
		    std:: cout << "MADE IT INTO VECTOR FLAG\n";
		    flag = 1;
		  }
		std::string seed = to_string(deckSeed);
		send(fds[nfds].fd, seed.c_str(), seed.size(), 0); 

	       }
	   else{
	      std:: string failMessage = "FAILURE";
	      send(fds[nfds].fd, failMessage.c_str(), failMessage.size(), 0); 
	      }
		nfds++;
    
	    //string message = "You have joined as ";
	    //string end2 = "\n";
	    //string message2 = message + name + end2;
	    //std::cout << message2.c_str() << "\n";
	    // write(1, message2.c_str(), message2.size());
	    // send(fds[i].fd, message2.c_str(), message2.size(), 0);
	    // }

	  } while (new_sd != -1);
	    }


	  else
	    {
	      std::cout << "MADE IT INTO ELSE\n";
	      //      printf("  Descriptor %d is readable\n", fds[i].fd);
	      close_conn = FALSE;

	      void *task1(void *);

	      pthread_create(&threadA[nfds+1], NULL, task1, NULL);


	    }
	} 

      if (compress_array)
	{
	  compress_array = FALSE;
	  for (i = 0; i < nfds; i++)
	    {
	      if (fds[i].fd == -1)
		{
		  for(j = i; j < nfds; j++)
		    {
		      fds[j].fd = fds[j+1].fd;
		    }
		  i--;
		  nfds--;
		}
	    }
	}

    } while (end_server == FALSE); /* End of serving running.    */
  for (i = 0; i < nfds; i++)
    {
      if(fds[i].fd >= 0)
	close(fds[i].fd);
    }
}