//---------------------------------------------------------------------------//
TEUCHOS_UNIT_TEST( DomainTransporter, Boundary )
{
typedef Epetra_Vector VectorType;
typedef Epetra_RowMatrix MatrixType;
typedef MCLS::MatrixTraits<VectorType,MatrixType> MT;
typedef MCLS::AdjointHistory<int> HistoryType;
typedef std::mt19937 rng_type;
typedef MCLS::AdjointDomain<VectorType,MatrixType,rng_type> DomainType;
Teuchos::RCP<const Teuchos::Comm<int> > comm =
Teuchos::DefaultComm<int>::getComm();
Teuchos::RCP<Epetra_Comm> epetra_comm = getEpetraComm( comm );
int comm_size = comm->getSize();
int comm_rank = comm->getRank();
// This test really needs a decomposed domain such that we can check
// hitting the local domain boundary.
if ( comm_size > 1 )
{
int local_num_rows = 10;
int global_num_rows = local_num_rows*comm_size;
Teuchos::RCP<Epetra_Map> map = Teuchos::rcp(
new Epetra_Map( global_num_rows, 0, *epetra_comm ) );
// Build the linear operator and solution vector. This operator will
// be assymetric so we quickly move the histories out of the domain
// before they hit the low weight cutoff.
Teuchos::RCP<Epetra_CrsMatrix> A =
Teuchos::rcp( new Epetra_CrsMatrix( Copy, *map, 0 ) );
Teuchos::Array<int> global_columns( 3 );
Teuchos::Array<double> values( 3 );
global_columns[0] = 0;
global_columns[1] = 1;
global_columns[2] = 2;
values[0] = 1.0;
values[1] = 0.49;
values[2] = 0.49;
A->InsertGlobalValues( 0, global_columns.size(),
&values[0], &global_columns[0] );
for ( int i = 1; i < global_num_rows-1; ++i )
{
global_columns[0] = i-1;
global_columns[1] = i;
global_columns[2] = i+1;
values[0] = 0.49;
values[1] = 1.0;
values[2] = 0.49;
A->InsertGlobalValues( i, global_columns.size(),
&values[0], &global_columns[0] );
}
global_columns[0] = global_num_rows-3;
global_columns[1] = global_num_rows-2;
global_columns[2] = global_num_rows-1;
values[0] = 0.49;
values[1] = 0.49;
values[2] = 1.0;
A->InsertGlobalValues( global_num_rows-1, global_columns().size(),
&values[0], &global_columns[0] );
A->FillComplete();
Teuchos::RCP<MatrixType> B = MT::copyTranspose(*A);
Teuchos::RCP<VectorType> x = MT::cloneVectorFromMatrixRows( *A );
// Build the adjoint domain.
Teuchos::ParameterList plist;
plist.set<int>( "Overlap Size", 2 );
Teuchos::RCP<DomainType> domain = Teuchos::rcp( new DomainType( B, x, plist ) );
Teuchos::RCP<MCLS::PRNG<rng_type> > rng = Teuchos::rcp(
new MCLS::PRNG<rng_type>( comm->getRank() ) );
domain->setRNG( rng );
// Build the domain transporter.
MCLS::DomainTransporter<DomainType> transporter( domain, plist );
domain->setCutoff( 1.0e-12 );
// Transport histories through the domain until they hit a boundary.
double weight = 3.0;
for ( int i = 0; i < global_num_rows-1; ++i )
{
if ( comm_rank == comm_size - 1 )
{
if ( i >= local_num_rows*comm_rank && i < local_num_rows*(comm_rank+1) )
{
HistoryType history( i, i, weight );
history.live();
transporter.transport( history );
TEST_ASSERT( history.event() ==
MCLS::Event::BOUNDARY || MCLS::Event::CUTOFF );
TEST_ASSERT( !history.alive() );
}
}
else
{
if ( i >= local_num_rows*comm_rank && i < 2+local_num_rows*(comm_rank+1) )
{
HistoryType history( i, i, weight );
history.live();
transporter.transport( history );
TEST_ASSERT( history.event() ==
MCLS::Event::BOUNDARY || MCLS::Event::CUTOFF );
TEST_ASSERT( !history.alive() );
}
}
}
}
}
//---------------------------------------------------------------------------//
TEUCHOS_UNIT_TEST( DomainTransporter, Cutoff2 )
{
typedef Epetra_Vector VectorType;
typedef MCLS::VectorTraits<VectorType> VT;
typedef Epetra_RowMatrix MatrixType;
typedef MCLS::MatrixTraits<VectorType,MatrixType> MT;
typedef MCLS::AdjointHistory<int> HistoryType;
typedef std::mt19937 rng_type;
typedef MCLS::AdjointDomain<VectorType,MatrixType,rng_type> DomainType;
Teuchos::RCP<const Teuchos::Comm<int> > comm =
Teuchos::DefaultComm<int>::getComm();
Teuchos::RCP<Epetra_Comm> epetra_comm = getEpetraComm( comm );
int comm_size = comm->getSize();
int comm_rank = comm->getRank();
int local_num_rows = 10;
int global_num_rows = local_num_rows*comm_size;
Teuchos::RCP<Epetra_Map> map = Teuchos::rcp(
new Epetra_Map( global_num_rows, 0, *epetra_comm ) );
// Build the linear operator and solution vector.
Teuchos::RCP<Epetra_CrsMatrix> A =
Teuchos::rcp( new Epetra_CrsMatrix( Copy, *map, 0 ) );
Teuchos::Array<int> global_columns( 1 );
Teuchos::Array<double> values( 1 );
for ( int i = 1; i < global_num_rows; ++i )
{
global_columns[0] = i-1;
values[0] = -0.5;
A->InsertGlobalValues( i, global_columns().size(),
&values[0], &global_columns[0] );
}
global_columns[0] = global_num_rows-1;
values[0] = -0.5;
A->InsertGlobalValues( global_num_rows-1, global_columns.size(),
&values[0], &global_columns[0] );
A->FillComplete();
Teuchos::RCP<MatrixType> B = MT::copyTranspose(*A);
Teuchos::RCP<VectorType> x = MT::cloneVectorFromMatrixRows( *A );
// Build the adjoint domain.
Teuchos::ParameterList plist;
plist.set<int>( "Overlap Size", 2 );
Teuchos::RCP<DomainType> domain = Teuchos::rcp( new DomainType( B, x, plist ) );
Teuchos::RCP<MCLS::PRNG<rng_type> > rng = Teuchos::rcp(
new MCLS::PRNG<rng_type>( comm->getRank() ) );
domain->setRNG( rng );
// Build the domain transporter.
double weight = 3.0;
double relative_cutoff = weight / 4 + 0.01;
MCLS::DomainTransporter<DomainType> transporter( domain, plist );
domain->setCutoff( relative_cutoff );
// Transport histories through the domain.
for ( int i = 0; i < global_num_rows-2; ++i )
{
if ( comm_rank == comm_size - 1 )
{
if ( i >= local_num_rows*comm_rank && i < local_num_rows*(comm_rank+1) )
{
HistoryType history( i, i, weight );
history.live();
transporter.transport( history );
TEST_EQUALITY( history.globalState(), i+2 );
TEST_EQUALITY( history.weight(), weight / 4 );
TEST_EQUALITY( history.event(), MCLS::Event::CUTOFF );
TEST_ASSERT( !history.alive() );
}
}
else
{
if ( i >= local_num_rows*comm_rank && i < 1+local_num_rows*(comm_rank+1) )
{
HistoryType history( i, i, weight );
history.live();
transporter.transport( history );
TEST_EQUALITY( history.globalState(), i+2 );
TEST_EQUALITY( history.weight(), weight / 4 );
TEST_EQUALITY( history.event(), MCLS::Event::CUTOFF );
TEST_ASSERT( !history.alive() );
}
}
}
// Check the tally.
domain->domainTally()->combineSetTallies( comm );
Teuchos::ArrayRCP<const double> x_view =
VT::view( *x );
double x_val = weight;
for ( int i = 0; i < local_num_rows; ++i )
{
if ( comm_rank == comm_size-1 && i == local_num_rows-1 )
{
TEST_EQUALITY( x_view[i], 0.0 );
}
else if ( comm_rank == comm_size-1 && i == local_num_rows-2 )
{
TEST_EQUALITY( x_view[i], 3.0/2.0 );
}
else if ( comm_rank == 0 && i == 0 )
{
TEST_EQUALITY( x_view[i], x_val );
}
else if ( comm_rank == 0 || i > 2 )
{
TEST_EQUALITY( x_view[i], 3.0*x_val/2.0 );
}
else
{
TEST_EQUALITY( x_view[i], 3.0*x_val );
}
}
}
//---------------------------------------------------------------------------//
TEUCHOS_UNIT_TEST( DomainTransporter, Boundary )
{
typedef Tpetra::Vector<double,int,long> VectorType;
typedef Tpetra::CrsMatrix<double,int,long> MatrixType;
typedef MCLS::MatrixTraits<VectorType,MatrixType> MT;
typedef MCLS::AdjointHistory<long> HistoryType;
typedef std::mt19937 rng_type;
typedef MCLS::AdjointTally<VectorType> TallyType;
typedef MCLS::AlmostOptimalDomain<VectorType,MatrixType,rng_type,TallyType>
DomainType;
Teuchos::RCP<const Teuchos::Comm<int> > comm =
Teuchos::DefaultComm<int>::getComm();
int comm_size = comm->getSize();
int comm_rank = comm->getRank();
// This test really needs a decomposed domain such that we can check
// hitting the local domain boundary.
if ( comm_size > 1 )
{
int local_num_rows = 10;
int global_num_rows = local_num_rows*comm_size;
Teuchos::RCP<const Tpetra::Map<int,long> > map =
Tpetra::createUniformContigMap<int,long>( global_num_rows, comm );
// Build the linear operator and solution vector.
Teuchos::RCP<MatrixType> A = Tpetra::createCrsMatrix<double,int,long>( map );
Teuchos::Array<long> global_columns( 3 );
Teuchos::Array<double> values( 3 );
global_columns[0] = 0;
global_columns[1] = 1;
global_columns[2] = 2;
values[0] = 1.0/comm_size;
values[1] = -0.499/comm_size;
values[2] = -0.499/comm_size;
A->insertGlobalValues( 0, global_columns(), values() );
for ( int i = 1; i < global_num_rows-1; ++i )
{
global_columns[0] = i-1;
global_columns[1] = i;
global_columns[2] = i+1;
values[0] = -0.499/comm_size;
values[1] = 1.0/comm_size;
values[2] = -0.499/comm_size;
A->insertGlobalValues( i, global_columns(), values() );
}
global_columns[0] = global_num_rows-3;
global_columns[1] = global_num_rows-2;
global_columns[2] = global_num_rows-1;
values[0] = -0.499/comm_size;
values[1] = -0.499/comm_size;
values[2] = 1.0/comm_size;
A->insertGlobalValues( global_num_rows-1, global_columns(), values() );
A->fillComplete();
Teuchos::RCP<VectorType> x = MT::cloneVectorFromMatrixRows( *A );
Teuchos::RCP<MatrixType> A_T = MT::copyTranspose(*A);
// Build the adjoint domain.
Teuchos::ParameterList plist;
plist.set<int>( "History Length", 10000 );
Teuchos::RCP<DomainType> domain =
Teuchos::rcp( new DomainType( A_T, x, plist ) );
Teuchos::RCP<MCLS::PRNG<rng_type> > rng = Teuchos::rcp(
new MCLS::PRNG<rng_type>( comm->getRank() ) );
domain->setRNG( rng );
// Build the domain transporter.
MCLS::DomainTransporter<DomainType> transporter( domain );
// Transport histories through the domain until they hit a boundary.
double weight = 3.0;
for ( int i = 0; i < global_num_rows-1; ++i )
{
if ( i >= local_num_rows*comm_rank && i < local_num_rows*(comm_rank+1) )
{
HistoryType history( i, i, weight );
history.live();
transporter.transport( history );
TEST_ASSERT( history.event() == MCLS::Event::BOUNDARY );
TEST_ASSERT( !history.alive() );
}
}
}
}
//---------------------------------------------------------------------------//
TEUCHOS_UNIT_TEST( DomainTransporter, Cutoff )
{
typedef Tpetra::Vector<double,int,long> VectorType;
typedef MCLS::VectorTraits<VectorType> VT;
typedef Tpetra::CrsMatrix<double,int,long> MatrixType;
typedef MCLS::MatrixTraits<VectorType,MatrixType> MT;
typedef MCLS::AdjointHistory<long> HistoryType;
typedef std::mt19937 rng_type;
typedef MCLS::AdjointTally<VectorType> TallyType;
typedef MCLS::AlmostOptimalDomain<VectorType,MatrixType,rng_type,TallyType>
DomainType;
Teuchos::RCP<const Teuchos::Comm<int> > comm =
Teuchos::DefaultComm<int>::getComm();
int comm_size = comm->getSize();
int comm_rank = comm->getRank();
int local_num_rows = 10;
int global_num_rows = local_num_rows*comm_size;
Teuchos::RCP<const Tpetra::Map<int,long> > map =
Tpetra::createUniformContigMap<int,long>( global_num_rows, comm );
// Build the linear operator and solution vector.
Teuchos::RCP<MatrixType> A = Tpetra::createCrsMatrix<double,int,long>( map );
Teuchos::Array<long> global_columns( 1 );
Teuchos::Array<double> values( 1, 0.5 );
for ( int i = 0; i < global_num_rows; ++i )
{
if ( i >= local_num_rows*comm_rank && i < local_num_rows*(comm_rank+1) )
{
global_columns[0] = i;
A->insertGlobalValues( i, global_columns(), values() );
}
}
A->fillComplete();
Teuchos::RCP<VectorType> x = MT::cloneVectorFromMatrixRows( *A );
Teuchos::RCP<MatrixType> A_T = MT::copyTranspose(*A);
// Build the adjoint domain.
Teuchos::ParameterList plist;
plist.set<int>( "History Length", 1 );
Teuchos::RCP<DomainType> domain = Teuchos::rcp( new DomainType( A_T, x, plist ) );
Teuchos::RCP<MCLS::PRNG<rng_type> > rng = Teuchos::rcp(
new MCLS::PRNG<rng_type>( comm->getRank() ) );
domain->setRNG( rng );
// Build the domain transporter.
double weight = 3.0;
MCLS::DomainTransporter<DomainType> transporter( domain );
// Transport histories through the domain.
for ( int i = 0; i < global_num_rows; ++i )
{
if ( i >= local_num_rows*comm_rank && i < local_num_rows*(comm_rank+1) )
{
HistoryType history( i, i, weight );
history.live();
transporter.transport( history );
TEST_EQUALITY( history.globalState(), i );
TEST_EQUALITY( history.localState(), i - local_num_rows*comm_rank );
TEST_EQUALITY( history.weight(), weight / 2 );
TEST_EQUALITY( history.event(), MCLS::Event::CUTOFF );
TEST_ASSERT( !history.alive() );
}
}
// Check the tally.
Teuchos::ArrayRCP<const double> x_view = VT::view( *x );
double x_val = weight;
for ( int i = 0; i < local_num_rows; ++i )
{
TEST_EQUALITY( x_view[i], x_val );
}
}
//pause_jouer()
void pause_jouer(){
int continuer = 1;
int suivre=0;
int debug=0;
int posee=0;
Point premier_clique={0,0};
Point precedent_motion={0,0};
Point actuel_motion={0,0};
SDL_Rect pos;
SDL_Event event;
while (continuer)
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
continuer = 0;
exit(0);
break;
case SDL_KEYDOWN:
if(event.key.keysym.sym==SDLK_a){continuer=0;exit(0);}
else if(event.key.keysym.sym==SDLK_d){test();}
if(event.key.keysym.sym==SDLK_u){
pieces=lire_solution(7);
actualiser_ecran();
}
break;
case SDL_MOUSEBUTTONUP:
premier_clique.x=event.button.x;
premier_clique.y=event.button.y;
if(event.button.button==SDL_BUTTON_LEFT){
//menu
if(premier_clique.x<=102 && premier_clique.x>=5 && premier_clique.y<=39){
if(stage<nbr_stages) stage++;
else stage=1;
init_stage(stage);
}
if(premier_clique.x<=208 && premier_clique.x>=114 && premier_clique.y<=39){
Piece* sol=lire_solution(stage);
if(sol) pieces=sol;
actualiser_ecran();
}
if(premier_clique.x<=312 && premier_clique.x>=216 && premier_clique.y<=39){
acceuil();
}
if(premier_clique.x<=419 && premier_clique.x>=324 && premier_clique.y<=39){
exit(0);
}
//movements
if(!suivre){
puts("........Transporter........");
piece_mobile=transporter(event.button.x,event.button.y);
if(piece_mobile!=NULL){
suivre=1;
if(premier_clique.x<TABLE_WIDTH) dans_table=1;else dans_table=0;
}
actualiser_ecran();
}else{
puts("........Poser.........");
posee=poser(piece_mobile,event.button.x,event.button.y);
if(posee){
piece_mobile=NULL;
dans_table=0;
actualiser_ecran();
suivre=0;
}
}
puts("........................................");
}
else if(event.button.button=SDL_BUTTON_RIGHT){
if(suivre){
puts(".....rotating....");
Point centre={event.button.x,event.button.y};
rotate_forme(piece_mobile->forme,centre);
actualiser_ecran();
}
}
break;
case SDL_MOUSEMOTION:
int xm=event.motion.x,ym=event.motion.y;
actuel_motion.x=xm;
actuel_motion.y=ym;
if(xm<TABLE_WIDTH) dans_table=1; else dans_table=0;
if(suivre){
if(piece_mobile==NULL){
puts("probleme dans l'operation de glissage");
exit(0);
}
translater_forme(piece_mobile->forme,precedent_motion,actuel_motion);
actualiser_ecran();
}else{
dans_table=0;
}
precedent_motion.x=xm;
precedent_motion.y=ym;
}
if(nbr_pieces_posees==7){
if(!mode_devel) {
if(stage<nbr_stages) stage++; else stage=1;
init_stage(stage);
continuer=0;
}
}
}
}
