一、结构上的荷载可分为下列三类：
1、永久荷载，例如结构自重、土压力、预应力等。
2、可变荷载，例如楼面活荷载、屋面活荷载和积灰荷载、吊车荷载、风荷载、雪荷载等。
3、偶然荷载，例如爆炸力、撞击力等。
地震因为是间接作用在结构上的，被称为地震作用。
二、建筑结构类型随划分标准不同而不同：
按材料可分为：砌体结构，混凝土结构，钢结构，钢和混凝土组合结构，木结构等；
按高度可分为：多层结构，高层结构，超高层结构等。
按结构形式可分为：排架结构，框架结构，剪力墙结构，筒体结构，以及框架和剪力墙、筒体组合成的混合结构等。
建筑结构是建筑工程中至关重要的部分。它承担着支撑建筑物自身重力、抵抗外部荷载以及抗震抗风等重要任务。优秀的建筑结构能够确保建筑物的安全稳固，并为人们提供一个舒适宜居的空间。
天坛建筑结构作为一家专业的建筑结构设计公司，充分认识到建筑结构的重要性。我们深知在建筑项目中，建筑结构不仅关乎建筑物的抗震性能和安全性，还直接影响建筑的造型设计和空间布局。
一项令人印象深刻和可持续的建筑项目，需要一个经过精心设计的建筑结构来支持和维持。我们的专业团队致力于创造出高品质的建筑结构，既能满足功能需求，又能体现出艺术与科技的完美结合。
天坛建筑结构的核心价值是为客户提供创新、可持续、高效和安全的建筑结构解决方案。我们的专家团队将根据项目的需求，结合先进的技术和丰富的经验，为客户量身定制最优化的设计方案。
我们深入研究不同的建筑材料，优化结构的各个方面，以实现最佳的力学性能和结构稳定性。通过运用现代工程技术和创新的设计理念，我们力求设计出富有想象力和符合可持续发展理念的建筑结构。
天坛建筑结构的另一个核心价值是追求卓越和品质。我们坚持严格的技术标准和工艺要求，以确保每个项目的质量。无论是简单的住宅设计还是复杂的商业建筑，我们都保持着对细节的关注和追求卓越的态度。
天坛建筑结构为广泛的建筑项目提供设计、咨询和检测等服务。我们的专业团队具备多样化的项目经验，从住宅、商业到公共建筑，涵盖了各个领域。无论项目规模大小，我们都能提供个性化和全面的解决方案。
我们的服务包括但不限于：
天坛建筑结构凭借卓越的设计能力和专业的服务质量，赢得了众多客户的信任和好评。我们将继续致力于提供最优质的建筑结构方案，为客户创造价值。
天坛建筑结构作为一家致力于创新和卓越的建筑结构设计公司，我们通过深入研究、严谨的技术标准和高品质的服务，为客户提供最理想的建筑结构。在未来的发展中，我们将不断探索新的技术和设计理念，不断提升自身的专业能力和服务水平，与客户共同谱写建筑发展的美好篇章。
别墅，是拥有独门独院的房屋，自己设计图纸，然后寻找施工队按照自己设计的来进行修改，还可以在建筑的过程中随时随地和施工地商量进行图纸的修改，建造出独具特色的房屋，完全满足家中所有人的居住需求，和房地产开发商统一建造的商品房具有很强的修改性和可塑性，经过几十年的不断发展，自建房的建造水平时越来越高，类型也是丰富多样的。很多的农村人选择回家自己盖房，自己设计然后找施工队进行修盖，其实自建房的类型有许多种，在盖房之前一定要详细了解，对比不同类型自建房的优势来选择到底出最适合的那一款房子，类型大多有以下几种，一起来详细了解下吧。
砖泥混合结构
砖泥混合结构一般是指红砖和钢筋水泥作为主要建筑材料，也可以广泛的解释为：石材、混凝土等作为承重墙体，用红砖作为辅助修建工具。
优点
a.建造成本低廉，大部分家庭都可以承受的起；
B．取材广泛，材料的需求量大，购买方便，很多厂家都在生产红砖，很好买到；
c.施工难度低，这种结构的房屋建造对于施工队的要求不高，普通的包工头带领的施工队都可以达到要求完成房屋建造。
缺点
a.抗震能力差，遇到地震等自然灾害很难抵抗过去；
b.红砖的生产不环保，污染环境，不符合国家提倡的环保发展政策。
砖泥混合结构建造的房屋
框架结构
框架结构是由众多梁和柱子作为主框架来承受整体房屋的载重，很多高层的商品房大多都是选用这种作为房屋主要建筑的承重结构。
优点
a.对于分隔的空间方面非常灵活，要求不高，随时可以分隔；
b.对于材料的使用非常节省，对于整体修建下来的成本不高；
c.所使用的框架结构梁、柱等使标准化生产，对于型号的要求不高，以便随时灵活的调整整体架构；
缺点
a.整体框架的节点太过于密集，不利于随时随地的调节节点；
b.使用的柱较多，需要工人进行多次的吊装，节点的安装工作量大，工人的工作量大，工期时间偏长；
c.框架是由梁和柱构成，对于整体房屋的承重力不强，受力特点是垂直方向受力；
剪力墙结构的房屋架构
剪力墙结构
剪力墙结构是由钢筋混凝来代替框架结构中的梁和柱，承担的负重远大于框架结构，对于整体房屋水平方向的承重力大大增强，很多高层建筑一般都选用这种结构。
优点
a.具有非常强的承重效果，适合高层建筑物；
b.抗震效果非常好，承重优势在于水平方向的称重，可以抵挡地震余波；
缺点
a.剪力墙对于空间要求较大，需要密集性和空间狭小的建筑物，不适合拥有大面积活动空间的房屋建造；
b.灵活性差，一旦选用剪力墙开始建造，中间不能修改图纸和空间，对于施工队的要求较高，需要施工队具有相关专业知识；
正在施工的剪力墙结构房屋
轻钢结构
轻钢结构是一种年轻的钢结构建筑，生命时间比较短，但是发展速度，目前被广泛的运用于农业棚、低级住房、体育场地和旅游建筑等领域，是一种新兴的科技房屋结构建造。
优点
a.吸取不同类型的结构优点，具有一定的抗震能力；
b.可以实现房屋活动面积的最大化，对于楼层高度要求不高，楼板之间的厚度降低；
c.对于空气中的温度起到一定程度的保温作用，造价低廉，安装操作易上手，对于专业性要求不高；
缺点
a.使用时期短暂，对于长期使用具有一定程度的威胁性；
b.材料自身的重量轻，适合短期内居住的房屋建造使用；
c.对于轻钢结构的安装要求高，机械化程度高，一般的施工队很难承担轻钢结构的安装工作，需要找专业的施工队。
未施工完成的轻钢结构房屋
木结构
木结构顾名思义是以木头作为主要的构建结构，受目前自然条件的限制，很少有适合的木头能够符合建筑房屋的要求，因此几乎不会有人选木结构房屋建造。
优点：
a.具有很高的耐用性，木材结构稳定，百年不会改变性能可以使用几百年不过时；
b.施工周期短，最大的工作量是修改木材的外形以便符合使用要求；
缺点：
a.木材很难寻找到合适的；
b.对于施工队要求非常高，需要转到专业的木材专家才可以施工。
as为受力主筋到梁截面边缘的距离。通过计算可以确定as的数据：as=混凝土保护层厚度c+二分之一受力主筋的直径d根据砼规范梁（常规单排筋）c=25，主筋取20，则计算as=25+10=35，当为砼板类构件时c=15，则as=15+10=25，符合本题。但是要记住，以上的保护层是02版砼规范的取值，按2010砼规范的规定，该数值还要有所增大。即，保护层的取法不同了。。
根据故宫的建筑结构研究最新成果和相关实践常识，一般来说，故宫建筑属于榫卯结构，以木材、砖瓦为主要建材，以木构架结构为主要的结构方式，由立柱、横梁、顺檩等主要构件建造而成，各个构件之间的结点以榫卯相吻合，构成富有弹性的框架。北京故宫是中国明清两代的皇家宫殿，旧称为紫禁城，位于北京中轴线，是中国古代宫廷建筑精华，是世界现存规模最大、保存最为完整的木质结构古建筑之一。北京故宫被誉为世界五大宫之首（北京故宫、法国凡尔赛宫、英国白金汉宫、美国白宫、俄罗斯克里姆林宫）。
《建筑结构选型》对常用的建筑结构型式如混合结构、刚架结构、剪力墙结构、薄腹梁结构、桁架结构、拱结构、薄壳结构、网架结构、悬索结构、薄膜结构、充气结构等进行了全面的叙述。编写过程中对理论的阐述力求深入浅出，并结合国内许多建筑实例分析比较，使读者对内容容易理解和掌握。
《建筑结构选型》自此至终强调建筑设计及结构设计互相配合的重要性，对两者如何配合才能相得益彰，提出了有益的见解和有效的办法。
《建筑结构选型》可作大学建筑学专业本科生和研究生的教材和教学参考书，也可供从事建筑设计、结构设计等技术人员作参考。
黄山市的建筑结构，现在是高楼层房子，黄山市原来是薇洲府，历史来的是马头墙，马头墙好处是防火，又美光大方。三区四县都是马头墙。
苏联式建筑简称苏式建筑，就是前联式的建筑，典型的苏式建筑有两大特点：首先是左右呈中轴对称，平面规矩，中间高两边低，主楼高耸，回廊宽缓伸展其次是有“三段式”结构，“三段”指的是檐部、墙身、勒脚三个部分。人们所说的“苏式建筑”，更多的是一种宽泛的说法，并没有明确的严格定义。符合以上两个条件的建筑，都可以算是苏式建筑。
之前看了Mahout官方示例 20news 的调用实现；于是想根据示例的流程实现其他例子。网上看到了一个关于天气适不适合打羽毛球的例子。
训练数据：
Day Outlook Temperature Humidity Wind PlayTennis
D1 Sunny Hot High Weak No
D2 Sunny Hot High Strong No
D3 Overcast Hot High Weak Yes
D4 Rain Mild High Weak Yes
D5 Rain Cool Normal Weak Yes
D6 Rain Cool Normal Strong No
D7 Overcast Cool Normal Strong Yes
D8 Sunny Mild High Weak No
D9 Sunny Cool Normal Weak Yes
D10 Rain Mild Normal Weak Yes
D11 Sunny Mild Normal Strong Yes
D12 Overcast Mild High Strong Yes
D13 Overcast Hot Normal Weak Yes
D14 Rain Mild High Strong No
检测数据：
sunny，hot，high，weak
结果：
Yes=》 0.007039
No=》 0.027418
于是使用Java代码调用Mahout的工具类实现分类。
基本思想：
1. 构造分类数据。
2. 使用Mahout工具类进行训练，得到训练模型。
3。将要检测数据转换成vector数据。
4. 分类器对vector数据进行分类。
接下来贴下我的代码实现=》
1. 构造分类数据：
在hdfs主要创建一个文件夹路径 /zhoujainfeng/playtennis/input 并将分类文件夹 no 和 yes 的数据传到hdfs上面。
数据文件格式，如D1文件内容： Sunny Hot High Weak
2. 使用Mahout工具类进行训练，得到训练模型。
3。将要检测数据转换成vector数据。
4. 分类器对vector数据进行分类。
这三步，代码我就一次全贴出来；主要是两个类 PlayTennis1 和 BayesCheckData = =》
package myTesting.bayes;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.util.ToolRunner;
import org.apache.mahout.classifier.naivebayes.training.TrainNaiveBayesJob;
import org.apache.mahout.text.SequenceFilesFromDirectory;
import org.apache.mahout.vectorizer.SparseVectorsFromSequenceFiles;
public class PlayTennis1 {
private static final String WORK_DIR = "hdfs://192.168.9.72:9000/zhoujianfeng/playtennis";
/*
* 测试代码
*/
public static void main(String[] args) {
//将训练数据转换成 vector数据
makeTrainVector();
//产生训练模型
makeModel(false);
//测试检测数据
BayesCheckData.printResult();
}
public static void makeCheckVector(){
//将测试数据转换成序列化文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"testinput";
String output = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();
String[] params = new String[]{"-i",input,"-o",output,"-ow"};
ToolRunner.run(sffd, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("文件序列化失败！");
System.exit(1);
}
//将序列化文件转换成向量文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";
String output = WORK_DIR+Path.SEPARATOR+"tennis-test-vectors";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();
String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};
ToolRunner.run(svfsf, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("序列化文件转换成向量失败！");
System.out.println(2);
}
}
public static void makeTrainVector(){
//将测试数据转换成序列化文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"input";
String output = WORK_DIR+Path.SEPARATOR+"tennis-seq";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();
String[] params = new String[]{"-i",input,"-o",output,"-ow"};
ToolRunner.run(sffd, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("文件序列化失败！");
System.exit(1);
}
//将序列化文件转换成向量文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-seq";
String output = WORK_DIR+Path.SEPARATOR+"tennis-vectors";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();
String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};
ToolRunner.run(svfsf, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("序列化文件转换成向量失败！");
System.out.println(2);
}
}
public static void makeModel(boolean completelyNB){
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-vectors"+Path.SEPARATOR+"tfidf-vectors";
String model = WORK_DIR+Path.SEPARATOR+"model";
String labelindex = WORK_DIR+Path.SEPARATOR+"labelindex";
Path in = new Path(input);
Path out = new Path(model);
Path label = new Path(labelindex);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
if(fs.exists(label)){
//boolean参数是，是否递归删除的意思
fs.delete(label, true);
}
TrainNaiveBayesJob tnbj = new TrainNaiveBayesJob();
String[] params =null;
if(completelyNB){
params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow","-c"};
}else{
params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow"};
}
ToolRunner.run(tnbj, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("生成训练模型失败！");
System.exit(3);
}
}
}
package myTesting.bayes;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.PathFilter;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.mahout.classifier.naivebayes.BayesUtils;
import org.apache.mahout.classifier.naivebayes.NaiveBayesModel;
import org.apache.mahout.classifier.naivebayes.StandardNaiveBayesClassifier;
import org.apache.mahout.common.Pair;
import org.apache.mahout.common.iterator.sequencefile.PathType;
import org.apache.mahout.common.iterator.sequencefile.SequenceFileDirIterable;
import org.apache.mahout.math.RandomAccessSparseVector;
import org.apache.mahout.math.Vector;
import org.apache.mahout.math.Vector.Element;
import org.apache.mahout.vectorizer.TFIDF;
import com.google.common.collect.ConcurrentHashMultiset;
import com.google.common.collect.Multiset;
public class BayesCheckData {
private static StandardNaiveBayesClassifier classifier;
private static Map<String, Integer> dictionary;
private static Map<Integer, Long> documentFrequency;
private static Map<Integer, String> labelIndex;
public void init(Configuration conf){
try {
String modelPath = "/zhoujianfeng/playtennis/model";
String dictionaryPath = "/zhoujianfeng/playtennis/tennis-vectors/dictionary.file-0";
String documentFrequencyPath = "/zhoujianfeng/playtennis/tennis-vectors/df-count";
String labelIndexPath = "/zhoujianfeng/playtennis/labelindex";
dictionary = readDictionnary(conf, new Path(dictionaryPath));
documentFrequency = readDocumentFrequency(conf, new Path(documentFrequencyPath));
labelIndex = BayesUtils.readLabelIndex(conf, new Path(labelIndexPath));
NaiveBayesModel model = NaiveBayesModel.materialize(new Path(modelPath), conf);
classifier = new StandardNaiveBayesClassifier(model);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("检测数据构造成vectors初始化时报错。。。。");
System.exit(4);
}
}
/**
* 加载字典文件，Key: TermValue； Value：TermID
* @param conf
* @param dictionnaryDir
* @return
*/
private static Map<String, Integer> readDictionnary(Configuration conf, Path dictionnaryDir) {
Map<String, Integer> dictionnary = new HashMap<String, Integer>();
PathFilter filter = new PathFilter() {
@Override
public boolean accept(Path path) {
String name = path.getName();
return name.startsWith("dictionary.file");
}
};
for (Pair<Text, IntWritable> pair : new SequenceFileDirIterable<Text, IntWritable>(dictionnaryDir, PathType.LIST, filter, conf)) {
dictionnary.put(pair.getFirst().toString(), pair.getSecond().get());
}
return dictionnary;
}
/**
* 加载df-count目录下TermDoc频率文件，Key: TermID； Value：DocFreq
* @param conf
* @param dictionnaryDir
* @return
*/
private static Map<Integer, Long> readDocumentFrequency(Configuration conf, Path documentFrequencyDir) {
Map<Integer, Long> documentFrequency = new HashMap<Integer, Long>();
PathFilter filter = new PathFilter() {
@Override
public boolean accept(Path path) {
return path.getName().startsWith("part-r");
}
};
for (Pair<IntWritable, LongWritable> pair : new SequenceFileDirIterable<IntWritable, LongWritable>(documentFrequencyDir, PathType.LIST, filter, conf)) {
documentFrequency.put(pair.getFirst().get(), pair.getSecond().get());
}
return documentFrequency;
}
public static String getCheckResult(){
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String classify = "NaN";
BayesCheckData cdv = new BayesCheckData();
cdv.init(conf);
System.out.println("init done...............");
Vector vector = new RandomAccessSparseVector(10000);
TFIDF tfidf = new TFIDF();
//sunny，hot，high，weak
Multiset<String> words = ConcurrentHashMultiset.create();
words.add("sunny",1);
words.add("hot",1);
words.add("high",1);
words.add("weak",1);
int documentCount = documentFrequency.get(-1).intValue(); // key=-1时表示总文档数
for (Multiset.Entry<String> entry : words.entrySet()) {
String word = entry.getElement();
int count = entry.getCount();
Integer wordId = dictionary.get(word); // 需要从dictionary.file-0文件（tf-vector）下得到wordID，
if (StringUtils.isEmpty(wordId.toString())){
continue;
}
if (documentFrequency.get(wordId) == null){
continue;
}
Long freq = documentFrequency.get(wordId);
double tfIdfValue = tfidf.calculate(count, freq.intValue(), 1, documentCount);
vector.setQuick(wordId, tfIdfValue);
}
// 利用贝叶斯算法开始分类,并提取得分最好的分类label
Vector resultVector = classifier.classifyFull(vector);
double bestScore = -Double.MAX_VALUE;
int bestCategoryId = -1;
for(Element element: resultVector.all()) {
int categoryId = element.index();
double score = element.get();
System.out.println("categoryId:"+categoryId+" score:"+score);
if (score > bestScore) {
bestScore = score;
bestCategoryId = categoryId;
}
}
classify = labelIndex.get(bestCategoryId)+"(categoryId="+bestCategoryId+")";
return classify;
}
public static void printResult(){
System.out.println("检测所属类别是："+getCheckResult());
}
}
1. 请介绍一下WebGIS的概念和作用，以及在实际应用中的优势和挑战。
WebGIS是一种基于Web技术的地理信息系统，通过将地理数据和功能以可视化的方式呈现在Web浏览器中，实现地理空间数据的共享和分析。它可以用于地图浏览、空间查询、地理分析等多种应用场景。WebGIS的优势包括易于访问、跨平台、实时更新、可定制性强等，但也面临着数据安全性、性能优化、用户体验等挑战。
2. 请谈谈您在WebGIS开发方面的经验和技能。
我在WebGIS开发方面有丰富的经验和技能。我熟悉常用的WebGIS开发框架和工具，如ArcGIS API for JavaScript、Leaflet、OpenLayers等。我能够使用HTML、CSS和JavaScript等前端技术进行地图展示和交互设计，并能够使用后端技术如Python、Java等进行地理数据处理和分析。我还具备数据库管理和地理空间数据建模的能力，能够设计和优化WebGIS系统的架构。
3. 请描述一下您在以往项目中使用WebGIS解决的具体问题和取得的成果。
在以往的项目中，我使用WebGIS解决了许多具体问题并取得了显著的成果。例如，在一次城市规划项目中，我开发了一个基于WebGIS的交通流量分析系统，帮助规划师们评估不同交通方案的效果。另外，在一次环境监测项目中，我使用WebGIS技术实现了实时的空气质量监测和预警系统，提供了准确的空气质量数据和可视化的分析结果，帮助政府和公众做出相应的决策。
4. 请谈谈您对WebGIS未来发展的看法和期望。
我认为WebGIS在未来会继续发展壮大。随着云计算、大数据和人工智能等技术的不断进步，WebGIS将能够处理更大规模的地理数据、提供更丰富的地理分析功能，并与其他领域的技术进行深度融合。我期望未来的WebGIS能够更加智能化、个性化，为用户提供更好的地理信息服务，助力各行各业的决策和发展。
