tp下载手机版|fel

首页
fel

tp下载手机版|fel

作者： tp下载手机版

2024-03-17 06:36:13

Fel是轻量级的高效的表达式计算引擎学习（一） - 先锋之客 - 博客园

会员

周边

新闻

博问

AI培训

云市场

所有博客

当前博客

我的博客

我的园子

账号设置

简洁模式 ...

退出登录

先锋之客

博客园

首页

新随笔

联系

管理

Fel是轻量级的高效的表达式计算引擎学习（一）

Fel在源自于企业项目，设计目标是为了满足不断变化的功能需求和性能需求。

Fel是开放的，引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是Fel函数），所有这些函数都是可以替换的，扩展函数也非常简单。Fel有双引擎，同时支持解释执行和编译执行。可以根据性能要求选择执行方式。编译执行就是将表达式编译成字节码（生成java代码和编译模块都是可以扩展和替换的）

Fel有多快？通常情况下，Fel-0.7每秒可以执行千万次表达式（不包含编译时间）。速度是Jexl-2.0的20倍以上。

目前还没有发现开源的表达式引擎比Fel快。

具体的测试数据请参见http://code.google.com/p/fast-el/wiki/Performance。

为何要使用Fel?Fel语法和API非常简单，语法与Java基本相同，几乎没有学习成本。

Fel非常快，上面已经做了简单说明。

Fel整个包只有200多KB。

Fel可以非常方便的访问数组、集合、Map的元素和对象的属性。

Fel可以非常方便的调用对象的方法和类方法（如果这些还不够，可以添加自定义函数）。

Fel支持大数值高精度计算

Fel有良好的安全管理功能

如果Fel不能满足你的要求，扩展和修改Fel很简单。

Fel不能做什么？Fel只支持表达式，不支持脚本。

Fel适用场景：Fel适合处理海量数据，Fel良好的扩展性可以更好的帮助用户处理数据。

Fel同样适用于其他需要使用表达式引擎的地方（如果工作流、公式计算、数据有效性校验等等）

安装1：获取Fel项目主页：http://code.google.com/p/fast-el/ 下载地址：http://code.google.com/p/fast-el/downloads/list

Fel使用例子：1：算术表达式：

FelEngine fel = new FelEngineImpl();

Object result = fel.eval("5000*12+7500");

System.out.println(result);

输出结果：67500

2：变量

使用变量，其代码如下所示：

FelContext ctx = fel.getContext();

ctx.set("单价", 5000);

ctx.set("数量", 12);

ctx.set("运费", 7500);

Object result = fel.eval("单价*数量+运费");

System.out.println(result);

输出结果：67500

3：访问对象属性

在Fel中，可能非常方便的访问对象属性，示例代码如下所示

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

Foo foo = new Foo();

ctx.set("foo", foo);

Map m = new HashMap();

m.put("ElName", "fel");

ctx.set("m",m);

//调用foo.getSize()方法。

Object result = fel.eval("foo.size");

//调用foo.isSample()方法。

result = fel.eval("foo.sample");

//foo没有name、getName、isName方法

//foo.name会调用foo.get("name")方法。

result = fel.eval("foo.name");

//m.ElName会调用m.get("ElName");

result = fel.eval("m.ElName");

4:访问数组、集合、Map

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

//数组

int[] intArray = {1,2,3};

ctx.set("intArray",intArray);

//获取intArray[0]

String exp = "intArray[0]";

System.out.println(exp+"->"+fel.eval(exp));

//List

List list = Arrays.asList(1,2,3);

ctx.set("list",list);

//获取list.get(0)

exp = "list[0]";

System.out.println(exp+"->"+fel.eval(exp));

//集合

Collection coll = Arrays.asList("a","b","c");

ctx.set("coll",coll);

//获取集合最前面的元素。执行结果为"a"

exp = "coll[0]";

System.out.println(exp+"->"+fel.eval(exp));

//迭代器

Iterator iterator = coll.iterator();

ctx.set("iterator", iterator);

//获取迭代器最前面的元素。执行结果为"a"

exp = "iterator[0]";

System.out.println(exp+"->"+fel.eval(exp));

//Map

Map m = new HashMap();

m.put("name", "HashMap");

ctx.set("map",m);

exp = "map.name";

System.out.println(exp+"->"+fel.eval(exp));

//多维数组

int[][] intArrays= {{11,12},{21,22}};

ctx.set("intArrays",intArrays);

exp = "intArrays[0][0]";

System.out.println(exp+"->"+fel.eval(exp));

//多维综合体，支持数组、集合的任意组合。

List listArray = new ArrayList();

listArray.add(new int[]{1,2,3});

listArray.add(new int[]{4,5,6});

ctx.set("listArray",listArray);

exp = "listArray[0][0]";

System.out.println(exp+"->"+fel.eval(exp));

5:调用JAVA方法

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

ctx.set("out", System.out);

fel.eval("out.println('Hello Everybody'.substring(6))");

输出结果：Everybody

6:自定义上下文环境

//负责提供气象服务的上下文环境

FelContext ctx = new AbstractConetxt() {

public Object get(Object name) {

if("天气".equals(name)){

return "晴";

}

if("温度".equals(name)){

return 25;

}

return null;

}

};

FelEngine fel = new FelEngineImpl(ctx);

Object eval = fel.eval("'天气:'+天气+';温度:'+温度");

System.out.println(eval);

输出结果：天气:晴;温度:25

7:多层上下文环境（命名空间）

FelEngine fel = new FelEngineImpl();

String costStr = "成本";

String priceStr="价格";

FelContext baseCtx = fel.getContext();

//父级上下文中设置成本和价格

baseCtx.set(costStr, 50);

baseCtx.set(priceStr,100);

String exp = priceStr+"-"+costStr;

Object baseCost = fel.eval(exp);

System.out.println("期望利润：" + baseCost);

FelContext ctx = new ContextChain(baseCtx, new MapContext());

//通货膨胀导致成本增加（子级上下文中设置成本，会覆盖父级上下文中的成本）

ctx.set(costStr,50+20 );

Object allCost = fel.eval(exp, ctx);

System.out.println("实际利润：" + allCost);

输出结果：

期望利润：50

实际利润：30

8:编译执行

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

ctx.set("单价", 5000);

ctx.set("数量", 12);

ctx.set("运费", 7500);

Expression exp = fel.compile("单价*数量+运费",ctx);

Object result = exp.eval(ctx);

System.out.println(result);

执行结果：67500

备注：适合处理海量数据，编译执行的速度基本与Java字节码执行速度一样快。

9:自定义函数

//定义hello函数

Function fun = new CommonFunction() {

public String getName() {

return "hello";

}

* 调用hello("xxx")时执行的代码

@Override

public Object call(Object[] arguments) {

Object msg = null;

if(arguments!= null && arguments.length>0){

msg = arguments[0];

}

return ObjectUtils.toString(msg);

}

};

FelEngine e = new FelEngineImpl();

//添加函数到引擎中。

e.addFun(fun);

String exp = "hello('fel')";

//解释执行

Object eval = e.eval(exp);

System.out.println("hello "+eval);

//编译执行

Expression compile = e.compile(exp, null);

eval = compile.eval(null);

System.out.println("hello "+eval);

执行结果：

hello fel hello fel

10:调用静态方法

如果你觉得上面的自定义函数也麻烦，Fel提供的$函数可以方便的调用工具类的方法熟悉jQuery的朋友肯定知道"$"函数的威力。Fel东施效颦，也实现了一个"$"函数,其作用是获取class和创建对象。结合点操作符，可以轻易的调用工具类或对象的方法。

//调用Math.min(1,2)

FelEngine.instance.eval("$('Math').min(1,2)");

//调用new Foo().toString();

