vector<int> searchRange(vector<int>& nums, int target) {
vector<int> res{-1, -1};
if (nums.empty() || nums[0] > target || nums[nums.size()-1] < target) return res;
int l = 0, r = nums.size() - 1, mid = 0;
int start = -1, end = -1;
while (l < r)
{
mid = (l + r) / 2 + 1;
if (nums[mid] == target)
{
vector<int> ltmp(nums.begin() + l, nums.begin() + mid);
vector<int> rtmp(nums.begin()+mid+1, nums.begin()+r+1);
auto lvec = searchRange(ltmp, target), rvec = searchRange(rtmp, target);
if (lvec != res) start = lvec[0] + l;
else start = mid;
if (rvec != res) end = rvec[1] + mid + 1;
else end = mid;
break;
}
else if (nums[mid] < target) l = mid + 1;
else r = mid - 1;
}
if (start == -1 && end == -1 && nums[l] == target && l == r) start = end = l;
res[0] = start;
res[1] = end;
return res;
}
size_t
Handler::addClient(int fd, Network::protocols_supported_e proto)
{
// GNASH_REPORT_FUNCTION;
boost::mutex::scoped_lock lock(_mutex);
log_debug("Adding %d to the client array.", fd);
switch (proto) {
case Network::NONE:
break;
case Network::HTTP:
{
boost::shared_ptr<HTTPServer> http(new HTTPServer);
_http[fd] = http;
break;
}
case Network::HTTPS:
break;
case Network::RTMP:
{
boost::shared_ptr<RTMPServer> rtmp(new RTMPServer);
_rtmp[fd] = rtmp;
break;
}
case Network::RTMPT:
case Network::RTMPTS:
case Network::RTMPE:
case Network::RTMPS:
case Network::DTN:
default:
log_unimpl("Protocol %d for Handler::AddClient()", proto);
break;
}
_clients.push_back(fd);
_protocol[fd] = proto;
return _clients.size();
}
void DumpModel::dump(Amr* parent, int force_dump)
{
// Exit if it isn't the right time to do the dump
if (force_dump == 0 &&
parent->levelSteps(0) % interval != 0) {
return;
}
// Create flattened list of ordered, disjoint boxes from the grid hierarchy
list<Box> bxlist;
list<int> lnlist;
vector<int> rat(parent->finestLevel(), 1);
for (int ln = 0; ln <= parent->finestLevel(); ln++) {
// rat[lnp] will be ratio between levels lnp and ln
if (ln > 0) {
for (int lnp = 0; lnp < ln; lnp++) {
rat[lnp] *= parent->refRatio(ln - 1)[0];
}
}
// Insert grids of level ln into list, trimming coarser grids as needed
const BoxArray& grids = parent->boxArray(ln);
for (int igr = 0; igr < grids.size(); igr++) {
const Box& reg = grids[igr];
list<Box>::iterator bi = bxlist.begin();
list<int>::iterator li = lnlist.begin();
for ( ; bi != bxlist.end(); ) {
if (*li == ln) {
if (bi->smallEnd(0) > reg.bigEnd(0)) {
// Insert reg before bi and break
bxlist.insert(bi, reg);
lnlist.insert(li, ln);
break;
}
// Increment and continue loop as reg not inserted yet
}
else { // *li < ln
Box bx(BoxLib::refine(*bi,rat[*li]));
if (bx.bigEnd(0) >= reg.smallEnd(0)) {
if (bx.smallEnd(0) < reg.smallEnd(0) &&
bx.bigEnd(0) <= reg.bigEnd(0)) {
// Trim overlap with reg from *bi leaving low end of *bi
bx.setBig(0, reg.smallEnd(0) - 1);
bx.coarsen(rat[*li]);
*bi = bx;
// Increment and continue loop as reg not inserted yet
}
else if (bx.smallEnd(0) >= reg.smallEnd(0) &&
bx.bigEnd(0) <= reg.bigEnd(0)) {
// Remove *bi from list as reg covers it completely
list<Box>::iterator bt = bi;
list<int>::iterator lt = li;
++bi;
++li;
bxlist.erase(bt);
lnlist.erase(lt);
// Continue loop as reg not inserted yet; but bypass
// increment at end of loop since we've done it already.
continue;
}
else {
// To get this far (bx.bigEnd(0) > reg.bigEnd(0)) must be true
if (bx.smallEnd(0) < reg.smallEnd(0)) {
// Trim overlap with reg from middle of *bi, extract low frag
Box bxx(bx);
bxx.setBig(0, reg.smallEnd(0) - 1);
bxx.coarsen(rat[*li]);
// Insert this low fragment of *bi before remainder of *bi
bxlist.insert(bi, bxx);
lnlist.insert(li, *li);
}
if (bx.smallEnd(0) <= reg.bigEnd(0)) {
// Trim overlap with reg leaving end high end of *bi
bx.setSmall(0, reg.bigEnd(0) + 1);
bx.coarsen(rat[*li]);
*bi = bx;
}
// Insert reg before high end of *bi and break
bxlist.insert(bi, reg);
lnlist.insert(li, ln);
break;
}
}
}
// Increment and continue loop as reg not inserted yet
++bi;
++li;
} // end of loop over bi, li
if (bi == bxlist.end()) {
// We made it to the end without finding another place to insert reg
bxlist.push_back(reg);
lnlist.push_back(ln);
}
}
}
// bxlist now contains an ordered list of disjoint boxes representing
// the exposed portions of all levels of the hierarchy. Each box is
// at the resolution of its respective level, and the corresponding
// entry of lnlist contains the level number.
if (ParallelDescriptor::IOProcessor() && verbose >= 2) {
cout << "Printing disjoint box list" << endl;
list<Box>::iterator bi = bxlist.begin();
list<int>::iterator li = lnlist.begin();
for ( ; bi != bxlist.end(); ++bi, ++li) {
cout << "Level " << *li << ", box " << *bi << endl;
}
}
if (ParallelDescriptor::IOProcessor() && verbose >= 1) {
cout << "Creating modelDump" << endl;
}
ofstream dumpfile;
if (ParallelDescriptor::IOProcessor()) {
dumpfile.open("modelDump", std::ios::out);
}
const int bufsiz = 200; // must hold 9 fields of width 16 plus a little more
char buf[bufsiz];
// The following are not parallel loops.
// We are doing the Fab copy portion on all processors because
// all must participate, but the write is done only on IOProcessor.
int k = 1;
list<Box>::iterator bi = bxlist.begin();
list<int>::iterator li = lnlist.begin();
for ( ; bi != bxlist.end(); ++bi, ++li) {
const Box& reg = *bi;
int ln = *li;
Castro *castro = dynamic_cast<Castro*>(&parent->getLevel(ln));
MultiFab& S_new = castro->get_new_data(State_Type);
Fab stmp(reg, S_new.nComp());
S_new.copy(stmp);
if (ParallelDescriptor::IOProcessor()) {
for (int i = reg.smallEnd(0); i <= reg.bigEnd(0); i++) {
IntVect p(i);
// Quantities written as 0.0 are not currently used, so we
// don't bother to derive them.
sprintf(buf,
"%16.8E%16.8E%16.8E%16.8E%16.8E%16.8E%16.8E%16.8E%16.8E %d\n",
parent->Geom(ln).CellCenter(i, 0), // radius
stmp(p, Density), // density
stmp(p, Xmom) / stmp(p, Density), // velocity
0.0, // pressure
stmp(p, Temp), // temperature (MeV ?)
stmp(p, Eint) / stmp(p, Density), // internal energy e
0.0, // entropy
0.0, // cumulative mass
stmp(p, FirstAux / stmp(p, Density), // Ye
k++);
std::string Buf = buf;
dumpfile << Buf;
}
}
}
if (ParallelDescriptor::IOProcessor()) {
dumpfile << Radiation::nGroups << '\n';
}
k = 1;
bi = bxlist.begin();
li = lnlist.begin();
for ( ; bi != bxlist.end(); ++bi, ++li) {
const Box& reg = *bi;
int ln = *li;
Castro *castro = dynamic_cast<Castro*>(&parent->getLevel(ln));
MultiFab& R_new = castro->get_new_data(Rad_Type);
Fab rtmp(reg, R_new.nComp());
R_new.copy(rtmp);
if (ParallelDescriptor::IOProcessor()) {
for (int i = reg.smallEnd(0); i <= reg.bigEnd(0); i++) {
IntVect p(i);
char* bufp = buf;
for (int j = 0; ; j++) {
sprintf(bufp, "%16.8E", rtmp(p, j));
bufp += 16;
if (j + 1 == Radiation::nGroups) {
sprintf(bufp, " %d\n", k++);
std::string Buf = buf;
dumpfile << Buf;
break;
}
else if (j % 4 == 3) {
sprintf(bufp, "\n");
std::string Buf = buf;
dumpfile << Buf;
bufp = buf;
}
}
}
}
}
if (ParallelDescriptor::IOProcessor()) {
dumpfile.close();
}
}
