Reaction Design提供一系列CHEMKIN产品，以满足不同层次的要求。 CHEMKIN-PRO是专为需要求解复杂反应机理的化学动力学模拟设计。先进的求解器和完整的功能允针对特定的应用开发快速和准确模型。Reaction Workbench是CHEMKIN-PRO模块的扩展，可以为燃烧设计工程师和科学家提供燃料配比和自动化反应机理简化能力。
快速、准确的化学分析
综合了先进的功能和最新的分析算法，CHEMKIN-PRO提供了极致的速度，精度和求解鲁棒性。
及时快速地获得高精度结果
对于包含大量反应机理的复杂模型，核心求解器的改进使CHEMKIN-PRO的模拟时间，从几天缩短到几小时，从几小时缩减到几分钟。CHEMKIN-PRO相比比以前版本的CHEMKIN快了超过100倍。
全新的界面
为了帮助您获得关键动力学的关联关系，CHEMKIN-PRO提供了反应路径分析。反应途径分析工具采用交互式、可视化的显示界面，清晰显示主导反应的路径，从而为机理的开发和机理简化提供了手段。
反应路径分析工具显示反应机理
用反应器网络来模拟复杂的流场
使用详细的化学动力学模型有效预测了污染排放问题，等效反应网络可用于模拟现实世界中的燃烧器，燃烧炉和化学反应器等复杂系统。
更好地理解低排放燃烧稳定性
CHEMKIN-PRO 燃烧熄灭模型可快速、精确地计算熄灭应变速率来确定系统的燃烧稳定性，这在预混合的低NOx燃烧系统的非常重要的。
理解并预测粒子形成
CHEMKIN-PRO 的创新性粒子跟踪功能可计算颗粒成立以来，成长，聚集和氧化。两个不同的跟踪方法能够计算平均粒径和粒数密度，以及对粒径分布的详细信息，可以用于预测烟尘排放或优化颗粒的生产。
快速和准确地为CFD创建火焰查询表
许多燃烧系统开发人员在他们的CFD模拟中使用火焰查询表来计算燃烧问题。CHEMKIN-PRO提供一个稳健而快速的方法为CFD创建这些火焰查询表。
探索输入的不确定性对模拟结果的影响
通过增加用户自定义输入精度范围，提高模拟结果的鲁棒性。
使用多区域模型来分析活塞式发动机
CHEMKIN-PRO 的多区域模型简化和优化了均质压燃式发动机中的关键燃烧效果，包括点火，氮氧化物，一氧化碳，碳氢化合物和分析烟尘排放量。

Reaction
Design提供一系列CHEMKIN产品，以满足不同层次的要求。 CHEMKIN-PRO是专为需要求解复杂反应机理的化学动力学模拟设计。先进的求解器和完整的功能允针对特定的应用开发快速和准确模型。Reaction Workbench是CHEMKIN-PRO模块的扩展，可以为燃烧设计工程师和科学家提供燃料配比和自动化反应机理简化能力。
快速、准确的化学分析
综合了先进的功能和分析算法，CHEMKIN-PRO提供了极致的速度，精度和求解鲁棒性。
及时快速地获得高精度结果
对于包含大量反应机理的复杂模型，核心求解器的改进使CHEMKIN-PRO的模拟时间，从几天缩短到几小时，从几小时缩减到几分钟。CHEMKIN-PRO相比比以前版本的CHEMKIN快了超过100倍。
全新的界面
为了帮助您获得关键动力学的关联关系，CHEMKIN-PRO提供了反应路径分析。反应途径分析工具采用交互式、可视化的显示界面，清晰显示主导反应的路径，从而为机理的开发和机理简化提供了手段。
反应路径分析工具显示反应机理
用反应器网络来模拟复杂的流场
使用详细的化学动力学模型有效预测了污染排放问题，等效反应网络可用于模拟现实世界中的燃烧器，燃烧炉和化学反应器等复杂系统。
更好地理解低排放燃烧稳定性
CHEMKIN-PRO
燃烧熄灭模型可快速、精确地计算熄灭应变速率来确定系统的燃烧稳定性，这在预混合的低NOx燃烧系统的非常重要的。
理解并预测粒子形成
CHEMKIN-PRO
的创新性粒子跟踪功能可计算颗粒成立以来，成长，聚集和氧化。两个不同的跟踪方法能够计算平均粒径和粒数密度，以及对粒径分布的详细信息，可以用于预测烟尘排放或优化颗粒的生产。
快速和准确地为CFD创建火焰查询表
许多燃烧系统开发人员在他们的CFD模拟中使用火焰查询表来计算燃烧问题。CHEMKIN-PRO提供一个稳健而快速的方法为CFD创建这些火焰查询表。
探索输入的不确定性对模拟结果的影响
通过增加用户自定义输入精度范围，提高模拟结果的鲁棒性。
使用多区域模型来分析活塞式发动机
CHEMKIN-PRO
的多区域模型简化和优化了均质压燃式发动机中的关键燃烧效果，包括点火，氮氧化物，一氧化碳，碳氢化合物和分析烟尘排放量。

                    

