PetscErrorCode PressurePoisson( UserContext *uc )
{
Mat A;
Vec b, px, py, p, u, v, ss, c;
KSP ksp;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscLogEventBegin(EVENT_PressurePoisson,0,0,0,0);
PetscLogEventRegister(&EVENT_PressurePoisson,"PressurePoisson", 0);
/* Assemble and Solve for pressure */
ierr = PetscPrintf(PETSC_COMM_WORLD, "***********************\nPRESSURE\n"); CHKERRQ(ierr);
ierr = AssemblePressureMatrx( uc ); CHKERRQ(ierr);
ierr = AssemblePressureRHS( uc ); CHKERRQ(ierr);
ierr = SolvePressure( uc ); CHKERRQ(ierr);
ierr = WriteResult( uc, uc->p, "p_pressure" ); CHKERRQ(ierr);
/* Assemble and Solve for Velocity */
ierr = PetscPrintf(PETSC_COMM_WORLD, "***********************\nVELOCITY\n"); CHKERRQ(ierr);
ierr = AssembleVelocityRHS( uc ); CHKERRQ(ierr);
ierr = AssembleVelocityMatrix( uc ); CHKERRQ(ierr);
ierr = KSPSetOperators(uc->ksp,uc->A, uc->A, SAME_PRECONDITIONER); CHKERRQ(ierr);
ierr = KSPSolve(uc->ksp,uc->px,uc->u);CHKERRQ(ierr);
ierr = KSPSolve(uc->ksp,uc->py,uc->v);CHKERRQ(ierr);
ierr = WriteResult( uc, uc->u, "u_velocity" ); CHKERRQ(ierr);
ierr = WriteResult( uc, uc->v, "v_velocity" ); CHKERRQ(ierr);
ierr = ComputeShearStress(uc); CHKERRQ(ierr);
ierr = WriteResult( uc, uc->ss,"shear_stress" ); CHKERRQ(ierr);
ierr = ConservationTest(uc); CHKERRQ(ierr);
/* Output indexing */
PetscReal *idx;
VecGetArray(uc->b,&idx);
for( int i = 0; i < uc->numNodes; i++)
idx[i] = i;
VecRestoreArray(uc->b,&idx);
WriteResult(uc, uc->b, "indexes");
VecSet(uc->b, 0.);
ierr = VecDestroy(uc->c); CHKERRQ(ierr);
ierr = VecDestroy(uc->ss); CHKERRQ(ierr);
ierr = MatDestroy(uc->A); CHKERRQ(ierr);
ierr = KSPDestroy(uc->ksp); CHKERRQ(ierr);
ierr = VecDestroy(uc->b); CHKERRQ(ierr);
ierr = VecDestroy(uc->p); CHKERRQ(ierr);
ierr = VecDestroy(uc->px); CHKERRQ(ierr);
ierr = VecDestroy(uc->py); CHKERRQ(ierr);
ierr = VecDestroy(uc->u); CHKERRQ(ierr);
ierr = VecDestroy(uc->v); CHKERRQ(ierr);
PetscLogEventEnd(EVENT_PressurePoisson,0,0,0,0);
PetscFunctionReturn(0);
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
Result result;
Run(*replay, result);
delete replay;
const ContestStatistics olc_plus = SolveContest(Contest::OLC_PLUS);
const ContestStatistics dmst = SolveContest(Contest::DMST);
TextWriter writer("/dev/stdout", true);
{
JSON::ObjectWriter root(writer);
WriteResult(root, result);
root.WriteElement("phases", WritePhaseList,
flight_phase_detector.GetPhases());
root.WriteElement("performance", WritePerformanceStats,
flight_phase_detector.GetTotals());
root.WriteElement("contests", WriteContests, olc_plus, dmst);
}
}
virtual WriteResult writeObject(const osg::Object& obj,std::ostream& fout,const Options* options=NULL) const
{
const osg::Node* node = dynamic_cast<const osg::Node*>(&obj);
if (node)
return writeNode(*node, fout, options);
else
return WriteResult(WriteResult::FILE_NOT_HANDLED);
}
virtual WriteResult writeNode(const osg::Node& node,const std::string& fileName,const Options* options =NULL) const
{
if (!acceptsExtension(osgDB::getFileExtension(fileName)))
return WriteResult(WriteResult::FILE_NOT_HANDLED);
std::ofstream f(fileName.c_str());
std::string materialFile = osgDB::getNameLessExtension(fileName) + ".mtl";
OBJWriterNodeVisitor nv(f, osgDB::getSimpleFileName(materialFile));
// we must cast away constness
(const_cast<osg::Node*>(&node))->accept(nv);
std::ofstream mf(materialFile.c_str());
nv.writeMaterials(mf);
return WriteResult(WriteResult::FILE_SAVED);
}
static void writeResults(FILE *fp, int topicId, const char *topicName, const ResultList *list)
{
int top_k = list->results;
const char *format = GetOptionalConfig("RESULTS-FORMAT", "%T Q0 %D %r %s Topsig-Exhaustive %h\\n");
for (int i = 0; i < top_k; i++) {
WriteResult(fp, format, topicId, topicName, list->docids[i], list->metadata[i].docname, i + 1, 1000000 - i, list->distances[i], list->metadata[i].uniqueTerms, list->metadata[i].documentCharLength, list->metadata[i].totalTerms, list->metadata[i].quality, list->metadata[i].offsetBegin, list->metadata[i].offsetEnd, list->metadata[i].unused7, list->metadata[i].unused8);
}
}
virtual WriteResult writeNode(const osg::Node& node,std::ostream& fout,const Options* =NULL) const
{
// writing to a stream does not support materials
OBJWriterNodeVisitor nv(fout);
// we must cast away constness
(const_cast<osg::Node*>(&node))->accept(nv);
return WriteResult(WriteResult::FILE_SAVED);
}
virtual WriteResult writeNode(const osg::Node& node,std::ostream& fout,const Options* options=NULL) const
{
ObjOptionsStruct localOptions = parseOptions(options);
fout.precision(localOptions.precision);
// writing to a stream does not support materials
OBJWriterNodeVisitor nv(fout);
// we must cast away constness
(const_cast<osg::Node*>(&node))->accept(nv);
return WriteResult(WriteResult::FILE_SAVED);
}
virtual WriteResult writeObject(const osg::Object& obj,std::ostream& fout, const osgDB::ReaderWriter::Options* options) const
{
osgDB::Output foutput;
foutput.setOptions(options);
std::ios &fios = foutput;
fios.rdbuf(fout.rdbuf());
if (fout)
{
setPrecision(foutput,options);
foutput.writeObject(obj);
return WriteResult::FILE_SAVED;
}
return WriteResult("Unable to write to output stream");
}
virtual WriteResult writeObject(const osg::Object& obj,const std::string& fileName, const osgDB::ReaderWriter::Options* options) const
{
std::string ext = osgDB::getLowerCaseFileExtension(fileName);
if (!acceptsExtension(ext)) return WriteResult::FILE_NOT_HANDLED;
osgDB::Output fout(fileName.c_str());
fout.setOptions(options);
if (fout)
{
setPrecision(fout,options);
fout.writeObject(obj);
fout.close();
return WriteResult::FILE_SAVED;
}
return WriteResult("Unable to open file for output");
}
PetscErrorCode ConservationTest(UserContext *uc)
{
PetscReal val[4], comp, *u, *v, *b, vx, vy,u1,u2,v1,v2;
int i,j;
Node *n;
PetscInt *nei;
PetscErrorCode ierr;
printf("***************************************************\n");
PetscFunctionBegin;
PetscLogEventBegin(EVENT_ConservationTest,0,0,0,0);
PetscLogEventRegister(&EVENT_ConservationTest,"ConservationTest", 0);
VecGetArray(uc->u, &u);
VecGetArray(uc->v, &v);
VecGetArray(uc->b, &b);
printf("***************************************************\n");
for (i = 0; i < uc->numNodes; ++i)
{
/*
for( j = 0; j < 4; j++ ) val[j] = 0.;
if( u[i] < 0. ) { val[2] += u[i];}
if( u[i] > 0. ) { val[1] -= u[i];}
if( v[i] < 0. ) { val[3] += v[i];}
if( v[i] > 0. ) { val[0] -= v[i];}
for( j = 0; j < 4; j++ ) comp += val[i];*/
n = &uc->nodes[i];
if( n->numNei == 4 )
{
nei = &n->nei[0];
vx = u[nei[1]] - u[nei[2]];
vy = v[nei[0]] - v[nei[3]];
u1 = u[nei[1]] - u[nei[2]];
b[i] = vx + vy;
} else {
b[i] = 0.;
}
}
printf("***************************************************\n");
VecRestoreArray(uc->b, &b);
VecRestoreArray(uc->v, &v);
VecRestoreArray(uc->u, &u);
printf("***************************************************\n");
WriteResult(uc, uc->b, "conservation");
PetscLogEventEnd(EVENT_ConservationTest,0,0,0,0);
PetscFunctionReturn(0);
}
void SearchThread::SearchDir(const wxString& path, const SearchInfo& si, ProjectInfoHandler& infoHandler) {
MMapBuffer buf;
wxFileName filepath;
vector<FileMatch> matches;
wxArrayString dirs;
wxArrayString filenames;
infoHandler.GetDirAndFileLists(path, dirs, filenames);
for (size_t f = 0; f < filenames.size(); ++f) {
if (!m_isSearching) return;
m_outputCrit.Enter();
m_currentPath = path + filenames[f];
m_outputCrit.Leave();
filepath = m_currentPath;
// Map the file to memory
buf.Open(filepath);
if (!buf.IsMapped()) {
wxLogDebug(wxT(" Mapping failed!"));
continue;
}
// Search the file
DoSearch(buf, si, matches);
if (matches.empty()) continue;
// Show matches
WriteResult(buf, filepath, matches);
matches.clear();
}
for (size_t d = 0; d < dirs.size(); ++d) {
const wxString dirpath = path + dirs[d] + wxFILE_SEP_PATH;
SearchDir(dirpath, si, infoHandler);
}
}
int main(int argc, const char **argv)
{
IntMatrix_t **optab = NULL;
int flags;
SpinUpInfo_t SpInfo;
if (Init(argc,argv) != 0)
{
MTX_ERROR("Initialization failed");
return 1;
}
if (OpName != NULL)
optab = &OpTable;
SpinUpInfoInit(&SpInfo);
if (MaxDim > 0)
SpInfo.MaxSubspaceDimension = MaxDim;
if (MaxTries > 0)
SpInfo.MaxTries = MaxTries;
flags = 0;
/* Seed mode: SF_MAKE, SF_EACH, or SF_FIRST.
----------------------------------------- */
if (TryOneVector)
flags |= SF_FIRST;
else if (TryLinearCombinations)
flags |= SF_MAKE;
else
flags |= SF_EACH;
/* Search mode: SF_CYCLIC, SF_SUB, or SF_COMBINE.
---------------------------------------------- */
if (FindCyclicVector)
flags |= SF_CYCLIC;
else if (FindClosure)
flags |= SF_COMBINE;
else
flags |= SF_SUB;
/* Spin-up mode: SF_STD or nothing.
-------------------------------- */
if (Standard)
flags |= SF_STD;
if (!Permutations)
Span = SpinUp(Seed,Rep,flags,optab,&SpInfo);
else
Span = SpinUpWithPermutations(Seed,ngen,Perm,flags,optab,&SpInfo);
if (Span == NULL)
{
MTX_ERROR("Spin-up failed");
return -1;
}
if (WriteResult() != 0)
return 1;
Cleanup();
return 0;
}
int MatchCSA::MatchNetwork(){
/************************************************
通信連続対局
************************************************/
#ifdef WIN32
HANDLE hTh_r; // レシーブスレッド
HANDLE hTh_e; // 相手番思考スレッド
#else
pthread_t tid_r; // レシーブスレッド
pthread_t tid_e; // 相手番思考スレッド
#endif
// スレッドを沸かしたかどうか
bool bTh_r = false; // レシーブスレッド
bool bTh_e = false; // 相手番思考スレッド
bool started;
int i;
LoadConfig();
for( i = 0 ; i < repeat ; i++ ){
started = false;
// 定刻まで待機
cout << "Waiting.." << '\n';
if( !Timer() ){
// 打ち切り
cout << "Stop!" << '\n';
return 1;
}
// フラグを下げる。
rflag = 0U;
// 接続
if( !Connect() ){
return 0;
}
cout << "Connected." << '\n';
// 受信スレッドを沸かす。
#ifdef WIN32
if( INVALID_HANDLE_VALUE != ( hTh_r = (HANDLE)_beginthreadex( NULL, 0, ReceiveThread, (LPVOID)this, 0, NULL ) ) ){
#else
if( 0 == pthread_create( &tid_r, NULL, ReceiveThread, (void*)this ) ){
#endif
bTh_r = true;
}
// ログイン
if( !Login() ){
Disconnect();
return 0;
}
cout << "Login OK." << '\n';
// 対局条件取得
if( !GetRecFlag( MATCH_CSA_SUMMARY ) ){
goto lab_logout;
}
#if USE_QUICKCOPY
pcons->PresetTrees( pshogi );
#endif
// 対局開始
if( !SendAgree() ){
goto lab_logout;
}
started = true;
MutexLock();
cout << "Start." << '\n';
MutexUnlock();
// 開始時刻
start.setNow();
end = start;
while( 1 ){
// 局面の表示
#if POSIX
pshogi->PrintBan( true );
#else
pshogi->PrintBan();
#endif
#ifndef NDEBUG
// Debug用棋譜出力
OutputFileCSA( "debug.csa" );
#endif
if( pshogi->GetSengo() == info.sengo ){
// 自分の手番
THINK_INFO think_info;
MOVE move;
int ret;
int l;
memset( &think_info, 0, sizeof(THINK_INFO) );
// 思考時間
l = limit;
// 時間制限あり
if( atime.IsValidSetting() ){
// 秒読みあり
if( atime.GetReadingOffSeconds() > 0 ){
// 秒読みも含めた残り時間を超えようとしている場合
if( atime.GetUsableTime() <= (double)limit ){
l = (int)( atime.GetUsableTime() - 1.0 );
}
}
// 切れ負け
else{
// 持ち時間の20分の1を上限
if( atime.GetRemainingTime() < limit * 20.0 ){
l = (int)( atime.GetRemainingTime() / 20.0 ) + 1;
}
}
}
else{
cout << "unlimited.\n";
}
// 乱数合議用正規乱数の偏差
pcons->SetDeviation( deviation );
// 探索
if( limit_node != U64(0) ){
pcons->SetNodeLimit( limit_node );
}
pcons->SetLimit( l );
ret = pcons->SearchLimit( pshogi, pbook, &move, depth,
&think_info, Think::SEARCH_DISP | Think::SEARCH_EASY );
pcons->UnsetLimit();
if( limit_node != U64(0) ){ // UnsetNodeLimitは無条件で読んでも良い。
pcons->UnsetNodeLimit();
}
#ifndef NDEBUG
Debug::Print( "split=%u, split_failed=%u, unused_tree=%u\n",
(unsigned)think_info.split, (unsigned)think_info.split_failed,
(unsigned)think_info.unused_tree );
#endif
// 時間切れなど
if( rflag & MATCH_CSA_MASK_END ){
SetResult();
goto lab_logout;
}
// 投了
if( ret == 0 || resign.bad( think_info ) ){
SendToryo();
SetResult( RES_LOSE );
goto lab_logout;
}
if( pshogi->MoveD( move ) ){
// 指し手の送信
if( !SendMove( &think_info ) ){
SetResult( RES_ERR );
goto lab_logout;
}
}
else{
// 投了
SendToryo();
SetResult( RES_LOSE );
goto lab_logout;
}
}
else{
// 相手の手番
unsigned rec;
// 相手番思考を開始
// 思考スレッドを沸かす。
#if 1
eflag = 0;
if( enemyTurnSearch &&
#ifdef WIN32
INVALID_HANDLE_VALUE != ( hTh_e = (HANDLE)_beginthreadex( NULL, 0, EnemyTurnSearchThread, (LPVOID)this, 0, NULL ) )
#else
0 == pthread_create( &tid_e, NULL, EnemyTurnSearchThread, (void*)this )
#endif
){
bTh_e = true;
}
#endif
// 相手の手を待つ。
rec = GetRecFlag( MATCH_CSA_MASK_MOVE | MATCH_CSA_MASK_END );
// 相手番思考を終了
// スレッドの終了を待つ。
#if 1
eflag = 1;
if( bTh_e ){
#ifdef WIN32
WaitForSingleObject( hTh_e, INFINITE );
CloseHandle( hTh_e );
#else
pthread_join( tid_e, NULL );
#endif
bTh_e = false;
}
#endif
if( rec & MATCH_CSA_MASK_MOVE ){
// 相手の指し手の読み込み
if( pshogi->InputLineCSA( MoveStrEnemy() ) ){
InputTime( MoveStrEnemy() ); // 消費時間
}
else{
// 反則手?
if( GetRecFlag( MATCH_CSA_MASK_END ) ){
// 反則などで終了
goto lab_logout;
}
else{
// 原因不明のトラブル(?)
goto lab_logout;
}
}
}
else{
// 終局 or 中断
goto lab_logout;
}
}
// 指し手の表示
pshogi->PrintMove( true );
}
lab_logout:
// 相手番思考を終了
eflag = 1;
if( bTh_e ){
#ifdef WIN32
WaitForSingleObject( hTh_e, INFINITE );
CloseHandle( hTh_e );
#else
pthread_join( tid_e, NULL );
#endif
bTh_e = false;
}
// ログアウト
Logout();
cout << "Logout." << '\n';
// 切断
Disconnect();
cout << "Disconnected." << '\n';
// スレッドの終了を待つ。
if( bTh_r ){
#ifdef WIN32
WaitForSingleObject( hTh_r, INFINITE );
CloseHandle( hTh_r );
#else
pthread_join( tid_r, NULL );
#endif
bTh_r = false;
}
// 終了時刻
end.setNow();
// 結果の記録
if( started ){
WriteResult( i );
}
}
return 1;
}
#ifdef WIN32
unsigned __stdcall MatchCSA::EnemyTurnSearchThread( LPVOID p ){
#else
void* MatchCSA::EnemyTurnSearchThread( void* p ){
#endif
/************************************************
相手番で探索をするスレッド
************************************************/
MatchCSA* pmatchCSA = (MatchCSA*)p;
THINK_INFO info;
pmatchCSA->pcons->EnemyTurnSearch( pmatchCSA->pshogi, NULL,
MAX_DEPTH, &info, &pmatchCSA->eflag, Think::SEARCH_DISP );
#ifdef WIN32
return 0;
#else
return NULL;
#endif
}
int main(int argc, char **argv)
{
unsigned full_max_points = 512,
triangle_max_points = 1024,
sprint_max_points = 64;
Args args(argc, argv,
"[options] DRIVER FILE\n"
"Options:\n"
" --full-points=512 Maximum number of full trace points (default = 512)\n"
" --triangle-points=1024 Maximum number of triangle trace points (default = 1024)\n"
" --sprint-points=64 Maximum number of sprint trace points (default = 64)");
const char *arg;
while ((arg = args.PeekNext()) != nullptr && *arg == '-') {
args.Skip();
const char *value;
if ((value = StringAfterPrefix(arg, "--full-points=")) != nullptr) {
unsigned _points = strtol(value, NULL, 10);
if (_points > 0)
full_max_points = _points;
else {
fputs("The start parameter could not be parsed correctly.\n", stderr);
args.UsageError();
}
} else if ((value = StringAfterPrefix(arg, "--triangle-points=")) != nullptr) {
unsigned _points = strtol(value, NULL, 10);
if (_points > 0)
triangle_max_points = _points;
else {
fputs("The start parameter could not be parsed correctly.\n", stderr);
args.UsageError();
}
} else if ((value = StringAfterPrefix(arg, "--sprint-points=")) != nullptr) {
unsigned _points = strtol(value, NULL, 10);
if (_points > 0)
sprint_max_points = _points;
else {
fputs("The start parameter could not be parsed correctly.\n", stderr);
args.UsageError();
}
} else {
args.UsageError();
}
}
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
static Trace full_trace(0, Trace::null_time, full_max_points);
static Trace triangle_trace(0, Trace::null_time, triangle_max_points);
static Trace sprint_trace(0, 9000, sprint_max_points);
Result result;
Run(*replay, result, full_trace, triangle_trace, sprint_trace);
delete replay;
const ContestStatistics olc_plus = SolveContest(Contest::OLC_PLUS, full_trace, triangle_trace, sprint_trace);
const ContestStatistics dmst = SolveContest(Contest::DMST, full_trace, triangle_trace, sprint_trace);
TextWriter writer("/dev/stdout", true);
{
JSON::ObjectWriter root(writer);
WriteResult(root, result);
root.WriteElement("phases", WritePhaseList,
flight_phase_detector.GetPhases());
root.WriteElement("performance", WritePerformanceStats,
flight_phase_detector.GetTotals());
root.WriteElement("contests", WriteContests, olc_plus, dmst);
}
}
