public int nunsplitghost; // # of ghost unsplit cells I store public void AddParentCell(int id, int iparent, int nx, int ny, int nz, double[] lo, double[] hi) { GrowPcells(1); ParentCell p = new ParentCell(); p.id = id; p.mask = 1; if (iparent >= 0) { p.level = pcells[iparent].level + 1; p.nbits = pcells[iparent].nbits + pcells[iparent].newbits; } else { p.level = p.nbits = 0; } p.newbits = IdBits(nx, ny, nz); p.iparent = iparent; p.grandparent = 0; // set by caller if (p.nbits + p.newbits > maxbits) { sparta.DumpError("Cell ID has too many bits"); } p.nx = nx; p.ny = ny; p.nz = nz; p.lo[0] = lo[0]; p.lo[1] = lo[1]; p.lo[2] = lo[2]; p.hi[0] = hi[0]; p.hi[1] = hi[1]; p.hi[2] = hi[2]; pcells.Add(p); nparent++; }
private void Params(int narg, string[] arg) { copyflag = false; bool deleteflag = false; bool fracflag = false; bool groupflag = false; double fracvalue; int grouparg; int iarg = 0; while (iarg < narg) { switch (arg[iarg]) { case "vstream": if (iarg + 4 > narg) { sparta.DumpError("Illegal mixture command"); } vstream_flag = 1; vstream_user[0] = double.Parse(arg[iarg + 1]); vstream_user[1] = double.Parse(arg[iarg + 2]); vstream_user[2] = double.Parse(arg[iarg + 3]); iarg += 4; break; default: sparta.DumpError(string.Format("complete Mixture->params arg:{0}", arg[iarg])); break; } } if (deleteflag) { sparta.DumpMessage("complete Mixture->params deleteflag"); } if (fracflag) { sparta.DumpMessage("complete Mixture->params fracflag"); } if (groupflag) { sparta.DumpMessage("complete Mixture->params groupflag"); } ShrinkGroup(); }
private void Dimension() { Domain domain = sparta.domain; if (args.Length != 1) { sparta.DumpError("Illegal dimension command"); } if (domain.box_exist) { sparta.DumpError("Dimension command after simulation box is defined"); } domain.dimension = int.Parse(args[0]); if (domain.dimension != 2 && domain.dimension != 3) { sparta.DumpError("Illegal dimension command"); } }
public void CheckPointInside() { int nbad = 0; double[] x; Domain domain = sparta.domain; int dim = domain.dimension; double[] boxlo = domain.boxlo; double[] boxhi = domain.boxhi; if (dim == 2) { //parallel foreach (Line l in lines) { x = l.p1; if (x[0] < boxlo[0] || x[0] > boxhi[0] || x[1] < boxlo[1] || x[1] > boxhi[1] || x[2] < boxlo[2] || x[2] > boxhi[2]) { nbad++; } x = l.p2; if (x[0] < boxlo[0] || x[0] > boxhi[0] || x[1] < boxlo[1] || x[1] > boxhi[1] || x[2] < boxlo[2] || x[2] > boxhi[2]) { nbad++; } } } else { sparta.DumpError("Surf->CheckPointInside: dim==3"); } if (nbad != 0) { sparta.DumpError(string.Format("{0} surface points are not inside simulation box", nbad)); } }
public void Command(string[] arg) { Domain domain = sparta.domain; Grid grid = sparta.grid; int narg = arg.Length; if (!domain.box_exist) { sparta.DumpError("Cannot create grid before simulation box is defined"); } if (grid.exist) { sparta.DumpError("Cannot create grid when grid is already defined"); } grid.exist = true; if (narg < 3) { sparta.DumpError("Illegal create_grid command"); } int nx = int.Parse(arg[0]); int ny = int.Parse(arg[1]); int nz = int.Parse(arg[2]); if (nx < 1 || ny < 1 || nz < 1) { sparta.DumpError("Illegal create_grid command"); } if (domain.dimension == 2 && nz != 1) { sparta.DumpError("Create_grid nz value must be 1 for a 2d simulation"); } dimension = domain.dimension; int nlevels = 1; Bstyle bstyle = Bstyle.NONE; int px = 0; int py = 0; int pz = 0; int order; Inside inside = Inside.ANY; int iarg = 3; while (iarg < narg) { sparta.DumpError("Complete CreateGrid.Command optional arguments"); iarg++; } if (bstyle == Bstyle.NONE) { bstyle = Bstyle.LEVEL; } if (bstyle == Bstyle.BLOCK) { sparta.DumpError("Complete CreateGrid.Command Bstyle.Block"); } double time1 = Timer.getTime(); int level = 1; int xlo, xhi, ylo, yhi, zlo, zhi; xlo = xhi = ylo = yhi = zlo = zhi = 1; iarg = 3; Region region = null; Int64 count = 0; int pnx, pny, pnz, ix, iy, iz, nbits, proc; bool pflag; int m, nth, idgrandparent, idparent, idchild; double[] lo = new double[3], hi = new double[3]; Grid.ParentCell p; while (true) { if (level == 1) { grid.AddParentCell(0, -1, nx, ny, nz, domain.boxlo, domain.boxhi); } else { int nparent = grid.nparent; int prevlevel = level - 2; for (int igrandparent = 0; igrandparent < nparent; igrandparent++) { if (grid.pcells[igrandparent].level != prevlevel) { continue; } p = grid.pcells[igrandparent]; idgrandparent = p.id; nbits = p.nbits; pnx = p.nx; pny = p.ny; pnz = p.nz; m = 0; for (iz = 0; iz < pnz; iz++) { for (iy = 0; iy < pny; iy++) { for (ix = 0; ix < pnx; ix++) { m++; idparent = idgrandparent | (m << nbits); grid.IdChildLohi(igrandparent, m, lo, hi); if (region != null) { pflag = CellInRegion(lo, hi, region, inside); } else { pflag = true; if (ix + 1 < xlo || ix + 1 > xhi) { pflag = false; } if (iy + 1 < ylo || iy + 1 > yhi) { pflag = false; } if (iz + 1 < zlo || iz + 1 > zhi) { pflag = false; } } if (pflag) { grid.AddParentCell(idparent, igrandparent, nx, ny, nz, lo, hi); } else { if (count % 1 == 0) { grid.AddChildCell(idparent, igrandparent, lo, hi); } count++; } } } } } } // final level, add current level cells as child cells // loop over all parent cells to find ones at previous level // use their info to generate my child cells at this level // if BSTYLE is set, there is only 1 level, create proc's cells directly if (level == nlevels) { List <Grid.ParentCell> pcells = grid.pcells; int nparent = grid.nparent; int prevlevel = level - 1; for (int iparent = 0; iparent < nparent; iparent++) { if (pcells[iparent].level != prevlevel) { continue; } p = pcells[iparent]; idparent = p.id; nbits = p.nbits; nx = p.nx; ny = p.ny; nz = p.nz; if (bstyle == Bstyle.LEVEL) { int ntotal = (int)nx * ny * nz; int firstproc = (int)count % 1; int ifirst = 0 - firstproc + 1; if (ifirst <= 0) { ifirst += 1; } for (m = ifirst; m <= ntotal; m += 1) { idchild = idparent | (m << nbits); grid.IdChildLohi(iparent, m, lo, hi); grid.AddChildCell(idchild, iparent, lo, hi); } count += ntotal; // loop over all child cells // convert M to Nth based on order // assign each cell to proc based on Nth and STRIDE or CLUMP } else { sparta.DumpError("CreateGrid->Command: more Bstyle"); } } break; } if (level == nlevels) { break; } level++; switch (arg[iarg]) { //case "level" default: sparta.DumpError("CreateGrid->Command: complete this"); break; } } List <Grid.ParentCell> pcells1 = grid.pcells; int nparent1 = grid.nparent; for (int i = 1; i < nparent1; i++) { pcells1[pcells1[i].iparent].grandparent = 1; } if (bstyle == Bstyle.CLUMP || bstyle == Bstyle.BLOCK) { grid.clumped = true; } else { grid.clumped = false; } double time2 = Timer.getTime(); grid.SetupOwned(); grid.AcquireGhosts(); grid.FindNeighbors(); grid.CheckUniform(); double time3 = Timer.getTime(); double time_total = time3 - time1; StringBuilder sb = new StringBuilder(); sb.AppendFormat("Create {0} child grid cells\n", grid.ncell); sb.AppendFormat(" parent cells = {0}\n", grid.nparent); sb.AppendFormat(" CPU time = {0} secs\n", time_total); sb.AppendFormat(" create/ghost percent = {0} {1}\n", 100.0 * (time2 - time1) / time_total, 100.0 * (time3 - time2) / time_total); sparta.DumpMessage(sb.ToString()); }
public void Command(string[] arg) { Grid grid = sparta.grid; Surf surf = sparta.surf; Domain domain = sparta.domain; Particle particle = sparta.particle; int narg = arg.Length; filename = arg[0]; double[] origion = new double[3]; if (!grid.exist) { sparta.DumpError("Cannot read_surf before grid is defined"); } surf.exist = true; dim = domain.dimension; if (narg < 1) { sparta.DumpError("Illegal read_surf command"); } Console.WriteLine("Reading surf file ...\n"); try { fp = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read); } catch (Exception e) { throw e; } double time1 = Timer.getTime(); Header(); pts = new List<Point>(npoint); lines = new List<Line>(nline); ParseKeyword(true); ParseKeyword(false); PartFlag pf = PartFlag.NONE; bool grouparg = false; int iarg = 1; while (iarg < narg) { switch (arg[iarg]) { default: sparta.DumpError(string.Format("ReadSurf->Command: complete args {0}", arg[iarg])); break; } } if (particle.exist && pf == PartFlag.NONE) { sparta.DumpError("Using read_surf particle none when particles exist"); } //if (grouparg) //{ // int igroup=surf.FindGroup //} // extent of surfs after geometric transformations // compute sizes of smallest surface elements double[,] extent = new double[3, 2]; extent[0, 0] = extent[1, 0] = extent[2, 0] = double.MaxValue; extent[0, 1] = extent[1, 1] = extent[2, 1] = -double.MaxValue; foreach (Point p in pts) { extent[0, 0] = Math.Min(extent[0, 0], p.x[0]); extent[0, 1] = Math.Max(extent[0, 1], p.x[0]); extent[1, 0] = Math.Min(extent[1, 0], p.x[1]); extent[1, 1] = Math.Max(extent[1, 1], p.x[1]); extent[2, 0] = Math.Min(extent[2, 0], p.x[2]); extent[2, 1] = Math.Max(extent[2, 1], p.x[2]); } double minlen=0, minarea=0; if (dim == 2) { minlen = ShortestLine(); } if (dim == 3) { sparta.DumpError("Readsurf->Command: complete dimension3"); } StringBuilder sb = new StringBuilder(); sb.AppendFormat(" {0:G6} {1:G6} xlo xhi\n", extent[0, 0], extent[0, 1]); sb.AppendFormat(" {0:G6} {1:G6} ylo yhi\n", extent[1, 0], extent[1, 1]); sb.AppendFormat(" {0:G6} {1:G6} zlo zhi\n", extent[2, 0], extent[2, 1]); if (dim==2) { sb.AppendFormat(" {0:G6} min line length\n", minlen); } else { sparta.DumpError("Readsurf->Command: complete dimension3"); } sparta.DumpMessage(sb.ToString()); if (dim == 2) { surf.nline = nline; surf.Grow(); List<Surf.Line> newlines = surf.lines; int m = 0; foreach (Line line in lines) { Surf.Line l = new Surf.Line(); l.id = m + 1; // check for overflow when allow distributed surfs l.type = line.type; l.mask = line.mask; l.isc = l.isr = -1; Array.Copy(pts[line.p1].x, l.p1, 3); Array.Copy(pts[line.p2].x, l.p2, 3); newlines.Add(l); m++; } } else if (dim==3) { sparta.DumpError("Readsurf->Command: complete dimension3"); } if (dim==2) { surf.ComputeLineNormal(); } else { sparta.DumpError("Readsurf->Command: complete dimension3"); } if (dim == 2) { surf.CheckPointInside(); } else { sparta.DumpError("Readsurf->Command: complete dimension3"); } double time2 = Timer.getTime(); if (particle.exist) { particle.Sort(); } surf.SetupSurf(); //todo:not necessary grid.UnsetNeighbors(); grid.RemoveGhosts(); if (particle.exist&&grid.nsplitlocal!=0) { throw new NotImplementedException(); } grid.ClearSurf(); double time3 = Timer.getTime(); if (dim==2) { surf.CheckWatertight2d(nline); CheckNeighborNorm2d(); } double time4 = Timer.getTime(); //todo:continue grid.SurftoGrid(true); throw new NotImplementedException(); }
private void SetUnit(string str) { switch (str) { case "cgs": boltz = 1.3806488e-16; mvv2e = 1.0; dt = 1.0; break; case "si": boltz = 1.3806488e-23; mvv2e = 1.0; dt = 1.0; break; default: sparta.DumpError("Illegal units command"); break; } unit_style = str; }
public void SetBoundry(string[] arg) { int narg = arg.Length; if (box_exist) { sparta.DumpError("Boundary command after simulation box is defined"); } if (narg != 3) { sparta.DumpError("Illegal boundary command"); } char c; int m = 0; for (int idim = 0; idim < 3; idim++) { for (int iside = 0; iside < 2; iside++) { if (iside == 0) { c = arg[idim][0]; } else if (iside == 1 && arg[idim].Length == 1) { c = arg[idim][0]; } else { c = arg[idim][1]; } if (c == 'o') { bflag[m] = bc.OUTFLOW; } else if (c == 'p') { bflag[m] = bc.PERIODIC; } else if (c == 'r') { bflag[m] = bc.REFLECT; } else if (c == 's') { bflag[m] = bc.SURFACE; } else if (c == 'a') { bflag[m] = bc.AXISYM; } else { sparta.DumpError("Illegal boundary command"); } surf_collide[m] = surf_react[m] = -1; m++; } } if (dimension == 2 && (bflag[(int)bd.ZLO] != bc.PERIODIC || bflag[(int)bd.ZHI] != bc.PERIODIC)) { sparta.DumpError("Z dimension must be periodic for 2d simulation"); } if (bflag[(int)bd.XLO] == bc.AXISYM || bflag[(int)bd.XHI] == bc.AXISYM || bflag[(int)bd.YHI] == bc.AXISYM || bflag[(int)bd.ZLO] == bc.AXISYM || bflag[(int)bd.ZHI] == bc.AXISYM) { sparta.DumpError("Only ylo boundary can be axi-symmetric"); } if (bflag[(int)bd.YLO] == bc.AXISYM) { axisymmetric = true; if (bflag[(int)bd.YHI] == bc.PERIODIC) { sparta.DumpError("Y cannot be periodic for axi-symmetric"); } } for (m = 0; m < 6; m += 2) { if (bflag[m] == bc.PERIODIC || bflag[m + 1] == bc.PERIODIC) { if (bflag[m] != bc.PERIODIC || bflag[m + 1] != bc.PERIODIC) { sparta.DumpError("Both sides of boundary must be periodic"); } } } }
public void Command(string[] arg) { Grid grid = sparta.grid; int narg = arg.Length; if (!grid.exist) { sparta.DumpError("Cannot balance grid before grid is defined"); } if (narg < 1) { sparta.DumpError("Illegal balance_grid command"); } Bstyle bstyle = Bstyle.NONE; Order order; int px, py, pz; RCBtype rcbwt = RCBtype.CELL; int rcbflip; switch (arg[0]) { case "rcb": if (narg != 2 && narg != 3) { sparta.DumpError("Illegal balance_grid command"); } bstyle = Bstyle.BISECTION; switch (arg[1]) { case "cell": rcbwt = RCBtype.CELL; break; case "part": rcbwt = RCBtype.PARTICLE; break; default: sparta.DumpError("Illegal balance_grid command"); break; } // undocumented optional 3rd arg // rcbflip = 3rd arg = 1 forces rcb.compute() to flip sign // of all grid cell "dots" to force totally different // assignment of grid cells to procs and induce // complete rebalance data migration rcbflip = 0; if (narg == 3) { rcbflip = int.Parse(arg[2]); } break; default: sparta.DumpError("BalanceGrid.Command(): complete arguments"); break; } if (bstyle == Bstyle.STRIDE || bstyle == Bstyle.CLUMP || bstyle == Bstyle.BLOCK) { if (!grid.uniform) { sparta.DumpError("Invalid balance_grid style for non-uniform grid"); } } double time1 = Timer.getTime(); List <Grid.ChildCell> cells = grid.cells; List <Grid.ChildInfo> cinfo = grid.cinfo; int nglocal = grid.nlocal; switch (bstyle) { case Bstyle.NONE: break; case Bstyle.STRIDE: break; case Bstyle.CLUMP: break; case Bstyle.BLOCK: break; case Bstyle.RANDOM: break; case Bstyle.PROC: break; case Bstyle.BISECTION: RCB rcb = new RCB(sparta); double[,] x; x = new double[nglocal, 3]; double[] lo, hi; int nbalance = 0; for (int icell = 0; icell < nglocal; icell++) { if (cells[icell].nsplit <= 0) { continue; } lo = cells[icell].lo; hi = cells[icell].hi; x[nbalance, 0] = 0.5 * (lo[0] + hi[0]); x[nbalance, 1] = 0.5 * (lo[1] + hi[1]); x[nbalance, 2] = 0.5 * (lo[2] + hi[2]); nbalance++; } double[] wt; if (rcbwt == RCBtype.PARTICLE) { //sparta.particle.Sort(); //int zero = 0; //int n; //wt = new double[nglocal]; //nbalance = 0; //for (int icell = 0; icell < nglocal; icell++) //{ // if (cells[icell].nsplit <= 0) continue; // n = cinfo[icell].count; // if (n!=0) wt[nbalance++] = n; // else // { // wt[nbalance++] = ZEROPARTICLE; // zero++; // } //} sparta.DumpError("BalanceGrid->Command: complete sorted by particle"); } //rcb.Compute(nbalance, x, wt, rcbflip); //rcb.Invert(); //nbalance = 0; //int[] sendproc = rcb.Sendproc; //for (int icell = 0; icell < nglocal; icell++) //{ // if (cells[icell].nsplit <= 0) continue; // cells[icell].proc = sendproc[nbalance++]; //} //nmigrate = nbalance - rcb.nkeep; break; default: break; } }