最近，由IBM公司科学家们开发的一种新型算法正在改进复杂化学反应的理解方式，同时还针对量子计算进行了相关优化。
目前，科学家们已研发出了一种全新的方法以完成分子模拟，该方法通过使用配备有7量子位处理器的量子计算机以模拟分子，旨在解决铍氢化物（BeH2）的分子结构问题。IBM方面表示，铍氢化物是迄今为止在量子计算机上能够模拟的最大分子。因其可直接应用于实际，故而该项研发结果的现实意义尤为重大，具体包括创造新材料、研究靶向药物以及发现更高效且可持续性能源。
在接受电话采访时，IBM公司量子计算机研究团队成员Abhinav Kandala对该团队如何实现能够满足分子模拟所需的量子运算数量的高效算法做出了概述。通过使用7量子位处理器中的6个量子位，他们即可测量出BeH2的最低能量级，而这正是理解化学反应的关键量化指标所在。此次实验的结果已发布于经同行评审的《自然》杂志，Kandala也参与了该篇论文的撰写。
该研究团队在此篇论文中率先使用逾百个Pauli（泡利）术语以论证实验优化中所涉及的多达6个量子位的汉密尔顿函数问题，而后展示了一系列分子基态能量的测定值。其中，分子体积大小为控制变量，在测定过程中逐步增加直至构成BeH2。该项测验由“一款能够在试验状态下于量子处理器中完成交互并结合了费米子汉密尔顿函数紧凑编码与随机优化程序的硬件高效量子优化器”完成。

IBM公司研究人员已经研发出了一种新型方法，能够在量子计算机上模拟分子，并在其定制的7量子位处理器上成功地使用其中6个量子位，借此以解决铍氢化物（BeH2）的分子结构问题。铍氢化物（BeH2）是迄今为止能够在量子计算机上模拟的最大分子。
尽管BeH2模型也能够在“经典”计算机上实现模拟，但由于这种新方法具备研究更大分子的潜力，并且随着更为强大的量子系统的建立，该全新的计算方法将自然而言地被视为超越传统计算方法的产物。Kandala表示，该实验最终表明执行于6位超导量子处理器上的硬件高效量子优化器可以解决单一元素以上的分子问题，并且具体范围可扩展至BeH2上限。
Kandala补充称，基本上他们已经颠覆了传统研究方式，即将之前已知的传统计算方法同量子硬件加 结合：该研究团队通过构建适合于当前可用量子设备性能的算法实现了这项重大目标。该算法允许其提取最大的量子计算能力以解决问题，而这对传统计算机而言，完成难度将呈指数级增长。为表达该算法的计算能力，IBM公司采用了全新的度量标准Quantum Volume，该标准具体包括量子位的数量与质量、电路连接以及运算错误率。
使用传统计算方法处理化学问题可能出现的问题，或将通过量子计算能够得以解决。 “迄今为止所有的化学反应都能够用相似的方法得以解决，” Kandala 表示，“而在传统计算机上处理此类问题将导致成本呈指数级增长。”
分子问题的复杂性与其轨道数量密切相关。分子轨道是描述分子中电子波状行为的数学函数。Kandala 表示：“希望量子计算能够以精确的方式处理此类问题。”

