int main() { //load config int ret = ZBus::Instance().LoadConfig("channel_temp.xml"); if (ret != 0) { printf("ret %d\n", ret); print_error(); exit(1); } //init channels ret = ZBus::Instance().InitChannels(20001); if (ret != 0) { printf("init channel failed\n"); print_error(); exit(1); } Channel* pchannel = ZBus::Instance().GetChannel(20001, 10001); if (!pchannel) { printf("get channel failed\n"); print_error(); exit(1); } Reactor reactor; ReactorHandler handler; reactor.Initialize(1); ret = reactor.RegisterChannel(pchannel, &handler); if (ret < 0) { printf("register channel failed\n"); return -1; } int i = 10; while (i) { reactor.EventLoop(1000); char str[12] = "hello world"; pchannel->Send(str, sizeof(str)); i--; } return 0; }
int main(int argc, char** argv) { setup_crash_handlers(); po::options_description desc ("Start Multilink server child"); desc.add_options() ("help", "produce help message") ("sock-fd", po::value<int>(), "FD of socket to start RPC server on") ("target-port", po::value<int>(), "target port (if using connect target)") ("target-host", po::value<string>()->default_value("127.0.0.1"), "target host") ("connect-bind", po::value<string>()->default_value("0.0.0.0"), "bind to this host when creating outbound TCP connections") ("tun-prefix", po::value<string>()->default_value("mlc"), "TUN device name prefix (if using terminate target)") ("dry-run", "only verify that options make sense"); po::variables_map vm; po::store(po::parse_command_line(argc, argv, desc), vm); po::notify(vm); if (vm.count("help")) { std::cout << desc << "\n"; return 0; } if (vm.count("target-port") && vm.count("tun-prefix")) { std::cout << desc << "\n"; return 1; } if (vm.count("dry-run")) return 0; Process::init(); Reactor reactor; Server server {reactor}; auto callback = [&](std::shared_ptr<RPCStream> stream, Json message) { server.callback(stream, message); }; if (vm.count("target-port")) { server.setup_connect_target(vm["target-host"].as<string>(), vm["target-port"].as<int>()); } else { server.setup_terminate_target(vm["connect-bind"].as<string>()); } if (vm.count("tun-prefix")) { string prefix = vm["tun-prefix"].as<string>(); string name = prefix + random_hex_string(15 - prefix.size()); server.setup_tun(name); } auto rpcserver = RPCServer::create(reactor, vm["sock-fd"].as<int>(), callback); reactor.run(); }
void processTimeEclapsed( evutil_socket_t sock, short flags, void * args ) { Reactor* reactor = (Reactor*)args; printf("定时器!!!\n"); reactor->scanLibeventContainer(); reactor->scanUnusedChannel(20); }
int main(int argc, char** argv) { Reactor *reactor = Reactor::getInstance(); reactor->callLater(30, &print_hello_world); reactor->run(); return 0; }
void* work_run(void* arg) { printf("create pthread %d\n", pthread_self()); BufBlock_t* block = NULL; BufBlock_t* new_block = NULL; Reactor* reactor = (Reactor*) arg; while (!stop) { reactor->handle_events(1000); //将接收到的协议 串行处理 while ((block=g_receive_queue.pop_queue()) != NULL) { char* send_data; int send_len = 0; int ret_code = dll.handle_process((char*)block->page_base, block->buf_head.len, &send_data, &send_len, &(block->buf_head.sk)); new_block = alloc_block(send_len); new_block->buf_head = block->buf_head; new_block->buf_head.len = send_len; memcpy(new_block->page_base, send_data, send_len); free_block(block); if (send_len != 0 && g_server_conf.need_free_send_buf) { free(send_data); } if (ret_code == -1) { //关闭链接 PUSH_ERRMSG(FIN_BLOCK); } else if (send_len == 0 || send_len > 8388608) { //长度不对 LOG4CPLUS_INFO(log4cplus::Logger::getRoot(), "socket fd="<<new_block->buf_head.sk.socket<<" send too large pkg"); PUSH_ERRMSG(CLEAR_BLOCK); } else if (send_len > 0) { new_block->buf_head.buf_type = DATA_BLOCK; if (1 == ret_code) { new_block->buf_head.buf_type |= FIN_BLOCK; } if (stop) { return ((void *)0); } HandlerBase* h = reactor->get_handler(new_block->buf_head.sk.socket); if (NULL == h) { free_block(new_block); continue; } if (!h->push_buf(new_block)) { free_block(new_block); } } } } }
void enableRead( evutil_socket_t sock, short flags, void * args ) { Reactor* reactor = (Reactor*)args; std::string addr = reactor->findaddrbysock(sock); Channel_var mychannel = reactor->mChannelTable->getChannel(addr); ByteBuffer_var readBuf = mychannel->getReadBuffer(); printf("capacity %d, size %d\n", readBuf->Capacity(), readBuf->Size()); int ret = 0; int offset = readBuf->Size(); while((ret = recv(sock, readBuf->Inout() + offset, readBuf->Capacity(), 0)) > 0) { offset += ret; } ret = offset - readBuf->Size(); readBuf->Size(offset); if(ret > 0) { mychannel->setTimestamp(); while(1) { printf("sock %d, ret %d\n", sock, ret); int length = readBuf->getInt(); int headerlength = readBuf->getInt(); printf("length %d, headerlength %d\n", length, headerlength); readBuf->adjustReadpos(-8); if(!readBuf->isFullPackage(length+4)) { return (void)0; } readBuf->adjustReadpos(8); Byte_var headerdata = new Byte(headerlength+1); headerdata->setBuffer(readBuf->getBytes(headerlength), headerlength); RemotingCommand_var responseFuture = RemotingCommand::decode(headerdata->getBuffer()); printf("header %s\n", headerdata->getBuffer()); Byte_var bodydata = new Byte(length-4-headerlength); bodydata->setBuffer(readBuf->getBytes(length-4-headerlength), length-4-headerlength); responseFuture->setBody(Byte_var::Duplicate(bodydata)); printf("body length %d\n", responseFuture->getBody()->size()); reactor->setResponse(RemotingCommand_var::Duplicate(responseFuture)); if(responseFuture->getCode() != 40) { reactor->notifyWorker(responseFuture->getOpaque()); } else { } ret -= length+4; if(ret <= 0) break; } readBuf->Reset(); } else { //连接断开 printf("server closed\n"); } }
ThreadPool::Scavenger::~Scavenger () { TRACE_CALL; Reactor* reactor = reactorGet (); if (reactor) reactor->timerRemove (this); }
void Reactor::handle_signal(int signal) { std::clog << "Signal " << signal << "caught. Terminating mainloop" << std::endl; Reactor* reactor = getInstance(); reactor->stop(); }
int main() { Eventhandler *evh=new Server; Reactor re; struct timeval tv; gettimeofday(&tv,NULL); re.register_handler(evh); re.waitEvents(&tv,doSthRead); }
// called by Connector.connect() after connection successfully established virtual int open(void *) { Reactor* reactor = this->getReactor(); Client_Timeout_Handler* timeOutHandler = new Client_Timeout_Handler; TimeValue tv1(0); TimeValue tv2(TimeSpec); if(reactor->scheduleTimer(timeOutHandler, this, tv1, tv2) == -1) { cerr << "scheduleTimer() failed!! \n"; return -1; } return SvcHandler::open(0); }
Reactor* Reactor::instance() { if (NULL == reactorM) { boost::lock_guard<boost::mutex> lock(reactorInstanceMutex); if (NULL == reactorM) { Reactor* reactor = new Reactor(); reactorInstanceReleaser.reset(reactor); reactor->start(); reactorM = reactor; } } return reactorM; }
int main() { Connector<ClientHandler> connector(Reactor::instance()); InetAddr connAddr(ServerPort, ServerIp); ClientHandler* handler = 0; // connect() will make a new ClientHandler and assign its address to handler when success if (connector.connect(handler, connAddr) == -1) { cout << "SubscribeClient::init, connect error: " << OS::strerror(OS::map_errno(OS::last_error())) << endl; return -1; } Reactor* reactor = handler->getReactor(); reactor->runReactorEventLoop(); return 0; }
void EventDriver::dispatchEvent (MZEventDispatcher* dispatcher, int events) { Reactor *r; while ((r = timeoutReactors.removeFront())) { r->mask &= ~EVENT_TIMEOUT; tryUnbind(r); log.debug("process timeout event. mask:%d r:%08x\n", r->mask, r); r->processEvent(EVENT_TIMEOUT); } { // consume event char c; while (read(timeoutFds[0], &c, sizeof(c)) > 0); } }
ConnectorBase::ConnectorBase(Reactor& reactor, auto_ptr<HandlerCreatorStrategyBase> handler_creator_stg, auto_ptr<FilterCreatorStrategyBase> filter_stg, int flag) : sp_reactor_impl_(reactor.impl()), sp_creator_stg_(handler_creator_stg), sp_filter_stg_(filter_stg), flag_(flag) { }
// When data is available for reading, accept the connection // and spawn a new handler. bool Acceptor::on_read(Reactor& r) { // FIXME: The error handling stuff is not good. Connection* c; try { c = new Connection(rc().accept()); } catch(System_error&) { perror("error"); r.stop(); return false; } catch(std::runtime_error& err) { std::cout << err.what() << '\n'; r.stop(); return false; } // Register the connection. r.add_handler(c); return true; }
int main(void) { pipe(pipe_); Pipe pipeio(pipe_[0]); InnerChange inner; EventHandler* eventHandler = new PipeHandler(pipeio, inner); Reactor * reactor = new Reactor(REACTORSIZE); //ReactorMask mask = EventHandler::READ_MASK | EventHandler::WRITE_MASK ; ReactorMask mask = EventHandler::READ_MASK; reactor->Register(eventHandler, mask); boost::thread *readt = new boost::thread(boost::bind(&printout)); boost::thread *writet = new boost::thread(boost::bind(&Reactor::Run, reactor)); readt->join(); writet->join(); return 1; }
void enableWrite(evutil_socket_t sock, short flags, void * args) { Reactor* reactor = (Reactor*)args; std::string addr = reactor->findaddrbysock(sock); //向对应的socket发送 连接成功可以发送信号 //对应的channel处在未连接状态,所以这个异步事件为判断connect成功 //此处应删除可写事件,防止再次触发 Channel_var mychannel = reactor->mChannelTable->getChannel(addr); if(!mychannel->IsRunOutOfTime(3)) { //成功连接上 mychannel->setTimestamp(); mychannel->setState(CHANNEL_CONNECTED); reactor->addReadable(mychannel->getSocket()); std::cout << "catch writable" << std::endl; reactor->notifyChannel(sock); } else { //等待超时 mychannel->setState(CHANNEL_ERROR); std::cout << "run out of time" << std::endl; reactor->notifyChannel(sock); } }
Future<unit> write_all(Reactor& reactor, StreamPtr out, Buffer data) { std::shared_ptr<Buffer> datap = std::make_shared<Buffer>(data); Completer<unit> completer; auto write_ready = [completer, datap, out]() { if(datap->size == 0) return; size_t len = out->write(*datap); *datap = datap->slice(len); if(datap->size == 0) completer.result(unit()); }; out->set_on_write_ready(write_ready); reactor.schedule(write_ready); return completer.future(); }
void run(string listen_host, int listen_port, std::vector<string> child_options, TlsStream::ServerPskFunc identity_callback) { this->child_options = child_options; TCP::listen(reactor, listen_host, listen_port, [&](FDPtr fd) { LOG("incoming connection"); auto stream = TlsStream::create(reactor, fd); stream->set_cipher_list("PSK-AES256-CBC-SHA"); stream->set_psk_server_callback(identity_callback); stream->handshake_as_server(); ioutil::read(stream, 128).then([this, stream](ByteString welcome) -> unit { // TODO: check identity string multilink_id = welcome.as_buffer().slice(0, 16); string link_name = welcome.as_buffer().slice(16); while (link_name.back() == 0) link_name.pop_back(); get_or_create(multilink_id).add_link(stream, link_name); return {}; }).ignore(); }).ignore(); reactor.run(); }
// Miscellaneous int LuaExports::dropItemReactor(lua_State *luaVm) { int32_t itemid = lua_tointeger(luaVm, 1); int16_t amount = 1; if (lua_isnumber(luaVm, 2)) { amount = lua_tointeger(luaVm, 2); } Reactor *reactor = getReactor(luaVm); Player *player = getPlayer(luaVm); Drop *drop; if (GameLogicUtilities::isEquip(itemid)) { Item f(itemid, true); drop = new Drop(reactor->getMapId(), f, reactor->getPos(), player != nullptr ? player->getId() : 0); } else { Item f(itemid, amount); drop = new Drop(reactor->getMapId(), f, reactor->getPos(), player != nullptr ? player->getId() : 0); } drop->setTime(player != nullptr ? 100 : 0); // FFA if player isn't around drop->doDrop(reactor->getPos()); return 0; }
int lws_client_callback(struct libwebsocket_context* context, struct libwebsocket *ws, enum libwebsocket_callback_reasons reason, void *user, void *data, size_t len){ const struct libwebsocket_protocols* lws_protocol = (ws == NULL ? NULL : libwebsockets_get_protocol(ws)); int idx = lws_protocol? lws_protocol->protocol_index : 0; Connection* conn; Reactor* reactor = NULL; Protocol* protocol; for (int i=0; i<(int)reactors.size(); i++){ if (reactors[i]->getContext() == context){ reactor = reactors[i]; protocol = reactor->protocol(idx); conn = ((Client*) reactor)->getConnection(); if (conn){ conn->context = context; } break; } else { } } ofLog( OF_LOG_VERBOSE, "[ofxLibwebsockets] " + getCallbackReason(reason) ); if (reason == LWS_CALLBACK_CLIENT_ESTABLISHED ){ libwebsocket_callback_on_writable(context, ws); } else if (reason == LWS_CALLBACK_CLOSED){ } switch (reason) { // cases we may use in the future case LWS_CALLBACK_CONFIRM_EXTENSION_OKAY: case LWS_CALLBACK_CLIENT_CONFIRM_EXTENSION_SUPPORTED: case LWS_CALLBACK_PROTOCOL_INIT: // this may be useful, says we're OK to allocate protocol data case LWS_CALLBACK_WSI_CREATE: case LWS_CALLBACK_HTTP_BODY_COMPLETION: case LWS_CALLBACK_HTTP_FILE_COMPLETION: case LWS_CALLBACK_HTTP_WRITEABLE: case LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION: return 0; // check if we allow this connection (default is always yes) case LWS_CALLBACK_FILTER_HTTP_CONNECTION: case LWS_CALLBACK_FILTER_NETWORK_CONNECTION: if (protocol != NULL){ return reactor->_allow(ws, protocol, (int)(long)user)? 0 : 1; } else { return 0; } // need to serve up an HTTP file case LWS_CALLBACK_HTTP: if ( reactor != NULL){ return reactor->_http(ws, (char*)data); } else { return 0; } // we're not really worried about these at the moment case LWS_CALLBACK_CLOSED_HTTP: case LWS_CALLBACK_ADD_POLL_FD: case LWS_CALLBACK_DEL_POLL_FD: case LWS_CALLBACK_CHANGE_MODE_POLL_FD: case LWS_CALLBACK_LOCK_POLL: case LWS_CALLBACK_UNLOCK_POLL: case LWS_CALLBACK_GET_THREAD_ID: case LWS_CALLBACK_CLIENT_FILTER_PRE_ESTABLISH: case LWS_CALLBACK_CLIENT_APPEND_HANDSHAKE_HEADER: return 1; // catch-all for most important events: // LWS_CALLBACK_CLIENT_CONNECTION_ERROR // LWS_CALLBACK_CLIENT_ESTABLISHED // LWS_CALLBACK_RECEIVE // LWS_CALLBACK_CLIENT_RECEIVE // LWS_CALLBACK_CLIENT_RECEIVE_PONG // LWS_CALLBACK_CLIENT_WRITEABLE default: if ( reactor != NULL ){ //conn = *(Connection**)user; if (conn && conn->ws != ws && ws != NULL){ conn->ws = ws; conn->context = context; } return reactor->_notify(conn, reason, (char*)data, len); } else { return 0; } } return 1; // FAIL (e.g. unhandled case/break in switch) }
// Mob int LuaExports::spawnMobReactor(lua_State *luaVm) { int32_t mobid = lua_tointeger(luaVm, -1); Reactor *reactor = getReactor(luaVm); lua_pushinteger(luaVm, Maps::getMap(reactor->getMapId())->spawnMob(mobid, reactor->getPos())); return 1; }
void runexample() { // use reaction mechanism GRI-Mech 3.0 IdealGasMix gas("gri30.cti", "gri30"); // create a reservoir for the fuel inlet, and set to pure methane. Reservoir fuel_in; gas.setState_TPX(300.0, OneAtm, "CH4:1.0"); fuel_in.insert(gas); double fuel_mw = gas.meanMolecularWeight(); // create a reservoir for the air inlet Reservoir air_in; IdealGasMix air("air.cti"); gas.setState_TPX(300.0, OneAtm, "N2:0.78, O2:0.21, AR:0.01"); double air_mw = air.meanMolecularWeight(); air_in.insert(gas); // to ignite the fuel/air mixture, we'll introduce a pulse of radicals. // The steady-state behavior is independent of how we do this, so we'll // just use a stream of pure atomic hydrogen. gas.setState_TPX(300.0, OneAtm, "H:1.0"); Reservoir igniter; igniter.insert(gas); // create the combustor, and fill it in initially with N2 gas.setState_TPX(300.0, OneAtm, "N2:1.0"); Reactor combustor; combustor.insert(gas); combustor.setInitialVolume(1.0); // create a reservoir for the exhaust. The initial composition // doesn't matter. Reservoir exhaust; exhaust.insert(gas); // lean combustion, phi = 0.5 double equiv_ratio = 0.5; // compute fuel and air mass flow rates double factor = 0.1; double air_mdot = factor*9.52*air_mw; double fuel_mdot = factor*equiv_ratio*fuel_mw; // create and install the mass flow controllers. Controllers // m1 and m2 provide constant mass flow rates, and m3 provides // a short Gaussian pulse only to ignite the mixture MassFlowController m1; m1.install(fuel_in, combustor); m1.setMassFlowRate(fuel_mdot); // Now create the air mass flow controller. Note that this connects // two reactors with different reaction mechanisms and different // numbers of species. Downstream and upstream species are matched by // name. MassFlowController m2; m2.install(air_in, combustor); m2.setMassFlowRate(air_mdot); // The igniter will use a Gaussian 'functor' object to specify the // time-dependent igniter mass flow rate. double A = 0.1; double FWHM = 0.2; double t0 = 0.5; Gaussian igniter_mdot(A, t0, FWHM); MassFlowController m3; m3.install(igniter, combustor); m3.setFunction(&igniter_mdot); // put a valve on the exhaust line to regulate the pressure Valve v; v.install(combustor, exhaust); double Kv = 1.0; v.setParameters(1, &Kv); // the simulation only contains one reactor ReactorNet sim; sim.addReactor(combustor); // take single steps to 6 s, writing the results to a CSV file // for later plotting. double tfinal = 1.0; double tnow = 0.0; double tres; std::ofstream f("combustor_cxx.csv"); std::vector<size_t> k_out { gas.speciesIndex("CH4"), gas.speciesIndex("O2"), gas.speciesIndex("CO2"), gas.speciesIndex("H2O"), gas.speciesIndex("CO"), gas.speciesIndex("OH"), gas.speciesIndex("H"), gas.speciesIndex("C2H6") }; while (tnow < tfinal) { tnow += 0.005; sim.advance(tnow); tres = combustor.mass()/v.massFlowRate(); f << tnow << ", " << combustor.temperature() << ", " << tres << ", "; ThermoPhase& c = combustor.contents(); for (size_t i = 0; i < k_out.size(); i++) { f << c.moleFraction(k_out[i]) << ", "; } f << std::endl; } f.close(); }
void ReactorNet::initialize() { size_t n, nv; char buf[100]; m_nv = 0; m_reactors.clear(); m_nreactors = 0; writelog("Initializing reactor network.\n", m_verbose); if (m_nr == 0) throw CanteraError("ReactorNet::initialize", "no reactors in network!"); size_t sensParamNumber = 0; for (n = 0; n < m_nr; n++) { if (m_r[n]->type() >= ReactorType) { m_r[n]->initialize(m_time); Reactor* r = (Reactor*)m_r[n]; m_reactors.push_back(r); nv = r->neq(); m_size.push_back(nv); m_nparams.push_back(r->nSensParams()); std::vector<std::pair<void*, int> > sens_objs = r->getSensitivityOrder(); for (size_t i = 0; i < sens_objs.size(); i++) { std::map<size_t, size_t>& s = m_sensOrder[sens_objs[i]]; for (std::map<size_t, size_t>::iterator iter = s.begin(); iter != s.end(); ++iter) { m_sensIndex.resize(std::max(iter->second + 1, m_sensIndex.size())); m_sensIndex[iter->second] = sensParamNumber++; } } m_nv += nv; m_nreactors++; if (m_verbose) { sprintf(buf,"Reactor %s: %s variables.\n", int2str(n).c_str(), int2str(nv).c_str()); writelog(buf); sprintf(buf," %s sensitivity params.\n", int2str(r->nSensParams()).c_str()); writelog(buf); } if (m_r[n]->type() == FlowReactorType && m_nr > 1) { throw CanteraError("ReactorNet::initialize", "FlowReactors must be used alone."); } } } m_connect.resize(m_nr*m_nr,0); m_ydot.resize(m_nv,0.0); size_t i, j, nin, nout, nw; ReactorBase* r, *rj; for (i = 0; i < m_nr; i++) { r = m_reactors[i]; for (j = 0; j < m_nr; j++) { if (i == j) { connect(i,j); } else { rj = m_reactors[j]; nin = rj->nInlets(); for (n = 0; n < nin; n++) { if (&rj->inlet(n).out() == r) { connect(i,j); } } nout = rj->nOutlets(); for (n = 0; n < nout; n++) { if (&rj->outlet(n).in() == r) { connect(i,j); } } nw = rj->nWalls(); for (n = 0; n < nw; n++) { if (&rj->wall(n).left() == rj && &rj->wall(n).right() == r) { connect(i,j); } else if (&rj->wall(n).left() == r && &rj->wall(n).right() == rj) { connect(i,j); } } } } } m_atol.resize(neq()); fill(m_atol.begin(), m_atol.end(), m_atols); m_integ->setTolerances(m_rtol, neq(), DATA_PTR(m_atol)); m_integ->setSensitivityTolerances(m_rtolsens, m_atolsens); m_integ->setMaxStepSize(m_maxstep); m_integ->setMaxErrTestFails(m_maxErrTestFails); if (m_verbose) { sprintf(buf, "Number of equations: %s\n", int2str(neq()).c_str()); writelog(buf); sprintf(buf, "Maximum time step: %14.6g\n", m_maxstep); writelog(buf); } m_integ->initialize(m_time, *this); m_init = true; }
void ReactorNet::addReactor(Reactor& r) { r.setNetwork(this); m_reactors.push_back(&r); }
int kinetics_example2(int job) { try { std::cout << "Ignition simulation using class GRI30." << std::endl; if (job >= 1) { std::cout << "Constant-pressure ignition of a hydrogen/oxygen/nitrogen" " mixture \nbeginning at T = 1001 K and P = 1 atm." << std::endl; } if (job < 2) return 0; // create a GRI30 object GRI30 gas; gas.setState_TPX(1001.0, OneAtm, "H2:2.0, O2:1.0, N2:4.0"); int kk = gas.nSpecies(); // create a reactor Reactor r; // create a reservoir to represent the environment Reservoir env; // specify the thermodynamic property and kinetics managers r.setThermoMgr(gas); r.setKineticsMgr(gas); env.setThermoMgr(gas); // create a flexible, insulating wall between the reactor and the // environment Wall w; w.install(r,env); // set the "Vdot coefficient" to a large value, in order to // approach the constant-pressure limit; see the documentation // for class Reactor w.setExpansionRateCoeff(1.e9); w.setArea(1.0); // create a container object to run the simulation // and add the reactor to it ReactorNet* sim_ptr = new ReactorNet(); ReactorNet& sim = *sim_ptr; sim.addReactor(&r); double tm; double dt = 1.e-5; // interval at which output is written int nsteps = 100; // number of intervals // create a 2D array to hold the output variables, // and store the values for the initial state Array2D soln(kk+4, 1); saveSoln(0, 0.0, gas, soln); // main loop for (int i = 1; i <= nsteps; i++) { tm = i*dt; sim.advance(tm); saveSoln(tm, gas, soln); } // make a Tecplot data file and an Excel spreadsheet std::string plotTitle = "kinetics example 2: constant-pressure ignition"; plotSoln("kin2.dat", "TEC", plotTitle, gas, soln); plotSoln("kin2.csv", "XL", plotTitle, gas, soln); // print final temperature std::cout << " Tfinal = " << r.temperature() << std::endl; std::cout << "Output files:" << std::endl << " kin2.csv (Excel CSV file)" << std::endl << " kin2.dat (Tecplot data file)" << std::endl; return 0; } // handle exceptions thrown by Cantera catch (CanteraError) { showErrors(std::cout); std::cout << " terminating... " << std::endl; appdelete(); return -1; } }
int rxnpath_example1(int job) { try { cout << "Reaction path diagram movies with file gri30.cti." << endl; if (job >= 1) { cout << "Generate reaction path diagrams following nitrogen\n" << "as a function of time for constant-pressure ignition of a\n" << "hydrogen/oxygen/nitrogen" " mixture \nbeginning at T = 1001 K and P = 1 atm." << endl; } if (job < 2) { return 0; } // create an ideal gas mixture that corresponds to GRI-Mech // 3.0 IdealGasMix gas("gri30.cti", "gri30"); gas.setState_TPX(1001.0, OneAtm, "H2:2.0, O2:1.0, N2:4.0"); // create a reactor Reactor r; // create a reservoir to represent the environment Reservoir env; // specify the thermodynamic property and kinetics managers r.setThermoMgr(gas); r.setKineticsMgr(gas); env.setThermoMgr(gas); // create a flexible, insulating wall between the reactor and the // environment Wall w; w.install(r,env); // set the "Vdot coefficient" to a large value, in order to // approach the constant-pressure limit; see the documentation // for class Reactor w.setExpansionRateCoeff(1.e9); w.setArea(1.0); double tm; double dt = 1.e-5; // interval at which output is written int nsteps = 100; // number of intervals // create a container object to run the simulation // and add the reactor to it ReactorNet& sim = *(new ReactorNet()); sim.addReactor(&r); // create a reaction path diagram builder ReactionPathBuilder b; std::ofstream rplog("rp1.log"); // log file std::ofstream rplot("rp1.dot"); // output file b.init(rplog, gas); // initialize // main loop for (int i = 1; i <= nsteps; i++) { tm = i*dt; sim.advance(tm); writeRxnPathDiagram(tm, b, gas, rplog, rplot); } // print final temperature cout << "Output files:" << endl << " rp1.log (log file)" << endl << " rp1.dot (input file for dot)" << endl; cout << "To generate the diagrams in Postscript, execute the command" << endl << endl << "dot -Tps rp1.dot > rp1.ps" << endl << endl << "Get dot for Windows here: http://blue.caltech.edu/dot.exe" << endl; } catch (CanteraError& err) { // handle exceptions thrown by Cantera std::cout << err.what() << std::endl; cout << " terminating... " << endl; appdelete(); return -1; } return 0; }
void ReactorNet::initialize(doublereal t0) { int n, nv; char buf[100]; m_nv = 0; m_reactors.clear(); m_nreactors = 0; if (m_verbose) { writelog("Initializing reactor network.\n"); } if (m_nr == 0) throw CanteraError("ReactorNet::initialize", "no reactors in network!"); for (n = 0; n < m_nr; n++) { if (m_r[n]->type() >= ReactorType) { m_r[n]->initialize(t0); Reactor* r = (Reactor*)m_r[n]; m_reactors.push_back(r); nv = r->neq(); m_size.push_back(nv); m_nparams.push_back(r->nSensParams()); m_ntotpar += r->nSensParams(); m_nv += nv; m_nreactors++; if (m_verbose) { sprintf(buf,"Reactor %d: %d variables.\n",n,nv); writelog(buf); sprintf(buf," %d sensitivity params.\n", r->nSensParams()); writelog(buf); } if (m_r[n]->type() == FlowReactorType && m_nr > 1) { throw CanteraError("ReactorNet::initialize", "FlowReactors must be used alone."); } } } m_connect.resize(m_nr*m_nr,0); m_ydot.resize(m_nv,0.0); int i, j, nin, nout, nw; ReactorBase *r, *rj; for (i = 0; i < m_nr; i++) { r = m_reactors[i]; for (j = 0; j < m_nr; j++) { if (i == j) connect(i,j); else { rj = m_reactors[j]; nin = rj->nInlets(); for (n = 0; n < nin; n++) { if (&rj->inlet(n).out() == r) connect(i,j); } nout = rj->nOutlets(); for (n = 0; n < nout; n++) { if (&rj->outlet(n).in() == r) connect(i,j); } nw = rj->nWalls(); for (n = 0; n < nw; n++) { if (&rj->wall(n).left() == rj && &rj->wall(n).right() == r) connect(i,j); else if (&rj->wall(n).left() == r && &rj->wall(n).right() == rj) connect(i,j); } } } } m_atol.resize(neq()); fill(m_atol.begin(), m_atol.end(), m_atols); m_integ->setTolerances(m_rtol, neq(), DATA_PTR(m_atol)); m_integ->setSensitivityTolerances(m_rtolsens, m_atolsens); m_integ->setMaxStepSize(m_maxstep); if (m_verbose) { sprintf(buf, "Number of equations: %d\n", neq()); writelog(buf); sprintf(buf, "Maximum time step: %14.6g\n", m_maxstep); writelog(buf); } m_integ->initialize(t0, *this); m_init = true; }
Acceptor::Acceptor(Reactor& reactor, int flag) : sp_reactor_impl_(reactor.impl()), flag_(flag) { }
ServerSocketHandler(unique_ptr<ServerSocket<T>> sock) { sock_fd = std::move(sock); Reactor *rec = Reactor::getInstance(); rec->registerHandler(EV_IN, (sock_fd.get())->getSockfd(), this); }