//
// this assumes that the user has set appropriate initial
// conditions on each level
//
void run() {
for (int nstep=0; nstep<this->nsteps; nstep++) {
time t = nstep * this->dt;
// predictor: sweep and interpolate to finest level
for (auto leviter=this->coarsest(); leviter<this->finest(); ++leviter) {
auto* sweeper = leviter.current();
auto* transfer = leviter.transfer();
if (leviter.level == 0) {
sweeper->predict(t, this->dt);
for (int s=1; s<nsweeps[leviter.level]; s++)
sweeper->sweep(t, this->dt);
} else {
for (int s=0; s<nsweeps[leviter.level]; s++)
sweeper->sweep(t, this->dt);
}
if (leviter < this->finest())
transfer->interpolate(leviter.fine(), leviter.current(), true);
}
// iterate by performing v-cycles
for (int niter=0; niter<this->niters; niter++)
cycle_v(this->finest(), t, this->dt);
// advance each level
for (auto lev=this->coarsest(); lev<=this->finest(); ++lev)
lev.current()->advance();
}
}
int main() {
freopen("color.in", "r", stdin);
freopen("color.out", "w", stdout);
scanf("%d%d", &n, &p);
for(int x = 0; x < (1 << n); x ++)
if(fine(x))
res ++;
printf("%d\n", res);
}
int main()
{
while(2==scanf("%d%d",&n,&m))
{
init();
if(fine())
{
printf("-1\n");
continue;
}
printf("%d\n",aws());
}
return 0;
}
void update_hash(string coordfile) {
ifstream coordstream(coordfile);
floatVector fine(3);
intVector fineInt(3);
intVector coarse(3);
while(coordstream.good()) {
coordstream >> fine[0]; coordstream >> fine[1]; coordstream >> fine[2];
for (int z=0; z<2; z++)
for (int y=0; y<2; y++)
for (int x=0; x<2; x++) {
fineInt[0]=(int)fine[0]+x; fineInt[1]=(int)fine[1]+y; fineInt[2]=(int)fine[2]+z;
conn_profile()[fineInt]=vector<float>(); // just to store the key
}
fine2coarse(fine, coarse);
if (!coarse_map().count(coarse))
coarse_map()[coarse] = coarse_map().size();
}
}
///*
int main(){ //第3回試走会用
int ball_count = 0;
bool area_flag = OFF;
float serch_posi = 0.0;
float move_dis = 0.0;
state = init_state;
// color = RED;
while(1){ //while開始
switch(state){
case init_state:
initialize();
state = free_ball;
//state = ball_search;
//state = finish;
break;
case free_ball:
Line_Trace(3);
turn(85.0, FAST);
wait(0.25);
servo_throw();
wait(0.25);
servo_ini();
wait(0.25);
turn(-85.0,FAST);
Line_Trace(2);
state = ball_search;
break;
case ball_search:
if(move_flag){
while(l_Y <= move_dis)
Line_Trace();
stop();
move_flag = OFF;
}
else{
if(color != NO_BALL){
while(l_Y <= serch_posi)
Line_Trace();
stop();
}
}
serch();
state = ball_shoot;
//if((l_time+35) > LIMIT)
// state = finish;
break;
case ball_shoot:
wait(0.25);
//color = what_color();
if(color != NO_BALL){ //色を得られたら
//turn(180, FAST);
//wait(0.25);
if(area_flag){
if(color == YELLO)
Line_Trace(color);
else
Line_Trace(color + 1);
}
else{
if(color == YELLO)
Line_Trace(color - 1);
else
Line_Trace(color);
}
Ball_Shoot();
ball_count++;
if(ball_count == B_GOAL || (l_time+35) > LIMIT){
state = finish;
break;
}
if(color == YELLO)
Line_Trace(color - 1);
else
Line_Trace(color);
}
//目標まで行ったかの確認
state = ball_search;
if(move_flag)
state = area_move;
break;
case area_move:
move_dis = 250;
if(serch_posi >= 1200 - move_dis) //行き過ぎ防止用
move_dis = 0;
serch_posi += move_dis;
area_flag = ON;
state = ball_search;
break;
case finish:
fine();
break;
}//switch終了
}//while終了
}//main終了
void
LevelFluxRegisterEdge::refluxCurl(LevelData<FluxBox>& a_uCoarse,
Real a_scale)
{
CH_assert(isDefined());
CH_assert(a_uCoarse.nComp() == m_nComp);
SideIterator side;
// idir is the normal direction to the coarse-fine interface
for (int idir=0 ; idir<SpaceDim; ++idir)
{
for (side.begin(); side.ok(); ++side)
{
LevelData<FluxBox>& fineReg = m_fabFine[index(idir, side())];
// first, create temp LevelData<FluxBox> to hold "coarse flux"
const DisjointBoxLayout coarseBoxes = m_regCoarse.getBoxes();
// this fills the place of what used to be m_fabCoarse in the old
// implementation
LevelData<FluxBox> coarReg(coarseBoxes, m_nComp, IntVect::Unit);
// now fill the coarReg with the curl of the stored coarse-level
// edge-centered flux
DataIterator crseDit = coarseBoxes.dataIterator();
for (crseDit.begin(); crseDit.ok(); ++crseDit)
{
FluxBox& thisCoarReg = coarReg[crseDit];
thisCoarReg.setVal(0.0);
EdgeDataBox& thisEdgeData = m_regCoarse[crseDit];
for (int edgeDir=0; edgeDir<SpaceDim; edgeDir++)
{
if (idir != edgeDir)
{
FArrayBox& crseEdgeDataDir = thisEdgeData[edgeDir];
for (int faceDir = 0; faceDir<SpaceDim; faceDir++)
{
if (faceDir != edgeDir)
{
FArrayBox& faceData = thisCoarReg[faceDir];
int shiftDir = -1;
for (int i=0; i<SpaceDim; i++)
{
if ((i != faceDir) && (i != edgeDir) )
{
shiftDir = i;
}
}
CH_assert(shiftDir >= 0);
crseEdgeDataDir.shiftHalf(shiftDir, sign(side()));
// scaling already taken care of in incrementCrse
Real scale = 1.0;
faceData.plus(crseEdgeDataDir, scale, 0, 0, faceData.nComp());
crseEdgeDataDir.shiftHalf(shiftDir, -sign(side()));
} // end if not normal direction
} // end loop over face directions
} // end if edgeDir != idir
} // end loop over edge directions
} // end loop over crse boxes
// first, we need to create a temp LevelData<FluxBox>
// to make a local copy in the coarse layout space of
// the fine register increments
LevelData<FluxBox> fineRegLocal(coarReg.getBoxes(), m_nComp, IntVect::Unit);
fineReg.copyTo(fineReg.interval(), fineRegLocal,
fineRegLocal.interval(),
m_crseCopiers[index(idir,side())]);
for (DataIterator it = a_uCoarse.dataIterator(); it.ok(); ++it)
{
// loop over flux components here
for (int fluxComp=0; fluxComp < SpaceDim; fluxComp++)
{
// we don't do anything in the normal direction
if (fluxComp != idir)
{
// fluxDir is the direction of the face-centered flux
FArrayBox& U = a_uCoarse[it()][fluxComp];
// set up IntVectSet to avoid double counting of updates
Box coarseGridBox = U.box();
// transfer to Cell-centered, then create IVS
coarseGridBox.shiftHalf(fluxComp,1);
IntVectSet nonUpdatedEdges(coarseGridBox);
// remember, we want to take the curl here
// also recall that fluxComp is the component
// of the face-centered curl (not the edge-centered
// vector field that we're refluxing, which is why
// the sign may seem like it's the opposite of what
// you might expect!
Real local_scale = -sign(side())*a_scale;
//int testDir = (fluxComp+1)%(SpaceDim);
if (((fluxComp+1)%(SpaceDim)) == idir) local_scale *= -1;
Vector<IntVectSet>& ivsV =
m_refluxLocations[index(idir, side())][it()][fluxComp];
Vector<DataIndex>& indexV =
m_coarToCoarMap[index(idir, side())][it()];
IVSIterator iv;
for (int i=0; i<ivsV.size(); ++i)
{
iv.define(ivsV[i]);
const FArrayBox& coar = coarReg[indexV[i]][fluxComp];
const FArrayBox& fine = fineRegLocal[indexV[i]][fluxComp];
for (iv.begin(); iv.ok(); ++iv)
{
IntVect thisIV = iv();
if (nonUpdatedEdges.contains(thisIV))
{
for (int comp=0; comp <m_nComp; ++comp)
{
//Real coarVal = coar(thisIV, comp);
//Real fineVal = fine(thisIV, comp);
U(thisIV, comp) -=
local_scale*(coar(thisIV, comp)
+fine(thisIV, comp));
}
nonUpdatedEdges -= thisIV;
}
}
}
} // end if not normal face
} // end loop over fluxbox directions
} // end loop over coarse boxes
} // end loop over sides
} // end loop over directions
}
int
main (int argc,
char* argv[])
{
BoxLib::Initialize(argc,argv);
std::cout << std::setprecision(10);
if (argc < 2)
{
std::cerr << "usage: " << argv[0] << " inputsfile [options]" << '\n';
exit(-1);
}
ParmParse pp;
int n;
BoxArray bs;
#if BL_SPACEDIM == 2
Box domain(IntVect(0,0),IntVect(11,11));
std::string boxfile("gr.2_small_a") ;
#elif BL_SPACEDIM == 3
Box domain(IntVect(0,0,0),IntVect(11,11,11));
std::string boxfile("grids/gr.3_2x3x4") ;
#endif
pp.query("boxes", boxfile);
std::ifstream ifs(boxfile.c_str(), std::ios::in);
if (!ifs)
{
std::string msg = "problem opening grids file: ";
msg += boxfile.c_str();
BoxLib::Abort(msg.c_str());
}
ifs >> domain;
if (ParallelDescriptor::IOProcessor())
std::cout << "domain: " << domain << std::endl;
bs.readFrom(ifs);
if (ParallelDescriptor::IOProcessor())
std::cout << "grids:\n" << bs << std::endl;
Geometry geom(domain);
const Real* H = geom.CellSize();
int ratio=2; pp.query("ratio", ratio);
// allocate/init soln and rhs
int Ncomp=BL_SPACEDIM;
int Nghost=0;
int Ngrids=bs.size();
MultiFab soln(bs, Ncomp, Nghost, Fab_allocate); soln.setVal(0.0);
MultiFab out(bs, Ncomp, Nghost, Fab_allocate);
MultiFab rhs(bs, Ncomp, Nghost, Fab_allocate); rhs.setVal(0.0);
for(MFIter rhsmfi(rhs); rhsmfi.isValid(); ++rhsmfi)
{
FORT_FILLRHS(rhs[rhsmfi].dataPtr(),
ARLIM(rhs[rhsmfi].loVect()),ARLIM(rhs[rhsmfi].hiVect()),
H,&Ncomp);
}
// Create the boundary object
MCViscBndry vbd(bs,geom);
BCRec phys_bc;
Array<int> lo_bc(BL_SPACEDIM), hi_bc(BL_SPACEDIM);
pp.getarr("lo_bc",lo_bc,0,BL_SPACEDIM);
pp.getarr("hi_bc",hi_bc,0,BL_SPACEDIM);
for (int i = 0; i < BL_SPACEDIM; i++)
{
phys_bc.setLo(i,lo_bc[i]);
phys_bc.setHi(i,hi_bc[i]);
}
// Create the BCRec's interpreted by ViscBndry objects
#if BL_SPACEDIM==2
Array<BCRec> pbcarray(4);
pbcarray[0] = BCRec(D_DECL(REFLECT_ODD,REFLECT_EVEN,EXT_DIR),
D_DECL(EXT_DIR,EXT_DIR,EXT_DIR));
pbcarray[1] = BCRec(D_DECL(REFLECT_EVEN,REFLECT_ODD,EXT_DIR),
D_DECL(EXT_DIR,EXT_DIR,EXT_DIR));
pbcarray[2] = BCRec(D_DECL(EXT_DIR,EXT_DIR,EXT_DIR),
D_DECL(EXT_DIR,EXT_DIR,EXT_DIR));
pbcarray[3] = BCRec(D_DECL(EXT_DIR,EXT_DIR,EXT_DIR),
D_DECL(EXT_DIR,EXT_DIR,EXT_DIR));
#elif BL_SPACEDIM==3
Array<BCRec> pbcarray(12);
#if 1
pbcarray[0] = BCRec(EXT_DIR,EXT_DIR,EXT_DIR,EXT_DIR,EXT_DIR,EXT_DIR);
pbcarray[1] = BCRec(EXT_DIR,EXT_DIR,EXT_DIR,EXT_DIR,EXT_DIR,EXT_DIR);
pbcarray[2] = BCRec(EXT_DIR,EXT_DIR,EXT_DIR,EXT_DIR,EXT_DIR,EXT_DIR);
pbcarray[3] = BCRec(D_DECL(EXT_DIR,EXT_DIR,EXT_DIR),
D_DECL(EXT_DIR,EXT_DIR,EXT_DIR));
pbcarray[4] = BCRec(D_DECL(EXT_DIR,EXT_DIR,EXT_DIR),
D_DECL(EXT_DIR,EXT_DIR,EXT_DIR));
pbcarray[5] = BCRec(D_DECL(EXT_DIR,EXT_DIR,EXT_DIR),
D_DECL(EXT_DIR,EXT_DIR,EXT_DIR));
pbcarray[6] = BCRec(D_DECL(EXT_DIR,EXT_DIR,EXT_DIR),
D_DECL(EXT_DIR,EXT_DIR,EXT_DIR));
pbcarray[7] = BCRec(D_DECL(EXT_DIR,EXT_DIR,EXT_DIR),
D_DECL(EXT_DIR,EXT_DIR,EXT_DIR));
pbcarray[8] = BCRec(D_DECL(EXT_DIR,EXT_DIR,EXT_DIR),
D_DECL(EXT_DIR,EXT_DIR,EXT_DIR));
pbcarray[9] = BCRec(D_DECL(EXT_DIR,EXT_DIR,EXT_DIR),
D_DECL(EXT_DIR,EXT_DIR,EXT_DIR));
pbcarray[10] = BCRec(D_DECL(EXT_DIR,EXT_DIR,EXT_DIR),
D_DECL(EXT_DIR,EXT_DIR,EXT_DIR));
pbcarray[11] = BCRec(D_DECL(EXT_DIR,EXT_DIR,EXT_DIR),
D_DECL(EXT_DIR,EXT_DIR,EXT_DIR));
#else
for (int i = 0; i < 12; i++)
pbcarray[i] = phys_bc;
#endif
#endif
Nghost = 1; // need space for bc info
MultiFab fine(bs,Ncomp,Nghost,Fab_allocate);
for(MFIter finemfi(fine); finemfi.isValid(); ++finemfi)
{
FORT_FILLFINE(fine[finemfi].dataPtr(),
ARLIM(fine[finemfi].loVect()),ARLIM(fine[finemfi].hiVect()),
H,&Ncomp);
}
// Create "background coarse data"
Box crse_bx = Box(domain).coarsen(ratio).grow(1);
BoxArray cba(crse_bx);
cba.maxSize(32);
Real h_crse[BL_SPACEDIM];
for (n=0; n<BL_SPACEDIM; n++) h_crse[n] = H[n]*ratio;
MultiFab crse_mf(cba, Ncomp, 0);
// FArrayBox crse_fab(crse_bx,Ncomp);
for (MFIter mfi(crse_mf); mfi.isValid(); ++mfi)
{
FORT_FILLCRSE(crse_mf[mfi].dataPtr(),
ARLIM(crse_mf[mfi].loVect()),ARLIM(crse_mf[mfi].hiVect()),
h_crse,&Ncomp);
}
// Create coarse boundary register, fill w/data from coarse FAB
int bndry_InRad=0;
int bndry_OutRad=1;
int bndry_Extent=1;
BoxArray cbs = BoxArray(bs).coarsen(ratio);
BndryRegister cbr(cbs,bndry_InRad,bndry_OutRad,bndry_Extent,Ncomp);
for (OrientationIter face; face; ++face)
{
Orientation f = face();
FabSet& bnd_fs(cbr[f]);
bnd_fs.copyFrom(crse_mf, 0, 0, 0, Ncomp);
}
// Interpolate crse data to fine boundary, where applicable
int cbr_Nstart=0;
int fine_Nstart=0;
int bndry_Nstart=0;
vbd.setBndryValues(cbr,cbr_Nstart,fine,fine_Nstart,
bndry_Nstart,Ncomp,ratio,pbcarray);
Nghost = 1; // other variables don't need extra space
DivVis lp(vbd,H);
Real a = 0.0;
Real b[BL_SPACEDIM];
b[0] = 1.0;
b[1] = 1.0;
#if BL_SPACEDIM>2
b[2] = 1.0;
#endif
MultiFab acoefs;
int NcompA = (BL_SPACEDIM == 2 ? 2 : 1);
acoefs.define(bs, NcompA, Nghost, Fab_allocate);
acoefs.setVal(a);
MultiFab bcoefs[BL_SPACEDIM];
for (n=0; n<BL_SPACEDIM; ++n)
{
BoxArray bsC(bs);
bcoefs[n].define(bsC.surroundingNodes(n), 1,
Nghost, Fab_allocate);
#if 1
for(MFIter bmfi(bcoefs[n]); bmfi.isValid(); ++bmfi)
{
FORT_MAKEMU(bcoefs[n][bmfi].dataPtr(),
ARLIM(bcoefs[n][bmfi].loVect()),ARLIM(bcoefs[n][bmfi].hiVect()),H,n);
}
#else
bcoefs[n].setVal(b[n]);
#endif
} // -->> over dimension
lp.setCoefficients(acoefs, bcoefs);
#if 1
lp.maxOrder(4);
#endif
Nghost = 1;
MultiFab tsoln(bs, Ncomp, Nghost, Fab_allocate);
tsoln.setVal(0.0);
#if 1
tsoln.copy(fine);
#endif
#if 0
// testing apply
lp.apply(out,tsoln);
Box subbox = out[0].box();
Real n1 = out[0].norm(subbox,1,0,BL_SPACEDIM)*pow(H[0],BL_SPACEDIM);
ParallelDescriptor::ReduceRealSum(n1);
if (ParallelDescriptor::IOProcessor())
{
cout << "n1 output is "<<n1<<std::endl;
}
out.minus(rhs,0,BL_SPACEDIM,0);
// special to single grid prob
Real n2 = out[0].norm(subbox,1,0,BL_SPACEDIM)*pow(H[0],BL_SPACEDIM);
ParallelDescriptor::ReduceRealSum(n2);
if (ParallelDescriptor::IOProcessor())
{
cout << "n2 difference is "<<n2<<std::endl;
}
#if 0
subbox.grow(-1);
Real n3 = out[0].norm(subbox,0,0,BL_SPACEDIM)*pow(H[0],BL_SPACEDIM);
ParallelDescriptor::ReduceRealMax(n3);
if (ParallelDescriptor::IOProcessor())
{
cout << "n3 difference is "<<n3<<std::endl;
}
#endif
#endif
const IntVect refRatio(D_DECL(2,2,2));
const Real bgVal = 1.0;
#if 1
#ifndef NDEBUG
// testing flux computation
BoxArray xfluxbox(bs);
xfluxbox.surroundingNodes(0);
MultiFab xflux(xfluxbox,Ncomp,Nghost,Fab_allocate);
xflux.setVal(1.e30);
BoxArray yfluxbox(bs);
yfluxbox.surroundingNodes(1);
MultiFab yflux(yfluxbox,Ncomp,Nghost,Fab_allocate);
yflux.setVal(1.e30);
#if BL_SPACEDIM>2
BoxArray zfluxbox(bs);
zfluxbox.surroundingNodes(2);
MultiFab zflux(zfluxbox,Ncomp,Nghost,Fab_allocate);
zflux.setVal(1.e30);
#endif
lp.compFlux(xflux,
yflux,
#if BL_SPACEDIM>2
zflux,
#endif
tsoln);
// Write fluxes
//writeMF(&xflux,"xflux.mfab");
//writeMF(&yflux,"yflux.mfab");
#if BL_SPACEDIM>2
//writeMF(&zflux,"zflux.mfab");
#endif
#endif
#endif
Real tolerance = 1.0e-10; pp.query("tol", tolerance);
Real tolerance_abs = 1.0e-10; pp.query("tol_abs", tolerance_abs);
#if 0
cout << "Bndry Data object:" << std::endl;
cout << lp.bndryData() << std::endl;
#endif
#if 0
bool use_mg_pre = false;
MCCGSolver cg(lp,use_mg_pre);
cg.solve(soln,rhs,tolerance,tolerance_abs);
#else
MCMultiGrid mg(lp);
mg.solve(soln,rhs,tolerance,tolerance_abs);
#endif
#if 0
cout << "MCLinOp object:" << std::endl;
cout << lp << std::endl;
#endif
VisMF::Write(soln,"soln");
#if 0
// apply operator to soln to see if really satisfies eqn
tsoln.copy(soln);
lp.apply(out,tsoln);
soln.copy(out);
// Output "apply" results on soln
VisMF::Write(soln,"apply");
// Compute truncation
for (MFIter smfi(soln); smfi.isValid(); ++smfi)
{
soln[smfi] -= fine[smfi];
}
for( int icomp=0; icomp < BL_SPACEDIM ; icomp++ )
{
Real solnMin = soln.min(icomp);
Real solnMax = soln.max(icomp);
ParallelDescriptor::ReduceRealMin(solnMin);
ParallelDescriptor::ReduceRealMax(solnMax);
if (ParallelDescriptor::IOProcessor())
{
cout << icomp << " "<<solnMin << " " << solnMax <<std::endl;
}
}
// Output truncation
VisMF::Write(soln,"trunc");
#endif
int dumpLp=0; pp.query("dumpLp",dumpLp);
bool write_lp = (dumpLp == 1 ? true : false);
if (write_lp)
std::cout << lp << std::endl;
// Output trunc
ParallelDescriptor::EndParallel();
}