如果量子计算机能够用于解决实际问题，那么其将需要搜索一个很大的量子态空间。故而在其衡量标准中，错误率与量子位数量一样重要。
以最简单的分子模型氢为例，科学家需要将四个轨道映射于两个量子位上。 “当试图解决更大的分子时，将有更多的轨道需要计算。因此，量子位随着分子轨道数量的增加而增加。” Kandala表示，“而这些问题可以得到解决。我们能够在量子计算机上尝试解决此类问题的原因正是由于数学映射的存在。” Kandala补充称：“分子轨道的数量与模拟中需要的量子位数量有关。”
Kandala表示，该实验的重点之一在于将量子计算结果与传统计算方法所得进行比较，并确定其实际错误率。 “此举旨在期望能够获得更多经典计算范围以外的信息，” Kandala解释称，“毕竟，这是个全新的领域。”
为展示量子计算机在模拟分子方面的实际表现，开发者与IBM Q体验用户现可访问量子化学Jupyter Notebook，通过QISKit GitHub库提供的开放源代码。IBM Q体验于去年推出，该活动通过在云端部署一台强大的5量子位计算机，且任何人都能自由访问该量子计算机。最近，该量子计算机已完成升级，开始以beta测试方式开放16量子位处理器。
“我们希望创建一个社区，” Kandala表示，“我们希望了解自己，同时也希望其他人能够了解我们。”









原文发布时间为：2017年9月15日 
本文作者：作者：李超
本文来自云栖社区合作伙伴至顶网，了解相关信息可以关注至顶网。

        
        
                
    

完整代码在我个人github上欢迎fork  https://github.com/hankai17/test/tree/master/linux_pro/day11
#include <stdlib.h>
#include <stdio.h> 
#include <stdio.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#define MAX_EVENTS  1024
#define BUFLEN 128
#define SERV_PORT   8080


/*
 * status:1表示在监听事件中，0表示不在 
 * last_active:记录最后一次响应时间,做超时处理
 */
struct myevent_s {
    int fd;                 //cfd listenfd
    int events;             //EPOLLIN  EPLLOUT
    void *arg;              //指向自己结构体指针
    void (*call_back)(int fd, int events, void *arg);
    int status;
    char buf[BUFLEN];
    int len;
    long last_active;
};

int g_efd;          /* epoll_create返回的句柄 */
struct myevent_s g_events[MAX_EVENTS+1];   /* +1 最后一个用于 listen fd */

//初始化一个事件
void eventset(struct myevent_s *ev, int fd, void (*call_back)(int, int, void *), void *arg)
{
    ev->fd = fd;
    ev->call_back = call_back;
    ev->events = 0;
    ev->arg = arg;
    ev->status = 0;
    //memset(ev->buf, 0, sizeof(ev->buf));
    //ev->len = 0;
    ev->last_active = time(NULL);

    return;
}

void recvdata(int fd, int events, void *arg);
void senddata(int fd, int events, void *arg);

void eventadd(int efd, int events, struct myevent_s *ev)
{
    struct epoll_event epv = {0, {0}};
    int op;
    epv.data.ptr = ev;
    epv.events = ev->events = events;

    if (ev->status == 1) {
        op = EPOLL_CTL_MOD;
    } 
    else {
        op = EPOLL_CTL_ADD;
        ev->status = 1;
    }

    if (epoll_ctl(efd, op, ev->fd, &epv) < 0)
        printf("event add failed [fd=%d], events[%d]\n", ev->fd, events);
    else
        printf("event add OK [fd=%d], op=%d, events[%0X]\n", ev->fd, op, events);

    return;
}

void eventdel(int efd, struct myevent_s *ev)
{
    struct epoll_event epv = {0, {0}};

    if (ev->status != 1)
        return;

    epv.data.ptr = ev;
    ev->status = 0;
    epoll_ctl(efd, EPOLL_CTL_DEL, ev->fd, &epv);

    return;
}


void acceptconn(int lfd, int events, void *arg)
{
    struct sockaddr_in cin;
    socklen_t len = sizeof(cin);
    int cfd, i;

    if ((cfd = accept(lfd, (struct sockaddr *)&cin, &len)) == -1) {
        if (errno != EAGAIN && errno != EINTR) {
            /* 暂时不做出错处理 */
        }
        printf("%s: accept, %s\n", __func__, strerror(errno));
        return;
    }

    do {
        for (i = 0; i < MAX_EVENTS; i++) {
            if (g_events[i].status == 0)
                break;
        }

        if (i == MAX_EVENTS) {
            printf("%s: max connect limit[%d]\n", __func__, MAX_EVENTS);
            break;
        }

        int flag = 0;
        if ((flag = fcntl(cfd, F_SETFL, O_NONBLOCK)) < 0)
        {
            printf("%s: fcntl nonblocking failed, %s\n", __func__, strerror(errno));
            break;
        }

        //accept成功
        eventset(&g_events[i], cfd, recvdata, &g_events[i]);
        eventadd(g_efd, EPOLLIN, &g_events[i]);
    } while(0);

    printf("new connect [%s:%d][time:%ld], pos[%d]\n", inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), g_events[i].last_active, i);

    return;
}