FelEngine.instance.eval("$('com.greenpineyu.test.Foo.new').toString());

通过"$('class').method"形式的语法，就可以调用任何等三方类包（commons lang等）及自定义工具类的方法，也可以创建对象，调用对象的方法。如果有需要，还可以直接注册Java Method到函数管理器中。

11 大数值计算（始于0.9版本）

Fel发布后，有些网友希望提供大数值计算功能，于是，大数值计算功能就有了。例子如下：

FelEngine fel = FelBuilder.bigNumberEngine();

String input = "111111111111111111111111111111+22222222222222222222222222222222";

Object value = fel.eval(input);

Object compileValue = fel.compile(input, fel.getContext()).eval(fel.getContext());

System.out.println("大数值计算（解释执行）:" + value);

System.out.println("大数值计算（编译执行）:" + compileValue);

由上例子可以看出，大数值计算引擎和常规计算引擎在使用方法是相同的。如果表达式数值比较大，要求精度高，可使用大数值计算引擎。不足之处是效率没有常规计算引擎高。

安全（始于0.8版本）

为了防止出现“${'System'}.exit(1)”这样的表达式导致系统崩溃。Fel加入了安全管理器，主要是对方法访问进行控制。安全管理器中通过允许访问的方法列表（白名单）和禁止访问的方法列表（黑名单）来控制方法访问。将"java.lang.System. * "加入到黑名单，表示System类的所有方法都不能访问。将"java.lang.Math. * "加入白名单，表示只能访问Math类中的方法。如果你不喜欢这个安全管理器，可以自己开发一个，非常简单，只需要实现一个方法就可以了。附基本Java工程源代码：

Example类：

1 public class Example {

3 public static void main(String[] args) {

5 System.out.println("-----------1.入门---------");

6 helloworld();

8 System.out.println("-----------2.使用变量---------");

9 useVariable();

11 System.out.println("-----------3.获取对象属性---------");

12 getAttr();

14 System.out.println("---------4.调用对象的方法-----------");

15 callMethod();

17 System.out.println("--------5.访问数组、集合------------");

18 visitColl();

20 System.out.println("--------6.自定义上下文环境------------");

21 context();

23 System.out.println("--------7.多层次上下文环境(变量命名空间)------------");

24 contexts();

26 System.out.println("---------8.大数值计算-----------");

27 testBigNumber();

29 System.out.println("----------9.函数----------");

30 userFunction();

32 System.out.println("---------10.自定义解释器-----------");

33 userInterpreter();

35 System.out.println("----------11.操作符重载----------");

36 operatorOverload();

38 System.out.println("----------12.速度测试----------");

39 testSpeed();

41 System.out.println("----------13.静态方法----------");

42 staticMethod();

43 }

45 /**

46 * 入门

47 */

48 public static void helloworld() {

49 // FelEngine fel = new FelEngineImpl();

50 Object result = FelEngine.instance.eval("5000*12+7500");

51 System.out.println(result);

52 }

54 /**

55 * 使用变量

56 */

57 public static void useVariable() {

58 FelEngine fel = getEngine();

59 FelContext ctx = fel.getContext();

60 ctx.set("单价", 5000);

61 ctx.set("数量", 12);

62 ctx.set("运费", 7500);

63 Object result = fel.eval("单价*数量+运费");

64 System.out.println(result);

65 }

67 /**

68 * 获取对象属性

69 */

70 public static void getAttr() {

71 FelEngine fel = getEngine();

72 FelContext ctx = fel.getContext();

73 Foo foo = new Foo();

74 ctx.set("foo", foo);

75 Map m = new HashMap();

76 m.put("ElName", "fel");

77 ctx.set("m", m);

79 // 调用foo.getSize()方法。

80 Object result = fel.eval("foo.size");

81 System.out.println(result);

82 // 调用foo.isSample()方法。

83 result = fel.eval("foo.sample");

84 System.out.println(result);

85 // foo没有name、getName、isName方法

86 // foo.name会调用foo.get("name")方法。

87 result = fel.eval("foo.name");

88 System.out.println(result);

89 // m.ElName会调用m.get("ElName");

90 result = fel.eval("m.ElName");

91 System.out.println(result);

92 }

94 /**

95 * 调用对象的方法

96 */

97 public static void callMethod() {

98 FelEngine fel = getEngine();

99 FelContext ctx = fel.getContext();

100 ctx.set("out", System.out);

101 fel.eval("out.println('Hello Everybody'.substring(6))");

102 }

103

104 /**

105 * 访问数组、集合

106 */

107 public static void visitColl() {

108 FelEngine fel = getEngine();

109 FelContext ctx = fel.getContext();

110

111 // 数组

112 int[] intArray = { 1, 2, 3 };

113 ctx.set("intArray", intArray);

114 // 获取intArray[0]

115 String exp = "intArray[0]";

116 System.out.println(exp + "->" + fel.eval(exp));

117

118 // List

119 List list = Arrays.asList(1, 2, 3);

120 ctx.set("list", list);

121 // 获取list.get(0)

122 exp = "list[0]";

123 System.out.println(exp + "->" + fel.eval(exp));

124

125 // 集合

126 Collection coll = Arrays.asList("a", "b", "c");

127 ctx.set("coll", coll);

128 // 获取集合最前面的元素。执行结果为"a"

129 exp = "coll[0]";

130 System.out.println(exp + "->" + fel.eval(exp));

131

132 // 迭代器

133 Iterator iterator = coll.iterator();

134 ctx.set("iterator", iterator);

135 // 获取迭代器最前面的元素。执行结果为"a"

136 exp = "iterator[0]";

137 System.out.println(exp + "->" + fel.eval(exp));

138

139 // Map

140 Map m = new HashMap();

141 m.put("name", "Wangxiaoming");

142 ctx.set("map", m);

143 exp = "map.name";

144 System.out.println(exp + "->" + fel.eval(exp));

145

146 // 多维数组

147 int[][] intArrays = { { 11, 12 }, { 21, 22 } };

148 ctx.set("intArrays", intArrays);

149 exp = "intArrays[0][0]";

150 System.out.println(exp + "->" + fel.eval(exp));

151

152 // 多维综合体，支持数组、集合的任意组合。

153 List listArray = new ArrayList();

154 listArray.add(new int[] { 1, 2, 3 });

155 listArray.add(new int[] { 4, 5, 6 });

156 ctx.set("listArray", listArray);

157 exp = "listArray[0][0]";

158 System.out.println(exp + "->" + fel.eval(exp));

159 }

160

161 /**

162 * 自定义上下文环境

163 */

164 public static void context() {

165 // 负责提供气象服务的上下文环境

166 FelContext ctx = new AbstractContext() {

167 @Override

168 public Object get(String name) {

169 if ("天气".equals(name)) {

170 return "晴";

171 }

172 if ("温度".equals(name)) {

173 return 25;

174 }

175 return null;

176 }

177

178 };

179 FelEngine fel = new FelEngineImpl(ctx);

180 String exp = "'天气-----:'+天气+';温度------:'+温度";

181 Object eval = fel.compile(exp, ctx).eval(ctx);

182 System.out.println(eval);

183 }

184

185 /**

186 * 多层次上下文环境(变量命名空间)

187 */

188 public static void contexts() {

189 FelEngine fel = getEngine();

190 String costStr = "成本";

191 String priceStr = "价格";

192 FelContext baseCtx = fel.getContext();

193 // 父级上下文中设置成本和价格

194 baseCtx.set(costStr, 50);

195 baseCtx.set(priceStr, 100);

196

197 String exp = priceStr + "-" + costStr;

198 Object baseCost = fel.eval(exp);

199 System.out.println("期望利润：" + baseCost);

200

201 FelContext ctx = new ContextChain(baseCtx, new MapContext());

202 // 通货膨胀导致成本增加（子级上下文中设置成本，会覆盖父级上下文中的成本）

203 ctx.set(costStr, 50 + 20);

204 Object allCost = fel.eval(exp, ctx);

205 System.out.println("实际利润：" + allCost);

206 }

207

208 /**

209 * 大数值计算

210 */

211 public static void testBigNumber() {

212 // 构建大数值计算引擎

213 FelEngine fel = FelBuilder.bigNumberEngine();

214 String input = "111111111111111111111111111111+22222222222222222222222222222222";

215 Object value = fel.eval(input);// 解释执行

216 Object compileValue = fel.compile(input, fel.getContext()).eval(

217 fel.getContext());// 编译执行

218 System.out.println("大数值计算（解释执行）:" + value);

219 System.out.println("大数值计算（编译执行）:" + compileValue);

220 }

221

222 /**

223 * 函数

224 */

225 public static void userFunction() {

226 // 定义hello函数

227 Function fun = new CommonFunction() {

228

229 @Override

230 public String getName() {

231 return "hello";

232 }

233

234 /*

235 * 调用hello("xxx")时执行的代码

236 */

237 @Override

238 public Object call(Object[] arguments) {

239 Object msg = null;

240 if (arguments != null && arguments.length > 0) {

241 msg = arguments[0];

242 }

243 return ObjectUtils.toString(msg);

244 }

245

246 };

247 FelEngine e = getEngine();

248 // 添加函数到引擎中。

249 e.addFun(fun);

250 String exp = "hello('fel')";

251 // 解释执行

252 Object eval = e.eval(exp);

253 System.out.println("hello " + eval);

254 // 编译执行

255 Expression compile = e.compile(exp, null);

256 eval = compile.eval(null);

257 System.out.println("hello " + eval);

258 }

259

260 /**

261 *

262 */

263 public static void testCompileX() {

264 FelEngine fel = getEngine();

265 String exp = "单价*数量";

266 final MutableInt index = new MutableInt(0);

267

268 // 数据库中单价列的记录

269 final int[] price = new int[] { 2, 3, 4 };

270 // 数据库中数量列的记录

271 final double[] number = new double[] { 10.99, 20.99, 9.9 };

272 FelContext context = new AbstractContext() {

273

274 @Override

275 public Object get(String name) {

276 if ("单价".equals(name)) {

277 return price[index.intValue()];

278 }

279 if ("数量".equals(name)) {

280 return number[index.intValue()];

281 }

282 return null;

283 }

284 };

285 Expression compExp = fel.compile(exp, context);

286 for (int i = 0; i < number.length; i++) {

287 index.setValue(i);

288 Object eval = compExp.eval(context);

289 System.out.println("总价[" + price[i] + "*" + number[i] + "=" + eval

290 + "]");

291 }

292 }

293

294 /**

295 * 自定义解释器

296 */

297 public static void userInterpreter() {

298 FelEngine fel = getEngine();

299 String costStr = "成本";

300 FelContext rootContext = fel.getContext();

301 rootContext.set(costStr, "60000");

302 FelNode node = fel.parse(costStr);

303 // 将变量解析成常量

304 node.setInterpreter(new ConstInterpreter(rootContext, node));

305 System.out.println(node.eval(rootContext));

306 }

307

308 /**

309 * 操作符重载，使用自定义解释器实现操作符重载

310 */

311 public static void operatorOverload() {

312 /*

313 * 扩展Fel的+运算符，使其支持数组+数组

314 */

315

316 FelEngine fel = getEngine();

317 // 单价

318 double[] price = new double[] { 2, 3, 4 };

319 // 费用

320 double[] cost = new double[] { 0.3, 0.3, 0.4 };

321 FelContext ctx = fel.getContext();

322 ctx.set("单价", price);

323 ctx.set("费用", cost);

324 String exp = "单价+费用";

325 Interpreters interpreters = new Interpreters();

326 // 定义"+"操作符的解释方法。

327 interpreters.add("+", new Interpreter() {

328 @Override

329 public Object interpret(FelContext context, FelNode node) {

330 List args = node.getChildren();

331 double[] leftArg = (double[]) args.get(0).eval(context);

332 double[] rightArg = (double[]) args.get(1).eval(context);

333 return sum(leftArg) + sum(rightArg);

334 }

335

336 // 对数组进行求和

337 public double sum(double[] array) {

338 double d = 0;

339 for (int i = 0; i < array.length; i++) {

340 d += array[i];

341 }

342 return d;

343 }

344 });

345

346 // 使用自定义解释器作为编译选项进行进行编译

347 Expression expObj = fel.compile(exp, null, interpreters);

348 Object eval = expObj.eval(ctx);

349 System.out.println("数组相加:" + eval);

350 }

351

352 /**

353 * 速度测试

354 */

355 public static void testSpeed() {

356 FelEngine fel = getEngine();

357 String exp = "40.52334+60*(21.8144+17*32.663)";

358 FelNode node = fel.parse(exp);

359 int times = 1000;

360 long s1 = System.currentTimeMillis();

361 for (int i = 0; i < times; i++) {

362 // double j = 40.52334 + 60 * (21.8144 + 17 * 32.663);

363 node.eval(null);

364 }

365 long s2 = System.currentTimeMillis();

366 System.out.println("花费的时间:" + (s2 - s1));

367 }

368

369 /**

370 * 大数据量计算（计算1千万次)

371 */

372 public static void massData() {

373 FelEngine fel = getEngine();

374 final Interpreters opti = new Interpreters();

375 final MutableInt index = new MutableInt(0);

376 int count = 10 * 1000 * 1000;

377 final double[] counts = new double[count];

378 final double[] prices = new double[count];

379 Arrays.fill(counts, 10d);

380 Arrays.fill(prices, 2.5d);

381 opti.add("单价", new Interpreter() {

382 @Override

383 public Object interpret(FelContext context, FelNode node) {

384 return prices[index.intValue()];

385 }

386 });

387 opti.add("数量", new Interpreter() {

388 @Override

389 public Object interpret(FelContext context, FelNode node) {

390 return counts[index.intValue()];

391 }

392 });

393 Expression expObj = fel.compile("单价*数量", null, opti);

394 long start = System.currentTimeMillis();

395 Object result = null;

396 for (int i = 0; i < count; i++) {

397 result = expObj.eval(null);

398 index.increment();

399 }

400 long end = System.currentTimeMillis();

401

402 System.out.println("大数据量计算:" + result + ";耗时:" + (end - start));

403 }

404

405 /**

406 * 静态方法

407 *

408 *

409 * 如果你觉得上面的自定义函数也麻烦，Fel提供的$函数可以方便的调用工具类的方法熟悉jQuery的朋友肯定知道"$"函数的威力。

410 * Fel东施效颦，也实现了一个"$"函数,其作用是获取class和创建对象。结合点操作符，可以轻易的调用工具类或对象的方法。

411 * 通过"$('class').method"形式的语法，就可以调用任何等三方类包（commons lang等）及自定义工具类的方法，

412 * 也可以创建对象，调用对象的方法。如果有需要，还可以直接注册Java Method到函数管理器中。

413 */

414 public static void staticMethod() {

415 // 调用Math.min(1,2)

416 System.out.println(FelEngine.instance.eval("$('Math').max(1,3)"));

417 // 调用new Foo().toString();

418 System.out.println(FelEngine.instance

419 .eval("$('com.ebiz.fel.Foo.new').toString()"));

420 }

421

422 private static FelEngine getEngine() {

423 return FelBuilder.engine();

424 }

425

426 }

427

428 class ColumnInterpreter implements Interpreter {

429 MutableInt index;

430

431 double[] records;

432

433 ColumnInterpreter(MutableInt index, double[] records) {

434 this.index = index;

435 this.records = records;

436 }

437

438 @Override

439 public Object interpret(FelContext context, FelNode node) {

440 return records[index.intValue()];

441 }

442 }

443

444 class MutableInt {

445 private int value;

446

447 public MutableInt(int i) {

448 this.value = i;

449 }

450

451 public int intValue() {

452 return value;

453 }

454

455 public void setValue(int i) {

456 this.value = i;

457 }

458

459 public void increment() {

460 value++;

461 }

462 }

Foo类：

1 import java.util.ArrayList;

2 import java.util.Iterator;

3 import java.util.List;

5 public class Foo {

7 private final String name;

9 private Foo foo = null;

11 static private Foo[] f = new Foo[] { new Foo("array0"), new Foo("array1") };

13 static private Foo[] fooes = f;

15 public Foo[] getFooes() {

16 return fooes;

17 }

19 public void setFooes(Foo[] fooes) {

20 this.fooes = fooes;

21 }

23 private boolean beenModified = false;

24 private String property1 = "some value";

26 public Foo(String name) {

27 this.name = name;

28 }

30 public Foo() {

31 this("anonymity");

32 }

34 public static String sayHello(String str) {

35 return "hello" + str;

36 }

38 public class Cheezy {

39 public Iterator iterator() {

40 return getCheeseList().iterator();

41 }

42 }

44 public String get(String arg) {

45 if ("name".equals(arg)) {

46 return name;

47 }

48 return "can't find " + arg;

49 }

51 public String convertBoolean(boolean b) {

52 return "Boolean : " + b;

53 }

55 public int getCount() {

56 return 5;

57 }

59 public String contact(String a, String b, String c, String d) {

60 return a + b + c + c;

61 }

63 public List getCheeseList() {

64 ArrayList answer = new ArrayList();

65 answer.add("cheddar");

66 answer.add("edam");

67 answer.add("brie");

68 return answer;

69 }

71 public Cheezy getCheezy() {

72 return new Cheezy();

73 }

75 public boolean isSimple() {

76 return true;

77 }

79 public int square(int value) {

80 return value * value;

81 }

83 public boolean getTrueAndModify() {

84 beenModified = true;

85 return true;

86 }

88 public boolean getModified() {

89 return beenModified;

90 }

92 public int getSize() {

93 return 22;

94 }

96 public String getProperty1() {

97 return property1;

98 }

100 public void setProperty1(String newValue) {

101 property1 = newValue;

102 }

103

104 public Foo getFoo() {

105 return this.foo;

106 }

107

108 public void setFoo(Foo foo) {

109 this.foo = foo;

110 }

111

112 @Override

113 public String toString() {

114 return this.name;

115 }

116 }

运行结果：

1 -----------1.入门---------

2 67500

3 -----------2.使用变量---------

4 67500

5 -----------3.获取对象属性---------

6 22

7 can't find sample

8 anonymity

9 fel

10 ---------4.调用对象的方法-----------

11 Everybody

12 --------5.访问数组、集合------------

13 intArray[0]->1

14 list[0]->1

15 coll[0]->a

16 iterator[0]->a

17 map.name->Wangxiaoming

18 intArrays[0][0]->11

19 listArray[0][0]->1

20 --------6.自定义上下文环境------------

21 天气-----:晴;温度------:25

22 --------7.多层次上下文环境(变量命名空间)------------

23 期望利润：50

24 实际利润：30

25 ---------8.大数值计算-----------

26 大数值计算（解释执行）:22333333333333333333333333333333

27 大数值计算（编译执行）:22333333333333333333333333333333

28 ----------9.函数----------

29 hello fel

30 hello fel

31 ---------10.自定义解释器-----------

32 60000

33 ----------11.操作符重载----------

34 数组相加:10.0

35 ----------12.速度测试----------

36 花费的时间:91

37 ----------13.静态方法----------

38 3

39 anonymity

转载：https://blog.csdn.net/chichengjunma/article/details/56012272

posted @

2019-01-07 15:27

先锋之客

阅读(13777)

编辑

会员力量，点亮园子希望

刷新页面返回顶部

公告

fel是什么意思_fel的翻译_音标_读音_用法_例句_爱词霸在线词典

什么意思_fel的翻译_音标_读音_用法_例句_爱词霸在线词典首页翻译背单词写作校对词霸下载用户反馈专栏平台登录fel是什么意思_fel用英语怎么说_fel的翻译_fel翻译成_fel的中文意思_fel怎么读,fel的读音,fel的用法,fel的例句翻译人工翻译试试人工翻译翻译全文fel英 [fel]美 [fel]释义n.<拉>胆汁大小写变形:FELFel点击人工翻译，了解更多人工释义实用场景例句全部This paper briefly expounds the technological design and smelting process of ZCuZn 40 Mn 3 Fel.主要论述了锰黄铜熔炼工艺设计及熔炼过程.互联网The Surefooted enchantment now requires Fel Iron Rod ( was Runed Eternium Rod ).“靴子-稳固”附魔现在需要符文魔铁棒 ( 原来是符文恒金棒 ).互联网Fel Armor spell power bonus no longer scales with Spirit.邪甲术法术强度不再受到精神值加成.互联网The orcs were corrupted and became Fel Orcs.兽人们腐化成为堕落兽人.互联网Added a new creep camp group ( 1 Ghost with Frost Attack + 2 Fel Beasts )增加了新的野怪种类 ( 鬼魂+2个地狱兽 )互联网The effect of divergence of the incident electron beam on the gain of FEL is analysed.分析了入射电子束的发散性对自由电子激光器增益的影响.互联网Mystery and speculation surround the corrupted fel orcs who recently appeared in Outland.神秘与猜测,不断地围绕著近期出现在外域的堕落地狱兽人.互联网The time of day when you fel most cyl f bdy temperature is at its peak.一天中,当你感到精力最充沛的时候,也就是你体温循环最高之时.互联网The transverse model spectral method is widely applied to numerical simulations of FEL oscillators.横模谱方法广泛应用于自由电子激光振荡器数值模拟.互联网There has been substantial theoretical interest in free - electron lasers ( FEL ) for the last decade.在过去10年对自由电子激光一直有着浓厚的研究兴趣.互联网Objective To determine whether TUDCA can penetrate the blood - aqueous barrier after taking orally the Fel Ursi.目的　探讨口服中药熊胆粉后,其标志成份牛磺熊脱氧胆酸(TUDCA)能否通过血 - 房水屏障到达房水内.互联网收起实用场景例句行业词典医学［拉］胆汁：同bile 释义实用场景例句行

自由电子激光器_百度百科

激光器_百度百科网页新闻贴吧知道网盘图片视频地图文库资讯采购百科百度首页登录注册进入词条全站搜索帮助首页秒懂百科特色百科知识专题加入百科百科团队权威合作下载百科APP个人中心收藏查看我的收藏0有用+10自由电子激光器播报讨论上传视频高功率相干辐射光源本词条由“科普中国”科学百科词条编写与应用工作项目审核。自由电子激光器(FEL)是一类不同于传统激光器的新型高功率相干辐射光源.虽然传统的激光器具有极好的单色性和相干性, 但它的低功率、低效率、固定频率和光束质量差的弱点, 使它大大逊色于自由电子激光器.自由电子激光器不需要气体、液体或固体作为工作物质, 而是将高能电子束的动能直接转换成相干辐射能.因此, 也可以认为自由电子激光器的工作物质就是自由电子。中文名自由电子激光器外文名FEL目录1简介2工作原理3自由电子激光器的应用4发展前景简介播报编辑自由电子激光器是一种新型的强相干辐射源。由于它可能具有高功率、高效率、波长的大范围调谐和超短脉冲的时间结构等一系列优良特性而受到人们的格外重视。目前, 除自由电子激光器之外, 还没有一种激光器能同时具备这些特点。这是因为它产生激光的原理与以往的激光器有本质上的不同。自由电子激光器是利用相对论电子束通过周期磁场将电子束的动能转换为辐射能。自由电子激光器是七十年代中期以来发展起来的一类新型激光器。它将电子束动能转变成激光辐射, 代表了一种全新的产生相干辐射的概念。自由电子激光器一般由电子加速器、摆动器和光学系统几个部分构成。加速器产生的高能电子束, 通过摆动器内沿长度方向交替变化的磁场时, 产生横向摆动, 并以光子的形式损失一部分能量。这部分能量转变成激光辐射, 通过光学系统输出。自由电子受激辐射的设想曾于1950年由Motz提出，并在1953年进行过实验，因受当时条件的限制，未能得到证实。1971年斯坦福大学的Madey等人重新提出了恒定横向周期磁场中的场致受激辐射理论，并首次在毫米波段实现了受激辐射；1976年Madey小组第一次实现了激光放大，1977年4月斯坦福大学Deacon等人才研制成第一台自由电子激光振荡器。它由一根抽成真空的长5.2米的铜管组成，外面绕有超导导线，以便在整个管上产生一个周期为3.2厘米的变化的横向静磁场（如图），轴上磁感应强度B_0为0.24特斯拉。铜管两端装有反射镜组成谐振腔，腔长12.7米，输出镜面的反射率为1.5%，能散度小于3\times10^{-3}的43.5兆电子伏的电子束由超导加速器产生。工作原理播报编辑yuanli自由电子激光的物理原理是利用通过周期性摆动磁场的高速电子束和光辐射场之间的相互作用，使电子的动能传递给光辐射而使其辐射强度增大。利用这一基本思想而设计的激光器称为自由电子激光器(简称FEL)。如图1所示，一组扭摆磁铁可以沿z轴方向产生周期性变化的磁场．磁场的方向沿Y轴。由加速器提供的高速电子束经偏转磁铁D导入摆动磁场。由于磁场的作用．电子的轨迹将发生偏转而沿着正弦曲线运动，其运动周期与摆动磁场的相同。这些电子在XOZ面内摇摆前进．沿x方向有一加速度．因而将在前进的方向上自发地发射电磁波。辐射的方向在以电子运动方向为中心的一个角度范围内。它的工作原理可简述如下。由加速器产生的高能电子经偏转磁铁注入到极性交替变换的扭摆磁铁中。电子因做扭摆运动而产生电磁辐射（光脉冲），光脉冲经下游及上游两反射镜反射而与以后的电子束团反复发生作用。结果是电子沿运动方向群聚成尺寸小于光波波长的微小的束团。这些微束团将它们的动能转换为光场的能量，使光场振幅增大。这个过程重复多次，直到光强达到饱和。作用后的电子则经下游的偏转磁铁偏转到系统之外。以上是FEL产生过程的比较形象的描述。从物理学角度看，这个过程就是电子对辐射的受激康普顿散射的结果。这里一个最为关键的环节是电子要聚集成许多短于光波波长的束团。因为，只有这样它的辐射才是相干的，而FEL的技术难度，恰恰也正在于此。电子束性能必须十分优越（能量分散小，方向分散小，时间稳定度高……），同时流强尽可能大，才能达到要求，显然，FEL工作波长愈短，技术难度也就愈大。通过稳定的电子束来泵浦，配置电子贮存环让电子束再加速并再循环使用，用静电方法或逆向运转的射频线性加速器使电子减速以充分利用出射电子束的剩余能量，使用上述任何一种方法都可以进一步增大总体效率。自由电子激光器输出的激光波长\lambda _s与电子的能量E有关：\lambda _s \sim 1/E^2，故改变电子束的加速电压就可以改变激光波长，这叫做电压调谐，其调谐范围很宽，原则上可以在任意波长上运转。在现有的电子枪和加速器的实验条件下，可以获得从毫米波到1000Å的光频波段范围内的连续调谐的相干辐射。自由电子激光器的输出功率与电子束的能量、电流密度以及磁感应强度B_0有关，它可望成为一种高平均功率、高效率（理论极限达40%）、高分辨率的具有稳定功率和频率输出的激光器件，采用它能够避免某些工艺上的麻烦（如激光工作物质稀缺、有毒或腐蚀金属、玻璃），另外，它基本上不存在使用寿命问题。 [1]自由电子激光器的应用播报编辑由于自由电子激光器具有许多一般激光器望尘莫及的优点, 所以自由电子激光器问世后不久,科学家们就开始着手于研究它的应用问题.自由电子激光特别适宜于研究光与原子、分子和凝固态物质的相互作用, 这类研究涉及到固体表面物理、半导体物理、超导体、凝聚态物理、化学、光谱学、非线性光学、生物学、医学、材料、能源、通信、国防和技术科学等多个方面.原子核工程是自由电子激光器应用最有前途的领域之一, 自由电子激光器在此应用上的最大优点是高功率、宽可调光谱范围, 以及准连续运转特点.因此, 可应用于物质提纯、受控核聚变、铀、钆、硼、锶和钛等元素的同位素分离和等离子体加热等.自由电子激光器的高效率、短脉冲及波长可调的优点, 在工业上也有广阔的应用前景.例如在半导体工艺中的薄膜沉积、平板印刷术、蚀刻、掺杂质等, 自由电子激光器特别适合大批量材料处理, 因为它的波长可调谐, 器件又可放大到能输出高平均功率.用于材料处理时, 要求功率为1 ～5KW, 波长为8 ～ 20μm的自由电子激光器.自由电子激光器还可进行各种化学分析与测量, 可以生产高纯硅晶体、满足计算机生产的需要.集成电路装配, 包括量子处理和光刻可更多地借助短波自由电子激光器.另外, 自由电子激光器还用在激光加工、光CVD等方面的材料, 制作X射线激光器、激光加速器等.自由电子激光器还用在原子、分子的基础研究上, 光化学可依赖工作在紫外到远紫外区的自由电子激光器.自由电子激光的可调谐性和超短脉冲特性, 使得探索化学反应过程、生化过程的动态过程成为可能.这对研究物质的结构和性能对生成新物质的研究, 将会产生革命性的变革和新的进展.医学也是自由电子激光器应用最丰富的领域, 而目前当务之急是研制紧凑、实用的小型自由电子激光器, 其主要目的是把价格降到大医院能买得起的水平.对医学研究和治疗而言, 这种激光器可在1 ～ 10μm波段可调, 输出功率不超过几百瓦, 此种应用一般要求有几瓦平均功率.更可观的是自由电子激光器可以为空间站输送能量, 以降低空间站对太阳能电池的依赖性.用于向卫星传输功率时, 要求功率为100KW ～ 1MW,波长为0.86μm的自由电子激光器.在军事上, 自由电子激光器可以成为强激光武器, 是反洲际导弹的激光武器的主要潜在手段之一.自由电子激光器功率虽然强大, 但由于其体积庞大, 因此目前只适宜安装在地面上, 供陆基激光器使用.在毫米波段, 自由电子激光器是唯一有效的强相干信号源, 在毫米波激光雷达、反隐形军事目标和激光致盲等研究中具有不可替代的重要应用价值. [1]发展前景播报编辑自由电子激光器在短波长、大功率、高效率和波长可调节这四大主攻方向上，为激光学科的研究开辟了一条新途径，它可望用于对凝聚态物理学、材料特征、激光武器、激光反导弹、雷达、激光聚变、等离子体诊断、表面特性、非线性以及瞬态现象的研究，在通讯、激光推进器、光谱学、激光分子化学、光化学、同位素分离、遥感等领域，它应用的前景也很可观。新手上路成长任务编辑入门编辑规则本人编辑我有疑问内容质疑在线客服官方贴吧意见反馈投诉建议举报不良信息未通过词条申诉投诉侵权信息封禁查询与解封©2024 Baidu 使用百度前必读 | 百科协议 | 隐私政策 | 百度百科合作平台 | 京ICP证030173号京公网安备110000020000

高性能EL——Fel探秘，兼谈EL-阿里云开发者社区

产品解决方案文档与社区权益中心定价云市场合作伙伴支持与服务了解阿里云联系我们4008013260售前咨询售后服务其他服务我要建议我要投诉备案控制台开发者社区首页探索云世界探索云世界云上快速入门，热门云上应用快速查找了解更多问产品动手实践考认证TIANCHI大赛活动广场活动广场丰富的线上&线下活动，深入探索云世界任务中心做任务，得社区积分和周边高校计划让每位学生受益于普惠算力训练营资深技术专家手把手带教话题畅聊无限，分享你的技术见解开发者评测最真实的开发者用云体验乘风者计划让创作激发创新阿里云MVP遇见技术追梦人直播技术交流，直击现场下载下载海量开发者使用工具、手册，免费下载镜像站极速、全面、稳定、安全的开源镜像技术资料开发手册、白皮书、案例集等实战精华插件为开发者定制的Chrome浏览器插件探索云世界新手上云云上应用构建云上数据管理云上探索人工智能云计算弹性计算无影存储网络倚天云原生容器serverless中间件微服务可观测消息队列数据库关系型数据库NoSQL数据库数据仓库数据管理工具PolarDB开源向量数据库热门Modelscope模型即服务弹性计算云原生数据库物联网云效DevOps龙蜥操作系统平头哥钉钉开放平台大数据大数据计算实时数仓Hologres实时计算FlinkE-MapReduceDataWorksElasticsearch机器学习平台PAI智能搜索推荐人工智能机器学习平台PAI视觉智能开放平台智能语音交互自然语言处理多模态模型pythonsdk通用模型开发与运维云效DevOps钉钉宜搭支持服务镜像站码上公益

开发者社区

开发与运维

文章

正文

高性能EL——Fel探秘，兼谈EL

2017-05-18

2765

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《

阿里云开发者社区用户服务协议》和

《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写

侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介：

Fel是最近javaeye比较火的关键词，这是由网友

lotusyu开发的一个高性能的EL，从作者给出的数据来看，性能非常优异，跟前段时间温少开源的

Simple EL有的一拼。首先要说，这是个好现象，国内的开源项目越来越多，可以看出开发者的水平是越来越高了，比如我最近还看到有人开源的类似kestel的轻量级MQ——

fqueue也非常不错，有兴趣可以看下我的分析《

fqueue初步分析》。

进入正文，本文是尝试分析下Fel的实现原理，以及优缺点和aviator——我自己开源的EL之间的简单比较。

Fel的实现原理跟Simple EL是类似，都是使用template生成中间代码——也就是普通的java代码，然后利用javac编译成class，最后运行，当然，这个过程都是动态的。JDK6已经引入了编译API，在此之前的版本可以调用sun的类来编译，因为javac其实就是用java实现的。回到Fel里面，FelCompiler15就是用 com.sun.tools.javac.Main来编译，而FelCompiler16用标准的javax.tools.JavaCompiler来编译的。

文法和语法解释这块是使用antlr这个parse generator生成的，这块不多说，有兴趣可以看下antlr，整体一个运行的过程是这样：

expression string

antlr

AST

comiple

java source template

java

class

Expression

这个思路我在实现aviator之前就想过，但是后来考虑到API需要用的sun独有的类，而且要求classpath必须有tools.jar这个依赖包，就放弃了这个思路，还是采用ASM生成字节码的方式。题外，velocity的优化可以采用这个思路，我们有这么一个项目是这么做的，也准备开源了。

看看Fel生成的中间代码，例如a+b这样的一个简单的表达式，假设我一开始不知道a和b的类型，编译是这样：

FelEngine fel

new

FelEngineImpl(); Expression exp

fel.compile(

a+b

null

);

我稍微改了下FEL的源码，让它打印中间生成的java代码，a+b生成的中间结果为：

package

com.greenpineyu.fel.compile;

import

com.greenpineyu.fel.common.NumberUtil;

import

com.greenpineyu.fel.Expression;

import

com.greenpineyu.fel.context.FelContext;

import

org.apache.commons.lang.ObjectUtils;

import

org.apache.commons.lang.StringUtils;

public

class

Fel_0

implements

Expression{

public

Object eval(FelContext context) { java.lang.Object var_1

(java.lang.Object)context.get(

);

java.lang.Object var_0

(java.lang.Object)context.get(

);

return

(ObjectUtils.toString(var_0))

(ObjectUtils.toString(var_1)); } }

可见，FEL对表达式解析和解释后，利用template生成这么一个普通的java类，而a和b都从context中获取并转化为Object类型，这里没有做任何判断就直接认为a和b是要做字符串相加，然后拼接字符串并返回。

问题出来了，因为没有在编译的时候传入context（我们这里是null），FEL会将a和b的类型默认都为java.lang.Object，a+b解释为字符串拼接。但是运行的时候，我完全可以传入a和b都为数字，那么结果就非常诡异了：

FelEngine fel

new

FelEngineImpl(); Expression exp

fel.compile(

a+b

null

); Map

String, Object

env

new

HashMap

String, Object

(); env.put(

); env.put(

3.14

); System.out.println(exp.eval(

new

MapContext(env)));

输出：

13.14

1+3.14的结果，作为字符串拼接就是13.14，而不是我们想要的4.14。如果将表达式换成a*b，就完全运行不了

com.greenpineyu.fel.exception.CompileException:

package

com.greenpineyu.fel.compile;

import

com.greenpineyu.fel.common.NumberUtil;

import

com.greenpineyu.fel.Expression;

import

com.greenpineyu.fel.context.FelContext;

import

org.apache.commons.lang.ObjectUtils;

import

org.apache.commons.lang.StringUtils;

public

class

Fel_0

implements

Expression{

public

Object eval(FelContext context) { java.lang.Object var_1

(java.lang.Object)context.get(

);

java.lang.Object var_0

(java.lang.Object)context.get(

);

return

(var_0)

(var_1); } } [Fel_0.java:

: 运算符

不能应用于 java.lang.Object,java.lang.Object] at com.greenpineyu.fel.compile.FelCompiler16.compileToClass(FelCompiler16.java:

113

) at com.greenpineyu.fel.compile.FelCompiler16.compile(FelCompiler16.java:

) at com.greenpineyu.fel.compile.CompileService.compile(CompileService.java:

) at com.greenpineyu.fel.FelEngineImpl.compile(FelEngineImpl.java:

) at TEst.main(TEst.java:

) Exception in thread

main

java.lang.NullPointerException at TEst.main(TEst.java:

)

这个问题对于Simple EL同样存在，如果没有在编译的时候能确定变量类型，这无法生成正确的中间代码，导致运行时出错，并且有可能造成非常诡异的bug。

这个问题的本质是因为Fel和Simple EL没有自己的类型系统，他们都是直接使用java的类型的系统，并且必须在编译的时候确定变量类型，才能生成高效和正确的代码，我们可以将它们称为“强类型的EL“。

现在让我们在编译的时候给a和b加上类型，看看生成的中间代码：

FelEngine fel

new

FelEngineImpl(); fel.getContext().set(

); fel.getContext().set(

3.14

); Expression exp

fel.compile(

a+b

null

); Map

String, Object

env

new

HashMap

String, Object

(); env.put(

); env.put(

3.14

); System.out.println(exp.eval(

new

MapContext(env)));

查看中间代码：

package

com.greenpineyu.fel.compile;

import

com.greenpineyu.fel.common.NumberUtil;

import

com.greenpineyu.fel.Expression;

import

com.greenpineyu.fel.context.FelContext;

import

org.apache.commons.lang.ObjectUtils;

import

org.apache.commons.lang.StringUtils;

public

class

Fel_0

implements

Expression{

public

Object eval(FelContext context) {

double

var_1

((java.lang.Number)context.get(

)).doubleValue();

double

var_0

((java.lang.Number)context.get(

)).doubleValue();

return

(var_0)

(var_1); } }

可以看到这次将a和b都强制转为double类型了，做数值相加，结果也正确了：

4.140000000000001

Simple EL我没看过代码，这里猜测它的实现也应该是类似的，也应该有同样的问题。

相比来说，aviator这是一个弱类型的EL，在编译的时候不对变量类型做任何假设，而是在运行时做类型判断和自动转化。过去提过，我给aviator的定位是一个介于EL和script之间的东西，它有自己的类型系统。例如，3这个数字，在java里可能是long,int,short,byte，而aviator统一为AviatorLong这个类型。为了在这两个类型之间做适配，就需要做很多的判断和box,unbox操作。这些判断和转化都是运行时进行的，因此aviator没有办法做到Fel这样的高效，但是已经做到至少跟groovy这样的弱类型脚本语言一个级别，也超过了JXEL这样的纯解释EL，具体可以看这个性能测试。

强类型还是弱类型，这是一个选择问题，如果你能在运行前就确定变量的类型，那么使用Fel应该可以达到或者接近于原生java执行的效率，但是失去了灵活性；如果你无法确定变量类型，则只能采用弱类型的EL。

EL涌现的越来越多，这个现象有点类似消息中间件领域，越来越多面向特定领域的轻量级MQ的出现，而不是原来那种大而笨重的通用MQ大行其道，一方面是互联网应用的发展，需求不是通用系统能够满足的，另一方面我认为也是开发者素质的提高，大家都能造适合自己的轮子。从EL这方面来说，我也认为会有越来越多特定于领域的，优点和缺点一样鲜明的EL出现，它们包含设计者自己的目标和口味，选择很多，就看取舍。

文章转自庄周梦蝶，原文发布时间2011-09-17

boxti

fel的简单使用及介绍-腾讯云开发者社区-腾讯云

简单使用及介绍-腾讯云开发者社区-腾讯云余生大大fel的简单使用及介绍关注作者腾讯云开发者社区文档建议反馈控制台首页学习活动专区工具TVP最新优惠活动文章/答案/技术大牛搜索搜索关闭发布登录/注册首页学习活动专区工具TVP最新优惠活动返回腾讯云官网余生大大首页学习活动专区工具TVP最新优惠活动返回腾讯云官网社区首页 >专栏 >fel的简单使用及介绍fel的简单使用及介绍余生大大关注发布于 2022-11-02 14:45:497960发布于 2022-11-02 14:45:49举报文章被收录于专栏：余生大大余生大大Fel介绍 Fel在源自于企业项目，设计目标是为了满足不断变化的功能需求和性能需求。

Fel是开放的，引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是Fel函数），所有这些函数都是可以替换的，扩展函数也非常简单。

Fel有双引擎，同时支持解释执行和编译执行。可以根据性能要求选择执行方式。编译执行就是将表达式编译成字节码（生成java代码和编译模块都是可以扩展和替换的）

Fel有多快？

通常情况下，Fel-0.7每秒可以执行千万次表达式（不包含编译时间）。速度是Jexl-2.0的20倍以上。目前还没有发现开源的表达式引擎比Fel快。

为何要使用Fel?

Fel语法和API非常简单，语法与Java基本相同，几乎没有学习成本。

Fel非常快，上面已经做了简单说明。

Fel整个包只有200多KB。

Fel可以非常方便的访问数组、集合、Map的元素和对象的属性。

Fel可以非常方便的调用对象的方法和类方法（如果这些还不够，可以添加自定义函数）。

Fel支持大数值高精度计算

Fel有良好的安全管理功能

如果Fel不能满足你的要求，扩展和修改Fel很简单。

Fel不能做什么？

Fel只支持表达式，不支持脚本。

Fel适用场景：

Fel适合处理海量数据，Fel良好的扩展性可以更好的帮助用户处理数据。

Fel同样适用于其他需要使用表达式引擎的地方（如果工作流、公式计算、数据有效性校验等等）

创建项目引入依赖

org.eweb4j

fel

0.8

复制使用方式1、算术方程式 public static void main(String[] args){

arithmetic();// 算术方程式

}

private static void arithmetic(){

FelEngine fel = new FelEngineImpl();

Object result = fel.eval("(6552*365+12000)/12");

System.out.println(result);

}复制2、变量方式获取变量进行计算表达 public static void main(String[] args){

arithmetic();// 算术方程式

System.err.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

variable();// 变量法

}

private static void arithmetic(){

FelEngine fel = new FelEngineImpl();

Object result = fel.eval("(6552*365+12000)/12");

System.out.println(result);

}

private static void variable(){

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

ctx.set("日计数", 6552);

ctx.set("天数", 365);

ctx.set("基础费用", 12000);

ctx.set("月份",12);

Object result = fel.eval("(日计数*天数+基础费用)/月份");

System.out.println(result);

}复制3、可以使用对象属性进行计算 public static void main(String[] args){

objectDetil();

}

private static void objectDetil(){

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

Map m = new HashMap();

m.put("ElName", "我是map的value");

ctx.set("m",m);

// 调用m.get('ElName')方法。

Object result = fel.eval("m.get('ElName')");

// 调用m.size()方法。

Object size = fel.eval("m.size()");

System.out.println(result+" size = "+size);

}复制4、获取数组，集合，map跟上面一样使用的 fel.eval(“xxx”)来获取对象内容 private static void array(){

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

//数组

int[] intArray = {1,2,3};

ctx.set("intArray",intArray);

//获取intArray[0]

String exp = "intArray[0]";

System.out.println(exp+"->"+fel.eval(exp));

//List

List list = Arrays.asList(1,2,3);

ctx.set("list",list);

//获取list.get(0)

exp = "list[0]";

System.out.println(exp+"->"+fel.eval(exp));

//集合

Collection coll = Arrays.asList("a","b","c");

ctx.set("coll",coll);

//获取集合最前面的元素。执行结果为"a"

exp = "coll[0]";

System.out.println(exp+"->"+fel.eval(exp));

//迭代器

Iterator iterator = coll.iterator();

ctx.set("iterator", iterator);

//获取迭代器最前面的元素。执行结果为"a"

exp = "iterator[0]";

System.out.println(exp+"->"+fel.eval(exp));

//Map

Map m = new HashMap();

m.put("name", "HashMap");

ctx.set("map",m);

exp = "map.name";

System.out.println(exp+"->"+fel.eval(exp));

//多维数组

int[][] intArrays= {{11,12},{21,22}};

ctx.set("intArrays",intArrays);

exp = "intArrays[0][0]";

System.out.println(exp+"->"+fel.eval(exp));

//多维综合体，支持数组、集合的任意组合。

List listArray = new ArrayList();

listArray.add(new int[]{1,2,3});

listArray.add(new int[]{4,5,6});

ctx.set("listArray",listArray);

exp = "listArray[0][0]";

System.out.println(exp+"->"+fel.eval(exp));

}复制5、调用java方法 private static void java(){

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

ctx.set("out", System.out);

fel.eval("out.println('Hello Word'.substring(6))");

}复制6、编译执行 private static void install(){

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

ctx.set("日计数", 6552);

ctx.set("天数", 365);

ctx.set("基础费用", 12000);

ctx.set("月份",12);

Expression exp = fel.compile("(日计数*天数+基础费用)/月份",ctx);

Object result = exp.eval(ctx);

System.out.println(result);

}复制适合处理海量数据，编译执行的速度基本与Java字节码执行速度一样快。7、自定义函数 private static void custom(){

//定义hello函数

Function fun = new CommonFunction() {

@Override

public String getName() {

return "hello";

}

* 调用hello("xxx")时执行的代码

@Override

public Object call(Object[] arguments) {

Object msg = null;

if(arguments!= null && arguments.length>0){

msg = arguments[0];

}

return ObjectUtils.toString(msg);

}

};

FelEngine e = new FelEngineImpl();

//添加函数到引擎中。

e.addFun(fun);

String exp = "hello('test')";

//解释执行

Object eval = e.eval(exp);

System.out.println("hello "+eval);

//编译执行

Expression compile = e.compile(exp, null);

eval = compile.eval(null);

System.out.println("hello "+eval);

}复制参考博客：Fel是轻量级的高效的表达式计算引擎学习（一）-------------------------IDEA引入本地jar包选择jar包确定即可本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。原始发表：2020-05-13，如有侵权请联系 cloudcommunity@tencent.com 删除前往查看打包jarjava编程算法本文分享自作者个人站点/博客前往查看如有侵权，请联系 cloudcommunity@tencent.com 删除。本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！打包jarjava编程算法评论登录后参与评论0 条评论热度最新登录后参与评论推荐阅读LV.关注文章0获赞0目录Fel介绍创建项目引入依赖使用方式领券社区专栏文章阅读清单互动问答技术沙龙技术视频团队主页腾讯云TI平台活动自媒体分享计划邀请作者入驻自荐上首页技术竞赛资源技术周刊社区标签开发者手册开发者实验室关于社区规范免责声明联系我们友情链接腾讯云开发者扫码关注腾讯云开发者领取腾讯云代金券热门产品域名注册云服务器区块链服务消息队列网络加速云数据库域名解析云存储视频直播热门推荐人脸识别腾讯会议企业云CDN加速视频通话图像分析MySQL 数据库SSL 证书语音识别更多推荐数据安全负载均衡短信文字识别云点播商标注册小程序开发网站监控数据迁移Copyright © 2013 - 2024 Tencent Cloud. All Rights Reserved. 腾讯云版权所有深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569腾讯云计算（北京）有限责任公司京ICP证150476号 | 京ICP备11018762号 | 京公网安备号11010802020287问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档Copyright © 2013 - 2024 Tencent Cloud.All Rights Reserved. 腾讯云版权所有登录后参与评论00

我国自由电子激光技术发展战略研究

中国工程科学

论文

视频

会议

专家

全部

标题

作者

年份

关键词

正文

投稿

审稿

编辑

首页

期刊

焦点

视频

联系我们

期刊首页

优先出版

当期阅读

过刊浏览

作者中心

关于期刊

English

2020年

第22卷

第3期

摘要

关键词

图片

参考文献

fel的简单使用及介绍-CSDN博客

fel的简单使用及介绍

最新推荐文章于 2022-02-08 17:08:38 发布

余生大大

最新推荐文章于 2022-02-08 17:08:38 发布

阅读量7.6k

点赞数

本文链接：https://blog.csdn.net/AnNanDu/article/details/106096235

版权

Fel介绍

Fel在源自于企业项目，设计目标是为了满足不断变化的功能需求和性能需求。

Fel是开放的，引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是Fel函数），所有这些函数都是可以替换的，扩展函数也非常简单。 Fel有双引擎，同时支持解释执行和编译执行。可以根据性能要求选择执行方式。编译执行就是将表达式编译成字节码（生成java代码和编译模块都是可以扩展和替换的）

Fel有多快？通常情况下，Fel-0.7每秒可以执行千万次表达式（不包含编译时间）。速度是Jexl-2.0的20倍以上。目前还没有发现开源的表达式引擎比Fel快。

为何要使用Fel? Fel语法和API非常简单，语法与Java基本相同，几乎没有学习成本。

Fel非常快，上面已经做了简单说明。

Fel整个包只有200多KB。

Fel可以非常方便的访问数组、集合、Map的元素和对象的属性。

Fel可以非常方便的调用对象的方法和类方法（如果这些还不够，可以添加自定义函数）。

Fel支持大数值高精度计算

Fel有良好的安全管理功能

如果Fel不能满足你的要求，扩展和修改Fel很简单。

Fel不能做什么？ Fel只支持表达式，不支持脚本。

Fel适用场景： Fel适合处理海量数据，Fel良好的扩展性可以更好的帮助用户处理数据。

Fel同样适用于其他需要使用表达式引擎的地方（如果工作流、公式计算、数据有效性校验等等）

创建项目引入依赖

org.eweb4j

fel

0.8

使用方式

1、算术方程式

public static void main(String[] args){

arithmetic();// 算术方程式

}

private static void arithmetic(){

FelEngine fel = new FelEngineImpl();

Object result = fel.eval("(6552*365+12000)/12");

System.out.println(result);

}

2、变量方式

获取变量进行计算表达

public static void main(String[] args){

arithmetic();// 算术方程式

System.err.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

variable();// 变量法

}

private static void arithmetic(){

FelEngine fel = new FelEngineImpl();

Object result = fel.eval("(6552*365+12000)/12");

System.out.println(result);

}

private static void variable(){

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

ctx.set("日计数", 6552);

ctx.set("天数", 365);

ctx.set("基础费用", 12000);

ctx.set("月份",12);

Object result = fel.eval("(日计数*天数+基础费用)/月份");

System.out.println(result);

}

3、可以使用对象属性进行计算

public static void main(String[] args){

objectDetil();

}

private static void objectDetil(){

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

Map m = new HashMap();

m.put("ElName", "我是map的value");

ctx.set("m",m);

// 调用m.get('ElName')方法。

Object result = fel.eval("m.get('ElName')");

// 调用m.size()方法。

Object size = fel.eval("m.size()");

System.out.println(result+" size = "+size);

}

4、获取数组，集合，map

跟上面一样使用的 fel.eval(“xxx”)来获取对象内容

private static void array(){

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

//数组

int[] intArray = {1,2,3};

ctx.set("intArray",intArray);

//获取intArray[0]

String exp = "intArray[0]";

System.out.println(exp+"->"+fel.eval(exp));

//List

List list = Arrays.asList(1,2,3);

ctx.set("list",list);

//获取list.get(0)

exp = "list[0]";

System.out.println(exp+"->"+fel.eval(exp));

//集合

Collection coll = Arrays.asList("a","b","c");

ctx.set("coll",coll);

//获取集合最前面的元素。执行结果为"a"

exp = "coll[0]";

System.out.println(exp+"->"+fel.eval(exp));

//迭代器

Iterator iterator = coll.iterator();

ctx.set("iterator", iterator);

//获取迭代器最前面的元素。执行结果为"a"

exp = "iterator[0]";

System.out.println(exp+"->"+fel.eval(exp));

//Map

Map m = new HashMap();

m.put("name", "HashMap");

ctx.set("map",m);

exp = "map.name";

System.out.println(exp+"->"+fel.eval(exp));

//多维数组

int[][] intArrays= {{11,12},{21,22}};

ctx.set("intArrays",intArrays);

exp = "intArrays[0][0]";

System.out.println(exp+"->"+fel.eval(exp));

//多维综合体，支持数组、集合的任意组合。

List listArray = new ArrayList();

listArray.add(new int[]{1,2,3});

listArray.add(new int[]{4,5,6});

ctx.set("listArray",listArray);

exp = "listArray[0][0]";

System.out.println(exp+"->"+fel.eval(exp));

}

5、调用java方法

private static void java(){

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

ctx.set("out", System.out);

fel.eval("out.println('Hello Word'.substring(6))");

}

6、编译执行

private static void install(){

FelEngine fel = new FelEngineImpl();

FelContext ctx = fel.getContext();

ctx.set("日计数", 6552);

ctx.set("天数", 365);

ctx.set("基础费用", 12000);

ctx.set("月份",12);

Expression exp = fel.compile("(日计数*天数+基础费用)/月份",ctx);

Object result = exp.eval(ctx);

System.out.println(result);

}

适合处理海量数据，编译执行的速度基本与Java字节码执行速度一样快。

7、自定义函数

private static void custom(){

//定义hello函数

Function fun = new CommonFunction() {

@Override

public String getName() {

return "hello";

}

* 调用hello("xxx")时执行的代码

@Override

public Object call(Object[] arguments) {

Object msg = null;

if(arguments!= null && arguments.length>0){

msg = arguments[0];

}

return ObjectUtils.toString(msg);

}

};

FelEngine e = new FelEngineImpl();

//添加函数到引擎中。

e.addFun(fun);

String exp = "hello('test')";

//解释执行

Object eval = e.eval(exp);

System.out.println("hello "+eval);

//编译执行

Expression compile = e.compile(exp, null);

eval = compile.eval(null);

System.out.println("hello "+eval);

}

参考博客：Fel是轻量级的高效的表达式计算引擎学习（一）

-------------------------IDEA引入本地jar包

选择jar包确定即可

优惠劵

余生大大

关注

踩

觉得还不错?

一键收藏

打赏

知道了

fel的简单使用及介绍

Fel介绍Fel在源自于企业项目，设计目标是为了满足不断变化的功能需求和性能需求。Fel是开放的，引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是Fel函数），所有这些函数都是可以替换的，扩展函数也非常简单。Fel有双引擎，同时支持解释执行和编译执行。可以根据性能要求选择执行方式。编译执行就是将表达式编译成字节码（生成java代码和编译模块都是可以扩展和替换的）Fel有多快？通常情况下，Fel-0.7每秒可以执行千万次表达式（不包含编译时间）。速度

复制链接

扫一扫

表达式引擎fel-0.9版本

12-29

Fel表达式计算引擎0.9版本

Fel表达式计算引擎

chen_jia_hao的博客

10-27

5500

一、Fel表达式计算引擎介绍

Fel在源自于企业项目，设计目标是为了满足不断变化的功能需求和性能需求。

Fel有双引擎，同时支持解释执行和编译执行。可以根据性能要求选择执行方式。编译执行就是将表达式编译成字节码（生成java代...

参与评论

您还未登录，请先

后发表或查看评论

Fel是轻量级的高效的表达式计算引擎学习（一）

weixin_33881753的博客

01-07

221

Fel在源自于企业项目，设计目标是为了满足不断变化的功能需求和性能需求。

【Java】Fel计算引擎学习

哈士奇

05-23

9050

#Fel是轻量级的高效的表达式计算引擎Fel在源自于企业项目，设计目标是为了满足不断变化的功能需求和性能需求。Fel是开放的，引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是Fel函数），所有这些函数都是可以替换的，扩展函数也非常简单。Fel有双引擎，同时支持解释执行和编译执行。可以根据性能要求选择执行方式。编译执行就是将表达式编译成字节码（生成java代码和编译模块都是可以扩展和替换的）##Fel有多快？http。//负责提供气象服务的上下文环境。...

Fel是轻量级的高效的表达式计算引擎[Z]

weixin_30698527的博客

06-06

251

Fel在源自于企业项目，设计目标是为了满足不断变化的功能需求和性能需求。

Fel有双引擎，同时支持解释执行和编译执行。可以根据性能要求选择执行方式。编译执行就是将表达式编译成字节码（生成java代码和编译模块都是可以扩展和替换...

JAVA FEL表达式的使用

止殇之战的专栏

02-09

1684

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

一、FEL是什么？

二、使用步骤

1.引入库

2.使用示例

数据格式

2.自定义函数

总结

前言

背景：用户行为事件，数据格式是Json的，需要解析数据，判断用户是否满足指定的表达式

一、FEL是什么？

是谷歌开发的，轻量级表达式计算引擎

参考：http://code.google.com/p/fast-el/wiki/Performance

二、使用...

Java表达式解析器

TangKenny的博客

02-08

3655

1、阿里巴巴QLExpress

https://github.com/alibaba/QLExpress/blob/master/README.md

由阿里的电商业务规则、表达式（布尔组合）、特殊数学公式计算（高精度）、语法分析、脚本二次定制等强需求而设计的一门动态脚本引擎解析工具。在阿里集团有很强的影响力，同时为了自身不断优化、发扬开源贡献精神，于2012年开源。

2、java的公式计算工具：【JEVAL】

开源项目，主页 http://jeval.sourceforge.net

主要用于实现计算字符

EWeb4J框架介绍

11-29

274

EWeb4J 是一个基于 Servlet/Jdbc 构建的轻量级 Java Web 开发框架。它可以代替 SSH来开发一个完整的 Web 应用程序。

它专注于少侵入、少配置、松耦合、RESTful架构风格的...

fel all 0.9 表达式

06-17

Fel是轻量级的高效的表达式计算引擎

allwinner-usb-fel.log

12-31

全志soc 使用usb进行nand flash 刷机的uart log

高速 Fel表达式引擎

04-23

高速 Fel表达式引擎。类似ognl 速度很快。性能很高

Fel表达式引擎

06-12

Fel表达式引擎

Fel是轻量级的高效的表达式计算引擎

01-10

Fel在源自于企业项目，设计目标是为了满足不断变化的功能需求和性能需求。

Fel基于Java1.5开发，适用于Java1.5及以上版本。

Fel Javael表达式引擎

10-17

Fel轻量级的高效的表达式计算引擎。 Fel在源自于企业项目,设计目标是为了不断变化的功能需求和性能需求.文档中有个别错误，但不影响阅读

fel计算引擎0.9官方版本.zip

05-20

fel计算引擎0.9官方版本,0.9的版本多了很多方法，支持了大数高精度，maven没有找到直接pom依赖，下载到本地再依赖本地jar包来进行操作

fel-0.8.zip

08-06

fel轻量高效的表达式计算引擎，下载后解压放入项目中即可使用

sunxi-tools-fel-windows

03-06

我自己移植的windows下的sunxitools-fel，可以用于全志cpu的fel模式。cpu调试

fel.jar-0.8

05-29

fel-0.8.jar...........................................................................

ts.rar_FEL_aaaz

09-20

Input for a file description created today

fel使用方法

上海光机所研制「自由电子激光（FEL）『台式机』」，攻克新型辐射源难关，这一研究有怎样的价值？ - 知乎

上海光机所研制「自由电子激光（FEL）『台式机』」，攻克新型辐射源难关，这一研究有怎样的价值？ - 知乎首页知乎知学堂发现等你来答切换模式登录/注册物理学粒子加速器电子信息电子科学与技术科研热点上海光机所研制「自由电子激光（FEL）『台式机』」，攻克新型辐射源难关，这一研究有怎样的价值？霭月寒洲详细链接：研制自由电子激光“台式机”，上海光机所攻克新型辐射源难关_腾讯新闻近期，中国科学院上海光学精密机械研究所强场物理国家重点实验室研究团队依托…显示全部关注者18被浏览17,723关注问题写回答邀请回答好问题添加评论分享1 个回答默认排序鱼刺知乎十年新知答主关注解读下。新闻稿和PRL文章[1]的题目是略有不同的。先说新闻稿的题目【研制自由电子激光（FEL）‘台式机’，上海光机所攻克新型辐射源难关】。关键词已经加粗了。先简要介绍下这些关键词的含义。首先是这个新型辐射源【自由电子激光】。自由电子激光被认为是第四代光源，其主要特点是高亮度，高相干度，超短脉冲宽度等。前三代光源就不介绍了，因为跟这篇PRL关系不是很大。自由电子激光的原理稍后细说。其次是【台式机】。“台式机”实际上是从英文“Table-top”翻译的，指的是设备的尺寸很小，一张桌子就足够了，当然桌子指的是光学平台“optical table”。强调小是为了跟基于传统加速器的光源做对比。这里还隐含传统加速器和激光等离子体加速器的对比。传统加速器往往动辄数公里长，而激光等离子体加速器（这里主要是指激光尾波场加速器）则可以做到手掌大小。这里后面还会细说。最后是【难关】。这个难关指的是加速器产生的电子束的一个重要品质参数--能散。电子束的能散极大程度上制约自由电子激光的光源品质。基本上能散越小越好。传统加速器得益于将近一个世纪的持续发展，能够将能散做到极小。而激光尾波场加速器中产生的电子能散还不是很理想。这篇PRL文章实际上在缩小电子束能散这个问题上取得了突破。因此新闻稿说攻克新型辐射源难关。那么再来看PRL文章的题目说了啥：激光尾波场加速器中通过调控等离子体密度分布产生能量近GeV能散千分之几量级的电子束。【我自己翻译的，英文题目是Near-GeV Electron Beams at a Few Per-Mille Level from a Laser Wakefield Accelerator via Density-Tailored Plasma】。这个调控等离子体密度分布的实质是为了【去啁啾】。这样我们再把加粗的概念介绍下。先说下上面没细说的传统加速器和激光尾波场加速器的对比。实际上这些背景知识介绍大家可以参考我另一篇回答: 这里自引下：传统加速器和激光尾波场加速器的对比: 大家应该都有关注前段时间吵的沸沸扬扬的CEPC论证「杨振宁先生和中科院高能所王贻芳院士神仙打架」。CEPC环形正负电子对撞机首先是电子加速器。需要将电子加速到至少到250GeV的能量量级，设备周长将达到100公里，耗资至少数以千亿。欧洲的CERN周长27公里。即便比较小的美国斯坦福直线加速器SLAC长度也有3公里，其最高电子能量只有50GeV左右。这些传统的加速器的原理都是射频场加速。其核心是电场对电子的加速。射频场加速器中粒子的能量增益受限于加速介质的电击穿强度。一般传统的射频加速器能够承载的最高加速梯度约为100 MeV/m，对应的电场梯度为100兆伏特/米。对于几十上百GeV的能量需求自然要求加速长度在km量级，造价自然是天文数字。而激光尾波场加速的梯度能够达到100GeV/m，是传统加速器的1000倍以上，加速到相同的能量介质的长度自然要小1000倍。比如需要1GeV的电子只需要大约1mm的加速长度。当然激光尾波场加速器的实际尺寸取决于激光器的大小。一般激光器的尺寸不会很大，业内人士称这种加速器为台面加速器。一张桌子的大小完事了「有点吹的成分，实际上也就是个大三居的面积」。等离子体：激光尾波场加速的介质是等离子体。等离子体的组成成分是离子和电子。在超强超短激光辐照下，基本上物质都会被完全电离成等离子体。既然已经被电离了，也就无所谓击穿了。没有了击穿场强的限制，原则上等离子体可以承载任意高的电场强度。激光尾波场加速器：激光尾波场加速中「尾波」指的是尾随激光脉冲的等离子体波。其基本加速原理如下，超短超强的激光脉冲辐照在一定密度的气体上以后，脉冲的前沿「可把脉冲的时间空间分布都看成高斯分布，激光脉冲就像一颗子弹一样」可以将气体电离成等离子体。激光脉冲的有质动力「光压，可联想太阳帆加速以便于理解」推开其传播路径上的电子，离子由于很重基本不动。激光过去以后就形成离子和电子的电荷分离场，电子被这个电场吸引围绕离子振荡，形成等离子体波。这个波是纵波，可以捕获背景的电子将其加速。由于激光在传播，持续的在其后面激发等离子体波，因此这个波被形象的叫做尾波。实际上整个过程也跟在快速移动的快艇后面的尾波非常类似。有一种冲浪运动就叫尾波冲浪，冲浪者在快艇后面形成的尾波中被持续加速。下面附赠笔者原创的激光尾波场加速原理动画【鸣谢Particle-in-Cell粒子模拟程序OSIRIS4.0】。能散：这个概念是这篇文章的研究重点，能散，顾名思义是能量的分散程度，英文“Energy spread”。指的是一个电子束团中电子能量的集中程度。比如，假如理想情况下一个电子束团中所有的电子的能量都完全一样，那么这个束团的能散为零。当然这种束团是不存在的。实际的电子束团总会有能散，而我们要做的就是试图减小能散。一个好的电子束团的能谱分布多数一般可近似为高斯分布，比如下图我某一篇文章中某一个电子束团的能谱分布。这个分布告诉我们大多数的电子的能量集中在1.2 GeV左右，随着远离峰值位置，各能量位置的电子数目逐渐减小。我们取能谱峰值的一半对应的峰值左右的能量的差值为能散，即半高全宽的能散 \Delta E_{\mathrm {FWHM}} ，当然也可以取均方差的能散 \Delta E_{\mathrm {rms}} 。一般均方差的能散要小于半高全宽，比如对于高斯分布来说半高全宽是均方差的 2\sqrt{2ln2} \approx 2.35 倍。这里说的是绝对能散。用绝对能散除以峰值位置的能量则为相对能散 \Delta E/ E 。这篇文章的主要结果即是产生了相对能散 \Delta E /E ~ 2.4‰ - 4.1‰ 的电子束。啁啾：啁啾【chirp】是指频率随时间而改变的信号。这个词本意是鸟叫声。鸟叫的声调抑扬顿挫实为频率随时间的改变，所以这个词用的真实很妙。知乎好像不能插入音频，不过感兴趣的可以听下这个链接里的啁啾音频信号：如果频率随时间增加，先看到低频波后看到高频波，为正啁啾。反之为负啁啾。比如下图中这个波，频率很明显的随时间增加，是一个正啁啾的信号。图片来自维基百科啁啾的用途很广泛。只举一个跟这篇PRL文章息息相关的。文章中提到的上海光机所的200TW激光器正是利用了啁啾脉冲放大技术，2018年的诺贝儿物理学奖。我们知道对于波来说，尤其是电磁波，频率即能量，频率越高能量越高。所以在加速器领域，或者说这篇文章中啁啾实际上指的是电子能量随时间的变化。换句话说，激光尾波场加速中电子束在加速过程中自然的产生了啁啾。再换句话说，在时间上【等效于空间位置除以常数c】电子束团的能量随时间变化而变化，即为有能散。那么这个啁啾是怎么来的呢？还是以我自己的研究工作举例，如下图左图。灰色背景是尾波场的等离子体密度分布，我们可以看到里面有一束电子束。绿色实现是这个尾波场纵向上的静电场分布。红色尾电子束的能谱分布，而彩色的倾斜的部分尾电子束的啁啾分布。可以看出这个束团中越往右的电子能量越低，越往左的电子能量越高。这是怎么造成的呢？绿色的实线在尾场范围里基本是一个线性的分布，左边为负值且越左越负，对电子为加速场；右边为正值且越右越高，对电子是减速场。电子的初始位置为靠近左边弧形尾波场密度最高的位置【最黑的位置】，且在纵向上有一定的分布。这样越往左的电子感受的加速场越高，越往右的电子感受的加速场越低，这样随着时间的演化，电子束团左右两端的电子能量差越来越大，从而形成如图所示的啁啾，也即有大的能散。最后为所谓的去啁啾：或者叫抑制啁啾【dechirping】。去啁啾所要实现的效果为电子的能量不随时间或者空间变化，也就是拉平上图左面的那个倾斜的电子分布。比如我通过一些方法能够实现上图右面的啁啾分布，在一定程度上抑制了啁啾，减小了能散。这既是去啁啾的概念。当然具体的手段暂时还不能说，因为文章还没有发出来。实现了小的能散，则有望将这种电子束用于自由电子激光。补充下自由电子激光原理：【自由电子】说明其原理与一般激光器依靠能级激励的粒子数反转有本质的不同。自由电子激光的原理如下图所示。核心有两个。电子源和磁铁振荡器「undulator」。振荡器由一系列磁极交替的二极磁铁组成。把一束自由电子注入到振荡器中。初始电子间的位置随机分布，即相位随机。电子在磁场中受洛伦兹力的作用发生偏振，由于磁场方向交替变化，电子的轨迹成正弦分布。当电子发生偏转时，即意味着有加速度的存在，因而产生同步辐射。偏转最强位置为正弦函数的波峰位置，辐射方向沿切向，因而是前向的定向辐射。然后，电子束再与其产生的辐射发生相互作用。某些电子的相位接近，导致他们产生的辐射为相干辐射，相干辐射强度更高。辐射对于电子的反作用会使得电子逐渐沿特定相位分布。特定相位分布又进一步增强相干辐射。如此正反馈过程，使得电子束逐渐变成某种间距特定的多束分布，这个过程叫做micro-bunching。当电子束micro-bunching完成后，辐射强度达到饱和。输出自由电子激光。自由电子激光的波长为：\lambda =\frac{ \lambda_{\mu} }{2\gamma^2} (1+\frac{K^2}{2})这里， \lambda_{\mu} 为振荡器的波长，即相邻磁铁的间距。K 为振荡强度，由磁铁强度和间距决定。 \gamma 为电子的洛伦兹因子，也即电子能量。显然电子束团的能散越小，上式分母中所有电子的 \gamma 越接近，自由电子激光的波长越接近，即单色性越好。另外，能散还决定了源的亮度，能散越小，亮度越高。OK，介绍了这么多背景知识，那么上光所这篇PRL是如何具体实现的去啁啾减小能散的呢？老规矩，睡醒了再更。又或者抛砖引玉，说不定有上光所的朋友们独家解读下。评论区惊现教授一枚，原论文通讯作者！以下我就越俎代庖，班门弄斧了。这篇文章用了一种很简单但高效的方法同时实现了电子注入、去啁啾和准稳相加速。介绍这个简单的方法之前，在啰嗦下新引入的概念。注入：英文「injection」，注射，打针的意思，就是把一种东西打入到另一种东西里面。这激光尾波场加速里面注入指的是把被加速对象--电子--弄到加速场结构--尾波场--里面。这就是类似于上面冲浪的例子，要把冲浪运动员弄到浪里面去。注入的实现需要一定的条件。就好比浪再高，运动员的竞技水平不行也不能完美的冲浪。一般而言在浪头来的时候，运动员要拼命的划水，这样使得自己的速度超过浪头的速度就可以被浪带着加速了。再举个例子，注入也有点像追火车。只有你的速度超过火车的速度，你才能一跃跳进火车里。在激光尾波场加速里面也是一样，电子的速度要超过尾波场的相速度才能实现注入和加速。当然，速度是一个相对的概念。如果你无法提升自己的速度，那就要想办法让火车慢下来。这篇文章实际上就是用了某种手段让尾波慢下来。去啁啾的概念上面介绍过了，不再赘述。再说下准稳相加速「quasi-phase-stabel acceleration」:前面介绍了尾波场的电场分布类似于线性分布，也就说在一个等离子体波的不同相位电场的大小是不一样的。实际上不只是大小在变，电场的方向也在变。比如，尾波场的后半个周期为负电场，对电子是加速；前半个周期为正电场，对电子是减速。对于单个电子来说，从后半个周期持续加速慢慢过渡到前半个周期就要面临减速了，我们把这个叫做失相「dephasing」。对于一群电子组成的电子束团，束团的头部的电子感受的电场强度低，加速效果差；尾部的电子感受的电场强度高，加速效果好，这样自然的就会引起能散的增加。因此如果能够控制尾波场的结构，或者尾波场结构的演化，使得电子束团感受的加速场稳定，那么就能控制电子束团的能散。这就是稳相的概念。前面加个「准」字，是说这种稳相还不是非常稳，科学家严谨又谦虚的表现。ok，下面进入正题，这个研究工作是如何实现注入、去啁啾和准稳相加速三位一体的？上面说了是调控了等离子体密度分布。这个密度分布的调控是通过局域的产生冲击波来说实现的。这个冲击波是通过在气体喷嘴「气体反生装置」上方放置障碍物的方式来实现的。具体如下图所示。圆柱形「Nozzle」就是气体喷嘴。一般这种喷嘴喷出的气体都是高马赫的超声气体喷流。下面的「Baffle」是障碍物，当超声气体喷流被障碍物阻挡，气体要被迫寻找其他路线，挤压临近的气体形成冲击波。最终的效果就是形成了下图（c）中蓝色曲线表示的密度分布图。很明显的看到在2mm位置处有一个高度的尖峰。在这个图中，激光从左向右传播。很明显，激光脉冲要先经历一个密度上升区域，然后再经历一个密度“下坡“，最后在较长的时间内经历一段均匀密度区「2-7mm」。图1. 图片来源[1]注入发生在尖峰的密度“下坡”区。这个密度下降沿实现的就是「让火车慢下来」，不是拼命的赶火车，而是让火车等你。这种注入方式也被叫做密度梯度注入。其原理是在密度梯度区降低等离子体波的相速度。相速度的概念不好理解的话，波长的概念可能更好理解一些。例如下图中的空泡状的圆形区域为一个等离子体波。等离子体波的波长 \lambda_p 与等离子体密度 n_p 有关， \lambda_p \propto 1 / \sqrt{n_p} 。显然，等离子体密度越高，等离子体波长越短，图中的空泡越小；等离子体密度越低，等离子体波长越长，图中的空泡越大。因此，在激光脉冲从尖峰位置向右传播的时候，由于等离子体密度的变低，等离子体波长变长。另外，等离子体波尾随激光脉冲，波的最前面是以激光的群速度运动，基本与激光脉冲保持同步，那么等离子体波变长相应的导致等离子体波的最后面向后移动，因此波的相速度降低。那么原本在较短的空泡尾部运动的电子由于波的拉长一下子进入了空泡内部，即注入。这是密度梯度注入的基本图像。这篇文章的注入还有另外一个因素。大家注意到上面图（c）还有一个红色区域代表了激光脉冲的焦斑大小随传播距离的演化过程。虚线是激光在真空中的传播情况。很显然，激光脉冲在真空中传播到焦点位置焦斑「或者叫束腰半径」最小，然后自然发散，焦斑越来越大。但是在等离子体中情况要较为复杂，因为激光脉冲会经历自聚焦和散焦的过程。这个过程基本上是非线性克尔效应和衍射的动态平衡过程。因而导致图中红色的激光脉冲自聚焦-散焦-再自聚焦-再散焦的过程。值得注意的是第一个自聚焦的位置非常接近密度下降沿与均匀密度区的过渡位置。他们这样做的目的是近一步的减小等离子体相速度，促进注入的发生。这是因为，自聚焦导致激光光强的增加，而非线性等离子体波的波长随激光光强的增加而增加 \lambda_{Np} \propto a\lambda_p 「这里a是归一化的激光光强，这个关系仅在a>>1时成立，在强场激光前提下这个关系一般总是成立的。」因此，将激光的焦点位置控制在密度下降沿能够进一步促进注入的发生。所以，作者们强调在他们的工作中，注入不仅仅是由于密度梯度注入机制，而是密度梯度注入和激光脉冲自聚焦的协同作用。上面所说的理论构想获得了数值模拟的验证，如下图。数值模拟中采用实验上实际测得的等离子体密度分布，获得了下图中红线和蓝线所代表的激光光球演化和尾波场相速度演化。灰色窄带区域对应数值模拟中注入发生的区域。很显然，注入发生在密度下降区快结束的时候，也是激光脉冲光强上升的时候。这个区域也和尾波场相速度的下降区符合。值得一提的是，注入是在很短的区域内发生的，当尾波场的相速度又增加了以后，注入迅速终止。这种局域性的注入能够缩短电子束团的纵向尺寸，即脉宽，也是保证小的能散的关键因素。图2. 图片来源[1]然后我们再来看，去啁啾和准稳相加速是如何实现的。下图3b给出了整个过程中电子束团的能量「蓝线」和绝对能散「红线」的演化。图c给出了对应的尾波场电场梯度「蓝线」和拟合的电子束团啁啾「红线」的演化。图3和下面的图4配合一起来看可能更好理解。我把图4上对应的四个时间节点也标在了图3上。图3. 图片来源[1]图4. 图片来源[1]基本上电子束团的啁啾取决于尾波场的电场梯度。在最初始注入时，电子束团具有负的啁啾（图3c,4e），这是因为束团头部的电子先注入，相比于尾部后注入的电子获得加速时间更长，能量更高。但由于，尾波场的电场梯度为正，头部电子感受的加速场场强低，尾部电子感受的加速场场强高，因为尾部电子的能量提升更快，在很短的时间内尾部电子能量高于头部电子，即啁啾的方向被翻了过来，如图4f。同时激光脉冲经历散焦，强度变低，尾波场尾部的尖峰状场强演化为了图4f向下的箭头位置处的形状，局部的电场梯度为负。这样头部感受的场强更强，尾部的场强变弱，这样电子束团的啁啾又一次被逐渐翻转。慢慢的正的啁啾被补偿为了几乎为零的啁啾「去啁啾了」，即电子束团各部分的能量几乎一致，如图4g。这时候对应的是能散最小的情形。当然能散的极小值不能为零，而是原来束团每一个纵向位置的局域能散「slice energy spread」。在随后的加速过程中，如图3c，电子束团的啁啾维持为零，即为稳相加速过程。这个稳相过程的物理实质应是「beam-loading」效应。不知道是不是可以翻译成载荷效应。指的是由于带负电的电子束团的存在，电子束自身的场强对尾波场的场强分布进行调节，使得电子束团感受到的场强几乎是均匀的场强，如图4g「绿线」。这样在数值模拟中产生了能量0.8GeV，能散仅有5‰的电子束团。当然，数值模拟的最终目的是为了解释实验结果的。下面欣赏下实验中产生的低能散的电子束团的能谱图。这里作者列出了15发电子束团的能谱，能量稳定在 800 MeV左右，能散\Delta E /E ~ 2.4‰ - 4.1‰，很难能可贵的是这些电子能谱非常干净，几乎没有暗背景。因此，这种低能散的，没有暗电流的电子能谱十分有望应用于驱动自由电子激光等先进光源。图5. 图片来源[1]参考^Near-GeV Electron Beams at a Few Per-Mille Level from a Laser Wakefield Accelerator via Density-Tailored Plasma https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.126.214801编辑于 2021-06-20 10:22赞同 10919 条评论分享收藏喜欢收起

自由电子激光可不可以用于半导体光刻？ - 知乎

自由电子激光可不可以用于半导体光刻？ - 知乎首页知乎知学堂发现等你来答切换模式登录/注册半导体芯片（集成电路）激光自由电子激光可不可以用于半导体光刻？自由电子激光（FEL）的优点是波长连续可调，从微波到硬X射线，相干性好，功率大。这些特点适不适合半导体工业，特别是极紫外（EUV）的应用？关注者24被浏览16,871关注问题写回答邀请回答好问题 4添加评论分享5 个回答默认排序一只鸟光学研究生/二次元爱好者/网络吹水大师关注可以用于，而且有极大的发展前景，甚至是光刻机未来的发展方向之一，甚至可以用于开发X激光直写芯片，如果能把产品做出来并商业化，那绝对是革命性和颠覆性的发展。但同样还是有非常多的问题难以解决。一个是自由电子激光器本身极大，一台自由电子激光器的尺寸往往是在百米量级；另外一个是成本极高，仅仅激光器造价，成本都是几十亿到上百亿的造价，而要用于加工那后续的成本会更高，这么对比asml的设备也就是个零头。所以自由电子激光领域有个比较大的方向就是低成本和小型化，如果做成了那用于加工也就不远了。编辑于 2020-08-10 16:07赞同 102 条评论分享收藏喜欢收起龙共人韦关注清华大学的SSMB光源已经验证可以用于激光光刻了，上海光机所这个月在自然发刊，封面就是自由电子激光装置的小型化发布于 2021-07-25 12:24赞同 42 条评论分享收藏喜欢

我国太赫兹源进入自由电子激光时代----中国科学院

PC / English / 联系我们 / 网站地图 /邮箱

加快打造原始创新策源地，加快突破关键核心技术，努力抢占科技制高点，为把我国建设成为世界科技强国作出新的更大的贡献。

——习近平总书记在致中国科学院建院70周年贺信中作出的“两加快一努力”重要指示要求

面向世界科技前沿、面向经济主战场、面向国家重大需求、面向人民生命健康，率先实现科学技术跨越发展，率先建成国家创新人才高地，率先建成国家高水平科技智库，率先建设国际一流科研机构。

——中国科学院办院方针

首页

组织机构

院况简介

院领导集体

机构设置

园区风采

科学研究

创新单元

科技专项

科技奖励

科技期刊

科研进展

成果转化

知识产权与科技成果转化网

工作动态

人才教育

中科院教育简介

中国科学技术大学

中国科学院大学

上海科技大学

工作动态

学部与院士

科学普及

中国科普博览

科普场馆

专题透视

工作动态

科普文章

科普视频

党建与科学文化

工作动态

反腐倡廉

文明天地

文化副刊

信息公开

信息公开规定

信息公开指南

信息公开目录

信息公开申请

信息公开年度报告

信息公开联系方式

首页

组织机构

科学研究

成果转化

人才教育

学部与院士

科学普及

党建与科学文化

信息公开

院况简介

　　1949年，伴随着新中国的诞生，中国科学院成立。　　作为国家在科学技术方面的最高学术机构和全国自然科学与高新技术的综合研究与发展中心，建院以来，中国科学院时刻牢记使命，与科学共进，与祖国同行，以国家富强、人民幸福为己任，人才辈出，硕果累累，为我国科技进步、经济社会发展和国家安全做出了不可替代的重要贡献。更多简介 +

院领导集体

侯建国

张亚平

孙也刚

周　琪

汪克强

常　进

丁赤飚

严　庆

孙晓明

翟立新

机构设置

院机关

办公厅

学部工作局

前沿科学与教育局

重大科技任务局

科技促进发展局

发展规划局

条件保障与财务局

人事局

直属机关党委

国际合作局

科学传播局

监督与审计局

离退休干部工作局

派驻机构

中央纪委国家监委驻中国科学院纪检监察组

分院

沈阳分院

长春分院

上海分院

南京分院

武汉分院

广州分院

成都分院

昆明分院

西安分院

兰州分院

新疆分院

院属机构

研究单位

学校

管理与公共支撑单位

新闻出版单位

其他单位

共建单位

投资企业

四类机构

院级非法人单元

所级分支机构

境外机构

群团和其他组织

创新单元

国家研究中心

国家重点实验室

国家工程研究中心

国家工程技术研究中心

国家科技资源共享服务平台

院工程实验室

重大科技基础设施

科技奖励

国家最高科学技术奖

国家自然科学奖

国家技术发明奖

国家科学技术进步奖

国家科学技术合作奖

中国科学院杰出科技成就奖

中国科学院国际科技合作奖

中国科学院科技促进发展奖

陈嘉庚科学奖

科技期刊

期刊导航

数字平台

期刊集群

期刊动态

科技专项

中国科学院院级科技专项体系包括战略性先导科技专项、重点部署科研专项、科技人才专项、科技合作专项、科技平台专项5类一级专项，实行分类定位、分级管理。

为方便科研人员全面快捷了解院级科技专项信息并进行项目申报等相关操作，特搭建中国科学院院级科技专项信息管理服务平台。了解科技专项更多内容，请点击进入→

科研进展/ 更多

上海药物所1类抗肿瘤新药HLN601脂质体获批进入临床研究

大连化物所实现室温下电催化甲烷和氧气转化制甲酸

理化所研制的全国产5吨/天氢液化器通过测试验收

沈阳自动化所等在生物制造与纳米机械分析领域获进展

合肥研究院等创制出套娃结构碳管阵列并构筑出小型化滤波电容器

科学家实现全脑光学接口虚拟现实和全脑闭环研究新范式

工作动态/ 更多

“液固循环流化床双氧水直接氧化氯丙烯生产环氧氯丙烷新工艺”通过科技成果评价

山东肥城300MW先进压缩空气储能国家示范项目阵列化蓄热装置完成安装

生物质化学链气化技术项目签约

萃取法短流程生产钒电解液示范线稳定运行

青海盐湖所获批建设青海省盐湖化工产业专利导航服务基地

硼中子俘获治疗项目获第八届“创客中国”总决赛一等奖

尾矿固废资源利用3×185万吨/年流态化磁化焙烧项目签约

宁波材料所获首届浙江省知识产权奖发明专利一等奖

亚热带生态所与长江水电集团签订战略合作协议

金属所组织开展“福建行”科技成果对接活动

分子细胞卓越中心、上海科技大学和翼思生物医药达成合作协议

2023年中国科学院（河南）科技成果发布暨项目对接会开幕

中国科学技术大学（简称“中科大”）于1958年由中国科学院创建于北京，1970年学校迁至安徽省合肥市。中科大坚持“全院办校、所系结合”的办学方针，是一所以前沿科学和高新技术为主、兼有特色管理与人文学科的研究型大学。

中国科学院大学（简称“国科大”）始建于1978年，其前身为中国科学院研究生院，2012年更名为中国科学院大学。国科大实行“科教融合”的办学体制，与中国科学院直属研究机构在管理体制、师资队伍、培养体系、科研工作等方面共有、共治、共享、共赢，是一所以研究生教育为主的独具特色的研究型大学。

上海科技大学（简称“上科大”），由上海市人民政府与中国科学院共同举办、共同建设，由上海市人民政府主管，2013年经教育部正式批准。上科大秉持“服务国家发展战略，培养创新创业人才”的办学方针，实现科技与教育、科教与产业、科教与创业的融合，是一所小规模、高水平、国际化的研究型、创新型大学。

工作动态/ 更多

中国科学院院士姚檀栋获塞里格曼冰晶奖

中国科大教授郝记华获2024年F.W.克拉克奖

中国科学院大学基础医学及长三角地区生命科学研究生学术论坛举办

全球气候变化下的水资源管理和研究生培养冬季学校开班

第八届植物分类研究高级研修班举办

中国科大学子在中国国际大学生创新大赛获佳绩

科普场馆/ 更多

中国科学院国家授时中心时间科学馆

中国科学院昆明动物研究所昆明动物博物馆

中国科学院合肥物质科学研究院合肥现代科技馆

中国科学院西双版纳热带植物园热带雨林民族文化博物馆

中国科学院动物研究所国家动物博物馆

中国科学院上海昆虫博物馆

工作动态/ 更多

华南植物园举办“植”此绿美共“树”未来植树活动

南北国家植物园女画家笔下的珍奇植物科普展开幕

上海天文台举办“与光同行”天文科普亲子活动

版纳植物园举办“2024雨林博物科学营”

科普文章/ 更多

太阳打“喷嚏” 地球会怎样

量子，匪夷所思但不“高冷”

卫星也戴“眼镜”——偏振卫星

看宇宙间那一场场盛大的“烟花表演”

科普视频/ 更多

十年，科技创新再出发！

【院士说】群星闪耀时总会照...

碳中和的创新发展机遇

专题透视/ 更多

科学环游记——2023寒假篇

核心舱成功发射我们的空间站来...

助力碳达峰、碳中和，科普在行动

工作动态/ 更多

兰州化物所党委理论学习中心组召开专题学习会

微电子所召开党委中心组（扩大）学习会议

沈阳分院分党组召开扩大学习会

成都生物所党委召开2024年第1次支部书记例会

南京天光所召开党委理论学习中心组党风廉政建设专题学习会

上海硅酸盐所召开党委理论学习中心组学习会

文化副刊

诗歌

书画

摄影

散文

反腐倡廉/ 更多

地理资源所召开2024年度第一次纪委会议

广州分院召开分院纪检组成员、直属机关纪委委员会议

兰州分院纪检组、系统单位纪委召开学习研讨（扩大）会议暨纪监审工作会议

沈阳分院召开2023年度纪监审业务第四次交流会暨纪检组2023年度工作总结会

沈阳自动化所开展纪检干部专题培训

违纪违法举报

文明天地/ 更多

武汉岩土所开展三八妇女节“巾帼绽芳华”活动

武汉植物园开展“春风如你熠熠芳华” 主题活动

成都文献中心开展“赴春天之约绽巾帼芳华” 科苑女性主题活动

深圳先进院举办"不负春色绽放芳华"三八妇女节主题系列活动

新疆生地所开展“芳华悦己，奋勇逐光”主题春日活动

信息公开工作信息

Follow

tp下载手机版|fel

tp下载手机版|fel

Fel是轻量级的高效的表达式计算引擎学习（一） - 先锋之客 - 博客园

fel是什么意思_fel的翻译_音标_读音_用法_例句_爱词霸在线词典

自由电子激光器_百度百科

高性能EL——Fel探秘，兼谈EL-阿里云开发者社区

fel的简单使用及介绍-腾讯云开发者社区-腾讯云

我国自由电子激光技术发展战略研究

fel的简单使用及介绍-CSDN博客

上海光机所研制「自由电子激光（FEL）『台式机』」，攻克新型辐射源难关，这一研究有怎样的价值？ - 知乎

自由电子激光可不可以用于半导体光刻？ - 知乎

我国太赫兹源进入自由电子激光时代----中国科学院

最近的新闻

您可能喜欢的文章

imtoken任务下载|最终救赎

imtoken钱包下载注册教程|ewteacher

TP钱包宣布涉嫌洗钱交易被限制 使用教程和最佳

以太坊K网钱包：安全便捷的数字资产管理工具

如何在TP钱包中购买USDT？

如何在TP钱包电脑端导入BSC链？

交易所提USDT到TP钱包，快速安全方便

TP钱包宣布涉嫌洗钱交易被限制使用教程和最佳