void recvdata(int fd, int events, void *arg)
{
    struct myevent_s *ev = (struct myevent_s *)arg;
    int len;

    len = recv(fd, ev->buf, sizeof(ev->buf), 0);
    eventdel(g_efd, ev);

    if (len > 0) {
        ev->len = len;
        ev->buf[len] = '\0';
        printf("C[%d]:%s\n", fd, ev->buf);
        /* 转换为发送事件 */
        eventset(ev, fd, senddata, ev);
        eventadd(g_efd, EPOLLOUT, ev);
    }
    else if (len == 0) {
        close(ev->fd);
        /* ev-g_events 地址相减得到偏移元素位置 */
        printf("[fd=%d] pos[%d], closed\n", fd, (int)(ev - g_events));
    }
    else {
        close(ev->fd);
        printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
    }

    return;
}

void senddata(int fd, int events, void *arg)
{
    struct myevent_s *ev = (struct myevent_s *)arg;
    int len;

    len = send(fd, ev->buf, ev->len, 0);
    //printf("fd=%d\tev->buf=%s\ttev->len=%d\n", fd, ev->buf, ev->len);
    //printf("send len = %d\n", len);

    eventdel(g_efd, ev);
    if (len > 0) {
        printf("send[fd=%d], [%d]%s\n", fd, len, ev->buf);
        eventset(ev, fd, recvdata, ev);
        eventadd(g_efd, EPOLLIN, ev);
    }
    else {
        close(ev->fd);
        printf("send[fd=%d] error %s\n", fd, strerror(errno));
    }

    return;
}

void initlistensocket(int efd, short port)
{
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    fcntl(lfd, F_SETFL, O_NONBLOCK);

    //将lfd绑定  初始化一个事件
    eventset(&g_events[MAX_EVENTS], lfd, acceptconn, &g_events[MAX_EVENTS]); //第一个参数是传入传出参数:即把后三个参数都传递给了第一参数结构体
    //g_events[MAX_EVENTS];

    //将已经封装好的事件 添加到 肯节点中 让epoll-wait去监听该事件
    eventadd(efd, EPOLLIN, &g_events[MAX_EVENTS]);

    struct sockaddr_in sin;

    memset(&sin, 0, sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = INADDR_ANY;
    sin.sin_port = htons(port);

    bind(lfd, (struct sockaddr *)&sin, sizeof(sin));

    listen(lfd, 20);

    return;
}

int main(int argc, char *argv[])
{
    unsigned short port = SERV_PORT;

    if (argc == 2)
        port = atoi(argv[1]);

    g_efd = epoll_create(MAX_EVENTS+1);

    if (g_efd <= 0)
        printf("create efd in %s err %s\n", __func__, strerror(errno));

    //创建一个listenfd 绑定一个事件，读事件，添加到epoll_wait中，  bind listen  端口
    initlistensocket(g_efd, port);

    /* 事件循环 */
    struct epoll_event events[MAX_EVENTS+1];

    printf("server running:port[%d]\n", port);
    int checkpos = 0, i;
    while (1) {
        /* 超时验证，每次测试100个链接，不测试listenfd 当客户端60秒内没有和服务器通信，则关闭此客户端链接 */
        long now = time(NULL);
        for (i = 0; i < 100; i++, checkpos++) {
            if (checkpos == MAX_EVENTS)
                checkpos = 0;
            if (g_events[checkpos].status != 1)
                continue;
            long duration = now - g_events[checkpos].last_active;
            if (duration >= 60) {
                close(g_events[checkpos].fd);
                printf("[fd=%d] timeout\n", g_events[checkpos].fd);
                eventdel(g_efd, &g_events[checkpos]);
            }
        }
        /* 等待事件发生 */
        int nfd = epoll_wait(g_efd, events, MAX_EVENTS+1, 1000);
        if (nfd < 0) {
            printf("epoll_wait error, exit\n");
            break;
        }
        for (i = 0; i < nfd; i++) {
            struct myevent_s *ev = (struct myevent_s *)events[i].data.ptr;
            if ((events[i].events & EPOLLIN) && (ev->events & EPOLLIN)) {
                //多态特性
                ev->call_back(ev->fd, events[i].events, ev->arg);
            }
            if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)) {
                ev->call_back(ev->fd, events[i].events, ev->arg);
            }
        }
    }

    /* 退出前释放所有资源 */
    return 0;
}