설계품질검토 대상법규   |   조항단위 법규   |   문장단위 법규   |   KBimCode-Assess 연동모듈   |   KBimCode DB   |   주어부 - 객체,속성 DB   |   서술부 - 함수 DB   |   관계부 - 문장관계   |   룰셋생성모듈   |  
(2025-06-28 기준) 설계품질검토용 건축법 및 관련법규 - KBIMCode (문장단위)
      KBIMCode - KBimAssess Python Code     KBIMCode - 체크리스트 단위     KBIMCode - 조항단위
  ◁prev 1   2   3   next▷  
2 / 3 page Total 2500 / 4000 records
Select
ALL
None 		#
 Law
 Jo
 JO Name
 HANG
 HO
 MOK
 Text
 Search!
1
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 18조 1 항

①영 제52조의 규정에 의하여 건축물의 최하층에 있는 거실바닥의 높이는 지표면으로부터 45센티미터 이상으로 하여야 한다. 다만, 지표면을 콘크리트바닥으로 설치하는 등 방습을 위한 조치를 하는 경우에는 그러하지 아니하다. 





// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 18조 (거실등의 방습) 1항





Check(REFB_18_1){

IF !CS THEN KS}







KS{

 getObjectHeight(getFloor(BottomFloor))>=45CM

}





CS {

 isObjectProperty(Ground.Surface.isDampProof)=TRUE 

} 









// 변환중

Check():

KS{

    myFloors = getFloor(BottomFloor)
    for myFloor in myFloors:
        if getObjectHeight(myFloor)>= 4500:
            myFloor.SUCCESS("BottomFloor elevation:"+ str(getObjectHeight(myFloor))  + 'mm')
        else:
            myFloor.Fail("BottomFloor elevation:"+ str(getObjectHeight(myFloor))  + 'mm')


}


CS{

    isObjectProperty(Ground.Surface.isDampProof)=TRUE

}


getobjectheight(str objname):
    objheight = root.select(obj).height().unit('m').number()
    return objheight

def getfloor(floor):
    if type(floor) == int:
        floornum = floor
        myfloor = root.select('slab')
        myfloor = myfloor.select(floornum)
        return myfloor

    elif type(floor) == str:
        floorname = floor
        myfloor = root.select('slab')
        myfloor = myfloor.select(floorname)
        return myfloor 


2
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 18조 2 항

②영 제52조에 따라 다음 각 호의 어느 하나에 해당하는 욕실 또는 조리장의 바닥과 그 바닥으로부터 높이 1미터까지의 안벽의 마감은 이를 내수재료로 하여야 한다. <개정 2010.4.7> 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 18조 (거실등의 방습) 2항





Check(REFB_18_2){

  IF CS THEN KS

}



CS{

 getResult(REFB_18_2_1)=TRUE

 OR getResult(REFB_18_2_2)=TRUE

}



KS{

  Finish myFinish{

    getObjectDistance(Finish,floor)<=1



  isObjectPropert(InteriorFinish.Material.waterResistance)=TRUE

} 





Python Code 변환 예정


3
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 19조 1 항

①영 제53조의 규정에 의하여 건축물에 설치하는 경계벽 및 간막이벽은 내화구조로 하고, 지붕밑 또는 바로 윗층의 바닥판까지 닿게 하여야 한다. 





check(REFB_19_1){

     KS

}



KS{

Wall myWall{
   isObjectProperty(Wall.isPartitionWall) = TRUE
}
Floor myFloor{
hasObject(Floor, myWall)
}
   isFireResistantStructure(myWall)=TRUE
(isConnectedTo(myWall, Roof.BottomSurface) = TRUE
 OR isCOnnectedTo(myWall, myFloor.UpperFloor.FloorSlab) = TRUE)

} 









def Check():
    for building in SELECT('building'):
        bldg_use = building.SELECT('building type').STRING()
        sub_use = building.SELECT('prop', '세부용도').STRING()
        space_codes = []
        
        if bldg_use == '단독주택' and sub_use == '다가구주택':
            space_codes = ['가구'] #가구
        elif (bldg_use == '공동주택' and sub_use != '기숙사') or (bldg_use == '노유자시설' and sub_use == '노인복지주택'):
            space_codes = ['33237'] #세대
        elif bldg_use == '공동주택' and sub_use == '기숙사':
            space_codes = ['33230'] #침실
        elif bldg_use == '의료시설':
            space_codes = ['34310'] #병실
        elif bldg_use == '교육연구시설' and sub_use == '학교':
            space_codes = ['34404', '34409']    #교실
        elif bldg_use == '숙박시설':
            space_codes = ['33201'] #객실
        elif (bldg_use == '제2종 근린생활시설' and sub_use == '다중생활시설') or (bldg_use == '노유자시설' and sub_use == '노인요양시설'):
            space_codes = ['호실'] #호실
        else:
            return

        for storey in building.SELECT('storey'):
            walls_list = []
            for space in storey.SELECT('space'):
                code = space.SELECT('class code').STRING()
                if code in space_codes:
                    walls_list.append(space.SELECT('wall'))
            
            n = len(walls_list)
            for i, walls in enumerate(walls_list):
                if i == n-1:
                    break
                for j, walls2 in enumerate(walls_list):
                    if i >= j:
                        continue
                    for wall in walls:
                        if wall.SELECT('isexterior').BOOL():
                            continue
                        id = wall.SELECT('element id').STRING()
                        for wall2 in walls2:
                            if wall2.SELECT('isexterior').BOOL():
                                continue
                            id2 = wall2.SELECT('element id').STRING()
                            if id == id2:
                                if wall.SELECT('prop', '경계벽').BOOL() == False:
                                    wall.ERROR('해당 벽은 경계벽이어야 합니다.')
                                else:
                                    if wall.SELECT('prop', '내화구조').BOOL() == False:
                                        wall.ERROR('경계벽은 내화구조이어야 합니다.')
                                    else:
                                        if wall.SELECT('top touched').BOOL():
                                            wall.SUCCESS('경계벽 조건에 부합합니다.')
                                        else:
                                            wall.ERROR('경계벽 상단이 슬라브와 닿지 않습니다.')
                                break 


4
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 25조 1 항 1호

1. 거실의 바닥면적이 50제곱미터 이상인 층에는 직통계단외에 피난층 또는 지상으로 통하는 비상탈출구 및 환기통을 설치할 것. 다만, 직통계단이 2개소 이상 설치되어 있는 경우에는 그러하지 아니하다. 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 1항 1호

check(REFB_25_1_1){

	IF !(CS) THEN KS

}



KS{

	Floor myFloor1{

		hasSpace(Floor,Room) = TRUE

		getTotalArea(Room) >= 50 m2

	}



	Floor myFloor2{

		isObjectProperty(Floor.isEscape) = TRUE

	}



	Door myDoor{

		isObjectProperty(Door.functionType) = "Emergency"

		(isDirectlyAccessible(Door, myFloor2) = TRUE

		OR isDirectlyAccessible(Door, Ground) = TRUE)

	}

	

	hasSpace(myFloor1, myDoor)

	OR (hasSpace(myFloor1, VentilatorPipe) = TRUE

	(isDirectlyAccessible(VentilatorPipe, myFloor2) = TRUE

	OR isDirectlyAccessible(VentilatorPipe, Ground) = TRUE))

}



CS{

	Floor myFloor1{

		hasSpace(Floor,Room) = TRUE

		getTotalArea(Room) >= 50 m2

	}



	Stair myStair{

		isObjectProperty(Stair.isDirect) = TRUE

		hasSpace(myFloor1, Stair) = TRUE

	}



	getObjectCount(myStair) >= 2

} 





Python Code 변환 예정


5
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 25조 1 항 1의2호

1의2. 제2종근린생활시설 중 공연장·단란주점·당구장·노래연습장, 문화 및 집회시설중 예식장·공연장, 수련시설 중 생활권수련시설·자연권수련시설, 숙박시설중 여관·여인숙, 위락시설중 단란주점·유흥주점 또는 「다중이용업소의 안전관리에 관한 특별법 시행령」 제2조에 따른 다중이용업의 용도에 쓰이는 층으로서 그 층의 거실의 바닥면적의 합계가 50제곱미터 이상인 건축물에는 직통계단을 2개소 이상 설치할 것 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 1항 1의2호
check(REFB_25_1_1-2){
	IF CS THEN KS
}

CS{
	(getBuildingUsage() = "ClassIINeighborhoodLivingFacility.PerformanceHall"
	OR getBuildingUsage() = "ClassIINeighborhoodLivingFacility.Pubs"
	OR getBuildingUsage() = "ClassIINeighborhoodLivingFacility.BilliardRoom"
	OR getBuildingUsage() = "ClassIINeighborhoodLivingFacility.Karaoke"
	OR getBuildingUsage() = "CulturalAndAssemblyFacility.WeddingHall"
	OR getBuildingUsage() = "CulturalAndAssemblyFacility.PerformanceHall"
	OR getBuildingUsage() = "TrainingFacility.TrainingFacilityInLivingZone"
	OR getBuildingUsage() = "TrainingFacility.??LivingZone"
	OR getBuildingUsage() = "LodgingFacility.Inn"
	OR getBuildingUsage() = "AmusementFacility.Pubs"
	OR getBuildingUsage() = "AmusementFacility.Tavern"
	OR getResult(ERSASP_2) = TRUE)

	getTotalFloorArea(Room) >= 50 m2
}

KS{
	Stair myStair{
		isObjectProperty(Stair.isDirect) = TRUE
	}

	getObjectCount(myStair) >= 2
} 





Python Code 변환 예정


6
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 25조 1 항 2호

2. 바닥면적이 1천제곱미터이상인 층에는 피난층 또는 지상으로 통하는 직통계단을 영 제46조의 규정에 의한 방화구획으로 구획되는 각 부분마다 1개소 이상 설치하되, 이를 피난계단 또는 특별피난계단의 구조로 할 것 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 1항 2호

check(REFB_25_1_2){

	IF CS THEN KS

}



CS{

	getTotalFloorArea(Floor) >= 1000 m2

}



KS{

	Floor myFloor{

		isObjectProperty(Floor.isEscape) = TRUE

	}



	Stair myStair{

		isObjectProperty(Stair.isDirect) = TRUE



		(isDirectlyAccessible(Stair, Ground) = TRUE

		OR isDirectlyAccessible(Stair, myFloor) = TRUE)



		(isObjectProperty(Stair.isEscape) = TRUE

		OR isObjectProperty(Stair.isSpecialEscape) = TRUE)

	}



	Zone myZone{

		isObjectProperty(Zone.isFirePartition) = TRUE

	}



	hasSpace(myZone, myStair) = TRUE

} 





Python Code 변환 예정


7
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 25조 1 항 3호

3. 거실의 바닥면적의 합계가 1천제곱미터 이상인 층에는 환기설비를 설치할 것 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 1항 3호
check(REFB_25_1_3){
	getTotalFloorArea(Room) >= 1000 m2
	isExist(VentilationSystem) = TRUE
} 





Python Code 변환 예정


8
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 25조 1 항 4호

4. 지하층의 바닥면적이 300제곱미터 이상인 층에는 식수공급을 위한 급수전을 1개소이상 설치할 것 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 1항 4호

check(REFB_25_1_4){

Floor myFloor{
Floor.number < 0
}
	getTotalFloorArea(myFloor) >= 300 m2

	getObjectCount(Hydrant) >= 1

} 





Python Code 변환 예정


9
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 25조 2 항 1호

1. 비상탈출구의 유효너비는 0.75미터 이상으로 하고, 유효높이는 1.5미터 이상으로 할 것 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 2항 1호

check(REFB_25_2_1){

Door myDoor{
Door.functionType = "Emergency"
Door.Floor.number < 0
}
	getObjectWidth(myDoor, a) >= 0.75 m 

	getObjectHeight(myDoor) >= 1.5 m

} 





Python Code 변환 예정


10
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 25조 2 항 3호

3. 비상탈출구는 출입구로부터 3미터 이상 떨어진 곳에 설치할 것 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 2항 3호

check(REFB_25_2_3){

Door myDoor{
Door.functionType = "Emergency"
Door.Floor.number < 0
}
	getSpaceDistance(myDoor, Door) >= 3 m 

} 





Python Code 변환 예정


11
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 25조 2 항 4호

4. 지하층의 바닥으로부터 비상탈출구의 아랫부분까지의 높이가 1.2미터 이상이 되는 경우에는 벽체에 발판의 너비가 20센티미터 이상인 사다리를 설치할 것 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 2항 4호

check(REFB_25_2_4){

	IF CS THEN KS

}



CS{
Door myDoor{
Door.functionType = "Emergency"
Door.Floor.number < 0
}
Floor myFloor{
Floor.number < 0 
}
	getObjectVerticalDistance(myFloor, myDoor) >= 1.2 m

}



KS{

	isConnectedTo(Wall, Ladder) = TRUE

	getObjectProperty(Ladder.footholdWidth) >= 20 cm

} 





Python Code 변환 예정


12
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 25조 2 항 5호

5. 비상탈출구는 피난층 또는 지상으로 통하는 복도나 직통계단에 직접 접하거나 통로 등으로 연결될 수 있도록 설치하여야 하며, 피난층 또는 지상으로 통하는 복도나 직통계단까지 이르는 피난통로의 유효너비는 0.75미터 이상으로 하고, 피난통로의 실내에 접하는 부분의 마감과 그 바탕은 불연재료로 할 것 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 2항 5호

check(REFB_25_2_5){

	

	Floor myFloor(

		isObjectProperty(Floor.isEscape) = TRUE

	)



	Stair myStair{

		isObjectProperty(Stair.isDirect) = TRUE

		(isDirectlyAccessible(Stair, Ground) = TRUE

		OR isDirectlyAccessible(Stair, myFloor) = TRUE)

	}



	Corridor myCorridor{

		isDirectlyAccessible(Corridor, myFloor) = TRUE

		OR isDirectlyAccessible(Corridor, Ground) = TRUE

	}

Door myDoor{
Door.functionType = "Emergency"
Door.Floor.number < 0
}

	(isDirectlyAccessible(myDoor, myStair) = TRUE

	OR isDirectlyAccessible(myDoor, myCorridor) = TRUE

	OR isGoThrough(myDoor, Corridor, myStair) = TRUE

	OR isGoThrough(myDoor, Corridor, myCorridor) = TRUE)

Passage myPassage{
isObjectProperty(Passage.isEscape) = TRUE
}

	getSpaceWidth(myPassage) >= 0.75 m



	isObjectProperty(myPassage.InteriorFinish.Material.nonCombustibility) = TRUE

} 





Python Code 변환 예정


13
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 25조 2 항 7호

7. 비상탈출구의 유도등과 피난통로의 비상조명등의 설치는 소방법령이 정하는 바에 의할 것 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 25조 (지하층의 구조) 2항 7호

check(REFB_25_2_7){	
Door myDoor{
Door.functionType = "Emergency"
Door.Floor.number < 0
}

Light myLight{
isObjectProperty(Light.isEmergency) = TRUE
}

Passage myPassage{
isObjectProperty(Passage.isEscape) = TRUE
}

	hasElement(myDoor, LeadingLight) = TRUE

	hasElement(myPassage, myLight) = TRUE

} 





Python Code 변환 예정


14
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 24조 2 항 1호

1. 영 제61조제1항 각 호에 따른 용도에 쓰이는 거실 등을 지하층 또는 지하의 공작물에 설치한 경우의 그 거실(출입문 및 문틀을 포함한다) 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 24조 (건축물의 마감재료) 2항1호
check(REFB_24_2_1){
       KS
}

KS{

  Building myBuilding{
     getResult(EDBA_61_1_1)=TRUE
      OR getResult(EDBA_61_1_2)=TRUE
      OR getResult(EDBA_61_1_3)=TRUE
      OR getResult(EDBA_61_1_4)=TRUE
      OR getResult(EDBA_61_1_5)=TRUE
      OR getResult(EDBA_61_1_6)=TRUE
      OR getResult(EDBA_61_1_7)=TRUE
  }
     
  Room myRoom{
      getSpace(myBuilding.Room)
  }
    getFloorNumber(myRoom)<0 

} 





Python Code 변환 예정


15
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 8조의2조 1 항

① 영 제34조제3항 및 제4항에 따라 설치하는 피난안전구역(이하 "피난안전구역"이라 한다)은 해당 건축물의 1개층을 대피공간으로 하며, 대피에 장애가 되지 아니하는 범위에서 기계실, 보일러실, 전기실 등 건축설비를 설치하기 위한 공간과 같은 층에 설치할 수 있다. 이 경우 피난안전구역은 건축설비가 설치되는 공간과 내화구조로 구획하여야 한다. <개정 2012.1.6> 





// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 8조의2 (피난안전구역의 설치기준) 1항
check(REFB_8-2_1){
	KS1 AND IF CS THEN KS2
}

	Zone myZone{
		isObjectProperty(Zone.isEgressSafetyZone) = TRUE
	}

	Space mySpace{
		hasSpace(Space, FacilitiesOfABuilding)
	}

	Structure myStructure{
		isObjectProperty(Space.isfireResistantStructure) = TRUE
	}

KS1{
 	BSC = getBuildingStoriesCount()
	getFloorNumber(myZone) <= BSC
}

CS{
	getFloorNumber(mySpace) = getFloorNumber(myZone)
}

KS2{
	isPartitioned(myZone, myStructure, mySpace) = TRUE
}
 





Python Code 변환 예정


16
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 9조 2 항 3호 가 목

가. 건축물의 내부와 계단실은 노대를 통하여 연결하거나 외부를 향하여 열 수 있는 면적 1제곱미터 이상인 창문(바닥으로부터 1미터 이상의 높이에 설치한 것에 한한다) 또는 「건축물의 설비기준 등에 관한 규칙」 제14조의 규정에 적합한 구조의 배연설비가 있는 면적 3제곱미터 이상인 부속실을 통하여 연결할 것 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 3호 가목

check (REFB_9_2_3_1){

CS THEN KS 

}

CS {

isExist(Stair.Space) = TRUE

}

KS {

	Window myWindow {

		getObjectProperty(Window.area)>= 1 m2

		isObjectProperty(Window.isExternalDirection) = TRUE

		 getElementDistance(Window, FloorSlab, a)>=1m



}

	SmokeExhaustionSystem mySmokeExhaustionSystem {

		getElement(SmokeExhaustionSystem)

		getResult(RFB_14)=TRUE

}



	Space mySpace1{

		getSpace(“Balcony”)

}

	Space mySpace2{

		isExternal(Space)=FALSE

}

	Space mySpace3{

		getSpace(“AncillaryRoom”)

		getFloorArea(Space.Floor, ) >= 3㎡

		hasElement(Space,mySmokeExhaustionSystem) = TRUE

		hasElement(Space,myWindow) = TRUE

}

isGoThrough(mySpace2,Stair.Space, ,mySpace1)

OR isGoThrough(mySpace2,Stair.Space, ,mySpace3) 





Python Code 변환 예정


17
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 15조 7 항

⑦ 제1항 및 제2항에도 불구하고 영 제34조제4항 후단에 따라 피난층 또는 지상으로 통하는 직통계단을 설치하는 경우 계단 및 계단참의 너비는 다음 각 호의 구분에 따른 기준에 적합하여야 한다. <신설 2012.1.6> 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조 (계단의 설치기준) 7항
check(REFP_15_7){
     IF CS THEN KS
}

CS{

Floor myFloor{
isObjectProperty(Floor.isEscape)=TRUE
}
      isAccessible(Stair,myFloor) 
      OR isAccessible(Stair,Ground)
}

KS{
      getResult(REFP_15_7_1)
      OR getResult(REFP_15_7_2)
} 









min_stair_width = 1.5

def Check():
    for building in SELECT('building'):
        bldg_type = building.SELECT('building type').STRING()
        sub_type = building.SELECT('prop', '세부용도').STRING()

        if bldg_type is "공통주택":
            min_stair_width = 1.2
        else :
            min_stair_width = 1.5

        d_stairs = building.SELECT('direct stair')

        for d_stair in d_stairs:
            s_stair_w = d_stair.SELECT('width').Unit(m)

            breker = True
            for stair_stories in  d_stair.SELECT('storey'):
                if stair_stories.SELECT('is evacuation storey').BOOL() is True :
                    break
                elif stair_stories.SELECT('level') is "Ground" :
                    break
                else:
                    breaker = False
            if breaker is True:
                d_stair.SUCCESS('해당계단은 피난층이나 지상으로 통하는 직통계단이 아닙니다.')
                break
            if d_stair_w >= min_stair_width:
                d_stair.SUCCESS('계단의너비()' + d_stair_w + ')가 '  + '>=' + min_stair_width)
            else:
                d_stair.ERROR('계단의너비()' + d_stair_w + ')가 '  + '<' + min_stair_width)                
                
                 


18
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 17조 1 항

①영 제51조에 따라 채광을 위하여 거실에 설치하는 창문등의 면적은 그 거실의 바닥면적의 10분의 1 이상이어야 한다. 다만, 거실의 용도에 따라 별표 1의3에 따라 조도 이상의 조명장치를 설치하는 경우에는 그러하지 아니하다. <개정 2000.6.3, 2010.4.7, 2012.1.6> 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 17조 (채광 및 환기를 위한 창문등) 1항

check(REFB_17_1){

	IF (getResult(REFB_*_1-3) = FALSE) THEN KS

}



KS{ 

	Window myWindow{

		hasElement(Room, myWindow) = TRUE

	}

	

	getElementArea(myWindow) >= getFloorArea(Room)*0.1

} 





Python Code 변환 예정


19
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 15조의2조 1 항

①영 제48조의 규정에 의하여 건축물에 설치하는 복도의 유효너비는 다음 표와 같이 하여야 한다 img30607976 ┌───────────────┬────────────┬──────┐ │구분 │양옆에 거실이 있는 복도 │기타의 복도 │ ├───────────────┼────────────┼──────┤ │유치원ㆍ초등학교 │2.4미터 이상 │1.8미터 이상│ │중학교ㆍ고등학교 │ │ │ ├───────────────┼────────────┼──────┤ │공동주택ㆍ오피스텔 │1.8미터 이상 │1.2미터 이상│ ├───────────────┼────────────┼──────┤ │당해 층 거실의 바닥면적 │1.5미터 이상(의료시설의 │1.2미터 이상│ │합계가 200제곱미터 이상인 경우│복도 1.8미터 이상) │ │ └───────────────┴────────────┴──────┘ 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조의2 (복도의 너비 및 설치기준) 1항
Check(EDBA_15-2_1){
    IF getBuildingUsage()="Kindergarten"
       OR getBuildingUsage()="ElementarySchool"
       OR getBuildingUsage()="MiddleSchool"
       OR getBuildingUsage()="HightSchool"
       THEN IF isExternal(Corridor)=FALSE
             THEN getObjectProperty(Corridor.effectiveWidth)>2.4 m   
     ELSE THEN  getObjectProperty(Corridor.effectiveWidth)>1.8 m
            END IF
     END IF  


     IF getBuildingUsage()="MultiUnitHouse"
       OR getBuildingUsage()="Officetel"
       THEN IF isExternal(Corridor)=FALSE
             THEN getObjectProperty(Corridor.effectiveWidth)>1.8 m
            ELSE THEN  getObjectProperty(Corridor.effectiveWidth)>1.2 m
            END IF
     END IF  


     IF getTotalFloorArea(Corridor.Floor.Room)>200 m2 
     THEN IF isExternal(Corridor)=FALSE
             THEN IF getBuildingUsage()="MedicalFacilities"
                       THEN getObjectProperty(Corridor.effectiveWidth)>1.8 m
                  ELSE THEN getObjectProperty(Corridor.effectiveWidth)>1.5 m
                  END IF
          ELSE THEN  getObjectProperty(Corridor.effectiveWidth)>1.2 m
          END IF
     END IF  
} 





Python Code 변환 예정


20
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 3조 4호 가 목

가. 철근콘크리트조 또는 철골철근콘크리트조로서 두께가 10센티미터 이상인 것 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 3조 (내화구조) 4호 가목

Check (REFB_3_0_4_가){
	KS
}
KS{
	getObjectProperty(Wall.Structure.materialType) = "ReinforcedConcrete" OR "SteelFramedReinforcedConcrete"
	getObjectThickness(FloorSlab.Structure) >= 10cm
} 





Python Code 변환 예정


21
 		건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 조 1(표) 항

표 





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 15조의2 (복도의 너비 및 설치기준) 1항

Check(REFB_15-2_1){
            KS
}

KS{

  IF (Building.usage="Kindergarten"
      OR Building.usage="ElementarySchool"
      OR Building.usage="MiddleAndHighSchool" )
      IF(isAdjacent(Corridor, Room)=True)
         THEN   Corridor.width>=2.4 m
            ELSE THEN  Corridor.width>=1.8 m                 
      END IF 

  ELSE IF( Building.usage="MultiUnitHouse"
           OR Building.usage="Officetels" )
         IF( isAdjacent(Corridor, Room)=True)
            TEHN  Corridor.width>=1.8 m
         ELSE THEN Corridor.width>=1.2 m
         END IF
  ELSE IF( Floor.One.Room.area > 200 m2) 
          IF(isAdjacent(Corridor, Room)=True)
             TEHN IF (Building.usage="MedicalFacility")
                   THEN Corridor.width>=1.8 m
             ELSE THEN  Corridor.width>=1.5 m
             
          ELSE THEN Corridor.width>=1.2 m
          END IF
  END IF

}














 





Python Code 변환 예정


22
 		건축법 제 47조 1 항

제47조(건축선에 따른 건축제한) ① 건축물과 담장은 건축선의 수직면(垂直面)을 넘어서는 아니 된다. 다만, 지표(地表) 아래 부분은 그러하지 아니하다. 





//건축법 47조 (건축선에 따른 건축제한) 1항

Check(BA_47_1){
      KS
}

KS{
    Floor myFloor{
        Floor.number>0
    }
     isOverBldAlignment(myFloor)=False
} 





Python Code 변환 예정


23
 		건축법 제 47조 2 항

② 도로면으로부터 높이 4.5미터 이하에 있는 출입구, 창문, 그 밖에 이와 유사한 구조물은 열고 닫을 때 건축선의 수직면을 넘지 아니하는 구조로 하여야 한다. 





//건축법 47조 (건축선에 따른 건축제한) 2항

Check(BA_47_2){
     KS
}

KS{
    Floor myFloor{
          getVerticleDistance(Floor, "도로면" )<=4.5
    }
    isOverBldAlignment(myFloor, 1)=False
} 





Python Code 변환 예정


24
 		건축법 제 53조

제53조(지하층) 건축물에 설치하는 지하층의 구조 및 설비는 국토교통부령으로 정하는 기준에 맞게 하여야 한다. <개정 2013.3.23> 





Check(BA_53){

IF (CS) THEN KS END IF

}



CS{

   Space.Floor.number<0 ;

}



KS{

   getResult(REFB_25_1)=True

} 





Python Code 변환 예정


25
 		건축법 제 64조 1 항

① 건축주는 6층 이상으로서 연면적이 2천제곱미터 이상인 건축물(대통령령으로 정하는 건축물은 제외한다)을 건축하려면 승강기를 설치하여야 한다. 이 경우 승강기의 규모 및 구조는 국토교통부령으로 정한다. <개정 2013.3.23> 





//건축법 64조 (승강기) 1항
check(BA_64_1){
   IF CS THEN KS
}

CS{ 
   getBuildingStoriesCount() >= 6    
   getGrossFloorArea()>= 2000 m2
}

KS{
	isExist(Elevator) = TRUE
        getResult(RFB_5)=TRUE
        getResult(RFB_6)=TRUE
        getResult(REFB_29_1)=True
} 





Python Code 변환 예정


26
 		건축법 시행령 제 36조 1호

1. 제2종 근린생활시설 중 공연장(해당 용도로 쓰는 바닥면적의 합계가 300제곱미터 이상인 경우만 해당한다), 문화 및 집회시설 중 공연장이나 위락시설 중 주점영업의 용도로 쓰는 층으로서 그 층 거실의 바닥면적의 합계가 300제곱미터 이상인 것 





//건축법 시행령 36조 (옥외 피난계단의 설치) 1호

Check(EDBA_36_0_1){
        KS
}

KS{
      Floor myFloor{
          getFloorUsage()="CulturalAndAssemblyFacility.PerformanceHall"
          OR getFloorUsage()="AmusementFacility.BarBusiness"
      }

      FloorSlab myFloorSlab{
           getObjectUsage(FloorSlab)="NeighborhoodLivingFacility.PerformanceHall"
      }


      getFloorUsage()="NeighborhoodLivingFacility.PerformanceHall"
      getObjectArea(myFloorSlab)>=300 m2
      OR getTotalFloorArea(myFloor.Room)>300 m2

     
} 





Python Code 변환 예정


27
 		건축법 시행령 제 36조 2호

2. 문화 및 집회시설 중 집회장의 용도로 쓰는 층으로서 그 층 거실의 바닥면적의 합계가 1천 제곱미터 이상인 것 





//건축법 시행령 36조 (옥외 피난계단의 설치) 2호

Check(EDBA_36_0_2){
            KS
}

KS{   
      Floor myFloor{
           getFloorUsage()="CulturalAndAssemblyFacility.AssemblyHall"
      }

      getTotalFloorArea(myFloor.Room)>=1000 m2


} 





Python Code 변환 예정


28
 		건축법 시행령 제 38조 1호

1. 제2종 근린생활시설 중 공연장ㆍ종교집회장(해당 용도로 쓰는 바닥면적의 합계가 각각 300제곱미터 이상인 경우만 해당한다) 





//건축법 시행령 38조(관람석 등으로부터의 출구 설치) 1호
Check(EDBA_38_0_1){
     (getBuildingUsage() = "ClassIINeighborhoodLivingFacility.performancehall"
     OR getBuildingUsage() = "ClassIINeighborhoodLivingFacility.ReligiousAssemblyFacility")

     Space mySpace {
          getSpaceUsage(Space) = "ClassIINeighborhoodLivingFacility.performancehall"
          OR getSpaceUsage(Space) = "ClassIINeighborhoodLivingFacility.ReligiousAssemblyFacility"
     }

     getTotalFloorArea(mySpace) > 300
}

 









identified_space_codes =['33703', '33708']
min_area = 300
min_door_width = 1.5
min_door_count = 2
identified_space_codes_label ='해당 공간 명칭'
min_area_label = '바닥면적이 다음 미만일 경우 제외(m2)'
min_door_width_label = '출구 유효너비'
min_door_count_label = '유효너비 이상 최소 출구 개수'

def Check():
    for space in SELECT('space'):
        name = space.SELECT('name').STRING()
        code = space.SELECT('class code').STRING()

        if not code in identified_space_codes:
            continue
                
        area = space.SELECT('area').UNIT('m2').NUMBER()
        if area >= min_area:
            exitCnt = 0
            door_width_sum = 0
            inward_exist = False

            for door in space.SELECT('space door'):
                if door.SELECT('is inward', space).BOOL() == False:
                    door_width = door.SELECT('width').UNIT('m2').NUMBER()
                    if door_width >= min_door_width:
                        exitCnt += 1
                        door_width_sum += door_width
                else:
                    door.ERROR('안여닫이 출구')
                    inward_exist = True
                    
            if inward_exist == True:
                continue

            if exitCnt >= min_door_count:
                if door_width_sum >= (area / 100) * 0.6:
                    space.SUCCESS(name)
                else:
                    space.ERROR(name + ', 출구유효너비 합: ' + str(door_width_sum) + 'm, 바닥면적: ' + str(area) + 'm2')
            else:
                space.ERROR(name + ', 출구 수 : ' + str(exitCnt) + '( < ' + str(min_door_count) + ')')
        else:
            space.SUCCESS('바닥면적:' + str(area) + '㎡ ( < ' + str(min_area) + '㎡)') 


29
 		건축법 시행령 제 52조 1호

1. 건축물의 최하층에 있는 거실(바닥이 목조인 경우만 해당한다) 





//건축법 시행령 52조 (거실 등의 방습) 1호

Check(EDBA_52_0_1){

CS}



CS{

hasObject(BottomFloor, Room) = TRUE
 getObjectProperty(FloorSlab.Structure.materialType) = "Timber"

} 





Python Code 변환 예정


30
 		건축법 시행령 제 58조 1호

1. 연면적 30제곱미터 미만인 단층 부속건축물로서 외벽 및 처마면이 내화구조 또는 불연재료로 된 것 





check(EDBA_58_0_1){

	getGrossFloorArea() < 30m2;

	isObjectProperty(Building.isAttachedBuilding) = TRUE

	getBuildingStoriesCount() = 1;

	isFireResistantStructure(MainStructure) = TRUE

	OR isFireResistantStructure(ExternalWall) = TRUE;

} 





Python Code 변환 예정


31
 		건축법 시행령 제 61조 1 항 5호

5. 5층 이상인 층 거실의 바닥면적의 합계가 500제곱미터 이상인 건축물 





Check(EDBA_61_1_5){
KS}

Floor myFloor {
Floor.number>=5
}

KS{
getTotalfloorArea(myFloor)>=500 m2
} 





Python Code 변환 예정


32
 		건축법 시행령 제 61조 1 항 7호

7. 창고로 쓰이는 바닥면적 3천 제곱미터(스프링클러나 그 밖에 이와 비슷한 자동식 소화설비를 설치한 경우에는 6천 제곱미터) 이상인 건축물 





//건축법 시행령 61조 (건축물의 마감재료) 1항7호

Check(EDBA_61_1_7){
  KS
}

KS{

  Floor myFloor{
      getObjectUsage(Floor)="Storage"

  }
   IF (isExist(SprinklerSystem)=TRUE
       OR isExist(ExtinguishingSystem.isAutomatic)=TRUE ) 

   THEN  getFloorArea(myFloor)>6000 m2
   ELSE THEN  getFloorArea(myFloor)>3000 m2
} 





Python Code 변환 예정


33
 		건축법 시행령 제 51조 2 항 1호 가 목

가. 제2종 근린생활시설 중 공연장, 종교집회장, 인터넷컴퓨터게임시설제공업소 및 다중생활시설(공연장, 종교집회장 및 인터넷컴퓨터게임시설제공업소는 해당 용도로 쓰는 바닥면적의 합계가 각각 300제곱미터 이상인 경우만 해당한다) 





//건축법 시행령 51조 (거실의 채광 등) 2항 1호
Check(EDBA_51_2_1){
	KS1 OR KS2
}	
KS1{
	Space mySpace{
		getBuildingUsage() = "ClassIINeighborhoodLivingFacility.PerformanceHall"
		OR getBuildingUsage() = "ClassIINeighborhoodLivingFacility.ReligiousAssemblyFacility"
		OR getBuildingUsage() = "ClassIINeighborhoodLivingFacility.FacilityForProvidingInternetComputerGameService"	
	}

	getFloorArea(mySpace) >= 300 m2
}

KS2{
	getBuildingUsage() = "ClassIINeighborhoodLivingFacility.CommunalLivingFacilities"
}
 





Python Code 변환 예정


34
 		건축법 시행령 제 61조 1 항 1호

1. 단독주택 중 다중주택·다가구주택 





Check(EDBA_61_1_1){

IF CS THEN KS

}



Floor myfloor1 {  

isObjectProperty(ClassIINeighborhoodLivingFacility.PerformanceHall)=TRUE

OR isObjectProperty(ClassIINeighborhoodLivingFacility.ReligiousAssemblyFacility)=TRUE

OR isObjectProperty(ClassIINeighborhoodLivingFacility.ReligiousAssemblyFacility)=TRUE

AND getFloorArea()>=300

}



CS{

isExist(myfloor1)=TRUE

OR(getBuildingUsage()= "CulturalAndAssemblyFacility"

AND getBuildingUsage()!= "CulturalAndAssemblyFacility.WeddingHall")

OR getBuildingUsage()= "ReligiousFacility"

OR getBuildingUsage()= "CommercialFacility"

OR getBuildingUsage()= "TransportationFacility"

OR (getBuildingUsage()= "AmusementFacility"

OR (getBuildingUsage()!= "AmusementFacility.Pubs"

AND getBuildingUsage()!= "AmusementFacility.BarBusiness")

}





KS{

getFloorArea(Room)>=200m2

OR (isObjectProperty(MainStructuralPart.isFireResistantStructure)=TRUE

OR isObjectProperty(MainStructuralPart.Material.nonCombustibility)=TRUE

getFloorArea(Room)>=400m2

} 





Python Code 변환 예정


35
 		건축법 시행령 제 61조 1 항 2호

2. 제2종 근린생활시설 중 공연장·종교집회장·인터넷컴퓨터게임시설제공업소·학원·독서실·당구장·다중생활시설의 용도로 쓰는 건축물 





Check(EDBA_61_1_2){

IF CS THEN KS1 OR KS2}



Building myBuilding{

getBuildingUsage()="DetachedHouse.Multi-userHouses"

OR getBuildingUsage()="DetachedHouse.Multi-familyHouses" 

OR getBuildingUsage()="ClassIINeighborhoodLivingFacility.EducationalInstitute"

OR getBuildingUsage()="ClassIINeighborhoodLivingFacility.ReadingRooms

OR getBuildingUsage()="ClassIINeighborhoodLivingFacility.CommunalLivingFacility 

OR getBuildingUsage()="ClassIINeighborhoodLivingFacility.LodgingFacility"

OR getBuildingUsage()="ClassIINeighborhoodLivingFacility.MedicalFacility"

OR getBuildingUsage()="EducationAndResearchFacility.EducationalInstitute"

OR getBuildingUsage()="BusinessFacility.Oofficetels"

OR getBuildingUsage()="FuneralParlors"

}



MBU = getObjectUsage(myBuilding)



CS{

getBuildingUsage() = MBU



Floor myfloor{

Floor.number>=3

}



KS1{

(Floor.number>=3

AND getTotalfloorarea(Room)>=200m2)





KS2{isObjectProperty(MainStructuralPart.isFireResistantStructure)=TRUE

OR isObjectProperty(MainStructuralPart.Material.nonCombustibility)=TRUE

AND Floor.number>=3

getTotalfloorarea(Room)>=200m2

} 





Python Code 변환 예정


36
 		건축법 시행령 제 61조 2 항 1호 가 목

가. 제1종 근린생활시설, 제2종 근린생활시설, 문화 및 집회시설, 종교시설, 판매시설, 의료시설, 교육연구시설, 노유자시설, 운동시설 및 위락시설의 용도로 쓰는 건축물로서 그 용도로 쓰는 바닥면적의 합계가 2천제곱미터 이상인 건축물 





//건축법 시행령 61조 (건축물의 마감재료) 2항 1호 가목

Check(EDBA_61_2_1_가){
            KS 
}



KS{
   Building myBuilding{
    getResult(SASP_2_1_1)=True
   }

  FloorSlab myFloorSlab{

     //   getFloorUsage()=myBuilding.usage
  }
  
   getObjectArea(myFloorSlab)>2000 m2

   
} 





Python Code 변환 예정


37
 		건축법 시행령 제 41조 1 항 1호 나 목

나. 바닥면적의 합계가 500제곱미터 이상인 문화 및 집회시설, 종교시설, 의료시설, 위락시설 또는 장례시설: 유효 너비 3미터 이상 





Check(EDBA_41_1_2){

   IF (CS) THEN  KS END IF

}



CS{

FloorSlab.area> 500 m2 

   Building.usage="CulturalAndAssemblyFacility"

   OR Building.usage="ReligiousFacility" 

   OR  Building.usage="MedicalFacility" 

   OR Building.usage="AmusementFacility" 

   OR Building.usage="FuneralParlor"  

}



KS{

  Passage.effectiveWidth> 3m ;

} 









target_bldg_uses_01 = ['단독주택']
target_bldg_uses_02 = ['문화 및 집회시설', '장례시설', '의료시설', '위락시설']

target_bldg_uses_01_label = '건축물 용도1'
target_bldg_uses_02_label = '건축물 용도2'

def Check():
    for building in SELECT('building'):
        bldg_use = building.SELECT('building type').STRING()
        min_corridor_w = 1.5
        min_area = 0.0

        if bldg_use in target_bldg_uses_01:
            min_corridor_w = 0.9
        elif bldg_use in target_bldg_uses_02:
            min_corridor_w = 3.0
            min_area = 500

        if min_area > 0:
            area = 0
            for space in building.SELECT('space'):
                area += space.SELECT('area').UNIT('m2').NUMBER()
            if area < min_area:
                building.SUCCESS('바닥면적의 합: ' + str(area) + ' < ' + str(min_area))
                continue

        base_storey = None
        stories = building.SELECT('storey')

        for storey in stories:
            if storey.SELECT('prop', '기준 지상층').BOOL() == True:
                base_storey = storey
                break

        if base_storey is None:
            building.ERROR('기준 지상층이 존재하지 않습니다.')
            break

        stairs = base_storey.SELECT('direct stair')

        if stairs.COUNT() == 0:
            base_storey.ERROR(base_storey.SELECT('name').STRING() + '에 직통계단이 존재하지 않습니다.')
            continue

        exDoors = []
        for door in base_storey.SELECT('door'):
            if door.SELECT('is external').BOOL() == True:
                exDoors.append(door)

        for stair in stairs:
            for route in stair.SELECT('escape route', exDoors):
                for space in route.SELECT('passing space'):
                    width = space.SELECT('min clear width').UNIT('m')
                    w = width.NUMBER()
                    if w < min_corridor_w:
                        width.ERROR('통로 너비: ' + str(w) + ' < ' + str(min_corridor_w))
                    else:
                        width.SUCCESS('통로 너비: ' + str(w) + ' >= ' + str(min_corridor_w)) 


38
 		건축법 시행령 제 61조 1 항

①법 제52조제1항에서 "대통령령으로 정하는 용도 및 규모의 건축물"이란 다음 각 호의 어느 하나에 해당하는 건축물을 말한다. 다만, 그 주요구조부가 내화구조 또는 불연재료로 되어 있고 그 거실의 바닥면적(스프링클러나 그 밖에 이와 비슷한 자동식 소화설비를 설치한 바닥면적을 뺀 면적으로 한다. 이하 이 조에서 같다) 200제곱미터 이내마다 방화구획이 되어 있는 건축물은 제외한다. <개정 2009.7.16, 2010.2.18, 2010.12.13, 2013.3.23, 2014.3.24, 2014.8.27, 2014.10.14, 2015.9.22, 2017.2.3> 





//건축법 시행령 61조 (건축물의 마감재료) 1항

Check(EDBA_61_1){

   IF !CS THEN  KS

}



CS{

 (isObjectProperty(MainStructuralPart.isFireResistantStructure)=TRUE

 OR isObjectProperty(MainStructuralPart.Material.nonCombustibility)=TRUE)

 

 isFirePartition(Room.Floor, a, 200)=TRUE



 

}



KS{

    getResult(EDBA_61_1_1)=TRUE

    OR getResult(EDBA_61_1_2)=TRUE

    OR getResult(EDBA_61_1_3)=TRUE

    OR getResult(EDBA_61_1_4)=TRUE

    OR getResult(EDBA_61_1_5)=TRUE

    OR getResult(EDBA_61_1_6)=TRUE

    OR getResult(EDBA_61_1_7)=TRUE

} 





Python Code 변환 예정


39
 		건축법 시행령 제 39조 1 항 7호

7. 교육연구시설 중 학교 





// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 1항 7호

Check(EDBA_39_1_7){     
KS
}


KS {
Building myBuilding{
getBuildingUsage() = “Warehouse”
Building.grossFloorArea >= 5000 m2
}

isExist(myBuliding) = TRUE
}
 









target_bldg_type_1 = ['제2종 근린생활시설', '문화 및 집회시설', '종교시설', '판매시설', '업무시설', '창고시설', '교육연구시설', '장례시설', '승강기를 설치하여야하는 건축물']
target_bldg_sub_type_2 = ['판매시설']
max_route_length_stair_to_door = 30
max_route_length_space_to_door = 60
min_em_door_count = 2
min_em_door_h = 1.5
min_em_door_w = 0.75

target_bldg_types_1_label = '외부 출입구 방향 적용 대상 건출물 용도'
target_bldg_types_2_label = '외부 출입구 유효너비 대상 건출물 용도'

max_route_length_stair_to_door_label = '직통계단과 외부 출입구 간 최소거리'
max_route_length_space_to_door_label = '거실과 외부 출입구 간 최소거리'
min_em_door_count_label = '최소 비상구 개수'
min_em_door_h_label = '최소 비상구 높이'
min_em_door_w_label = '최소 비상구 유효너비'

def Check():
    for building in SELECT('building'):
        bldg_type = building.SELECT('building type').STRING()
        sub_type = building.SELECT('prop', '세부용도').STRING()
        if (bldg_type in target_bldg_type_1):
            if bldg_type == '제2종 근린생활시설' and sub_type in ['공연장', '종교집회장', '인터넷컴퓨터게임시설제공업소']:
                message =  '검토 대상 건물이 아닙니다.' + '(용도:' + bldg_type + ', 세부용도:' + sub_type + ' )'
                SUCCESS(message)
                break
            elif bldg_type == '문화 및 집회시설' and sub_type in ['전시장', '동물원', '식물원']:
                message =  '검토 대상 건물이 아닙니다.' + '(용도:' + bldg_type + ', 세부용도:' + sub_type + ' )'
                SUCCESS(message)
                break
            elif bldg_type == '업무시설' and sub_type == '청사':
                message =  '검토 대상 건물이 아닙니다.' + '(용도:' + bldg_type + ', 세부용도:' + sub_type + ' )'
                SUCCESS(message)
                break
            elif bldg_type == '교육연구시설' and sub_type == '학교':
                message =  '검토 대상 건물이 아닙니다.' + '(용도:' + bldg_type + ', 세부용도:' + sub_type + ' )'
                SUCCESS(message)
                break
            message =  '검토 대상 건물입니다.' + '(용도:' + bldg_type + ', 세부용도:' + sub_type + ' )'
            SUCCESS(message)

        else:
            message =  '검토 대상 건물이 아닙니다.' + '(용도:' + bldg_type + ', 세부용도:' + sub_type + ' )'
            SUCCESS(message)
            break



        evac_storey_exist = False
        stories = building.SELECT('storey')

        for storey in stories:
            if storey.SELECT('is evacuation storey').BOOL() == True:
                evac_storey_exist = True
                break

        if evac_storey_exist == False:
            ERROR('피난층이 존재하지 않습니다.')
            return

        for storey in stories:
            stairs = storey.SELECT('direct stair')

            if stairs.COUNT() == 0:
                storey.ERROR(storey.SELECT('name').STRING() + '에 직통계단이 존재하지 않습니다.')
                continue

            exDoors = []
            for door in storey.SELECT('door'):
                if door.SELECT('is external').BOOL() == True:
                    exDoors.append(door)

            for stair in stairs:
                route_length = -1
                for route in stair.SELECT('escape route', exDoors):
                    length = route.SELECT('length').UNIT('m').NUMBER()
                    if length > 0:
                        if route_length < 0:
                            route_length = length
                        else:
                            route_length = min([route_length, length])
                if route_length < 0:
                    stair.ERROR(stair.SELECT('name').STRING() + '부터 외부 출입구까지 갈 수 없다.')
                elif route_length > max_route_length_stair_to_door:
                    stair.ERROR(stair.SELECT('name').STRING() + '부터 외부 출입구까지의 거리가 멀다 : ' + str(route_length))
                else:
                    stair.SUCCESS(stair.SELECT('name').STRING() + ' : ' + str(route_length))

            spaces = storey.SELECT('space')

            for space in spaces:
                route_length = -1
                for route in space.SELECT('escape route', exDoors):
                    length = route.SELECT('length').UNIT('m').NUMBER()
                    if length > 0:
                        if route_length < 0:
                            route_length = length
                        else:
                            route_length = min([route_length, length])
                if route_length < 0:
                    space.ERROR(space.SELECT('name').STRING() + '부터 외부 출입구까지 갈 수 없다.')
                elif route_length > max_route_length_space_to_door:
                    space.ERROR(space.SELECT('name').STRING() + '부터 외부 출입구까지의 거리가 멀다 : ' + str(route_length))
                else:
                    space.SUCCESS(space.SELECT('name').STRING() + ' : ' + str(route_length))

            if bldg_type in target_bldg_types_1:
                for door in exDoors:
                    if door.SELECT('is inward').BOOL():
                        door.ERROR('외부 출입구의 방향이 안여닫이입니다.')

                for space in spaces:
                    code = space.SELECT('class code').STRING()
                    if not code in theater_space_codes:
                        continue
                    area = space.SELECT('area').UNIT('m2').NUMBER()
                    if area < 300:
                        continue
                    emExits = []
                    for door in space.SELECT('space door'):
                        if door.SELECT('prop', '비상구').BOOL() or door.SELECT('prop', '보조출입구').BOOL():
                            emExits.append(door)
                    if len(emExits) < min_em_door_count:
                        space.ERROR('비상구(보조출입구) 개수:' + str(len(emExits)) + '(<' + str(min_em_door_count) + ')')
                        continue
                    em_exit_count = 0
                    for exit in emExits:
                        if exit.SELECT('clear opening').UNIT('m').NUMBER() >= min_em_door_w and exit.SELECT('height').UNIT('m').NUMBER() >= min_em_door_h:
                            em_exit_count += 1
                    if em_exit_count < min_em_door_count:
                        space.ERROR('기준(' + str(min_em_door_w) + 'X' + str(min_em_door_h) + ')을 충족하는 비상구(보조출입구) 개수:' + str(em_exit_count) + '(<' + str(min_em_door_count) + ')')
                    else:
                        space.SUCCESS('기준(' + str(min_em_door_w) + 'X' + str(min_em_door_h) + ')을 충족하는 비상구(보조출입구) 개수:' + str(em_exit_count) + '(>=' + str(min_em_door_count) + ')')

            if bldg_type in target_bldg_types_2:
                if storey.SELECT('is evacuation storey').BOOL() == False:
                    continue
                max_area = 0;
                for space in spaces:
                    area = space.SELECT('area').UNIT('m2').NUMBER()
                    if area > max_area:
                        max_area = area
                min_door_w = max_area / 100 * 0.6;

                for door in exDoors:
                    width = door.SELECT('clear opening').UNIT('m')
                    w = width.NUMBER()
                    if (w < min_door_w):
                        width.ERROR('출구 유효너비:' + str(w) + '(<' + str(min_door_w) + ')')
                    else:
                        width.SUCCESS('출구 유효너비:' + str(w) + '(>=' + str(min_door_w) + ')')
 


40
 		건축법 시행령 제 34조 2 항 3호

3. 공동주택(층당 4세대 이하인 것은 제외한다) 또는 업무시설 중 오피스텔의 용도로 쓰는 층으로서 그 층의 해당 용도로 쓰는 거실의 바닥면적의 합계가 300제곱미터 이상인 것 





//건축법 시행령 34조 (직통계단의 설치) 2항3호

Check(EDBA_34_2_3){



	Floor myFloor{

		 getFloorUsage()= “MultiUnitHouse”

		getObjectProperty(Floor.numberOfHousehold)>=4 



		OR getFloorUsage() = “BusinessFacility.Officetel”

	}	



				getTotalFloorArea(myFloor.Room)>=300 m2



} 





Python Code 변환 예정


41
 		건축법 시행령 제 34조 2 항 4호

4. 제1호부터 제3호까지의 용도로 쓰지 아니하는 3층 이상의 층으로서 그 층 거실의 바닥면적의 합계가 400제곱미터 이상인 것 





//건축법 시행령 34조 (직통계단의 설치) 2항4호
check(EDBA_34_2_4){

     IF getResult(EDBA_34_2_1)=FALSE
        OR getResult(EDBA_34_2_2)=FALSE
	OR getResult(EDBA_34_2_3)=FALSE
	   THEN getTotalFloorNumber(myFloor.Room)>=400 m2
     END IF
} 





Python Code 변환 예정


42
 		건축법 시행령 제 34조 2 항 5호

5. 지하층으로서 그 층 거실의 바닥면적의 합계가 200제곱미터 이상인 것 





//건축법 시행령 34조 (직통계단의 설치) 2항5호
check(EDBA_34_2_5){
	Floor myFloor {
		getFloorNumber()<0
	}
		
	getTotalFloorArea(myFloor.Room)>= 200 m2
}
 





Python Code 변환 예정


43
 		건축법 시행령 제 35조 1 항

① 법 제49조제1항에 따라 5층 이상 또는 지하 2층 이하인 층에 설치하는 직통계단은 국토해양부령으로 정하는 기준에 따라 피난계단 또는 특별피난계단으로 설치하여야 한다. 다만, 건축물의 주요구조부가 내화구조 또는 불연재료로 되어 있는 경우로서 다음 각 호의 어느 하나에 해당하는 경우에는 그러하지 아니하다. <개정 2008.10.29> 





//건축법 시행령 35조(피난계단의 설치) 1항
Check(EDBA_35_1){
	IF (!CS1 AND !CS2 AND CS3) THEN KS
}

CS1 {
     isFireProofStructure(MainStructuralPart) = TRUE
     OR isObjectProperty(MainStructuralPart.Material.nonCombustibility) = TRUE
}

CS2 {
     getResult(EDBA_35_1_1) = TRUE
     OR getResult(EDBA_35_1_2) = TRUE
}

CS3{
     Floor myFloor {
          Floor.number > 5
		OR Floor.number <= -2
	}

	Stair myStair {	
		isObjectProperty(Stair.isDirect) = TRUE
	}

	hasElement(myFloor, myStair) = TRUE
}

KS {
	isObjectProperty(myStair.isEscape) = TRUE
	OR isObjectProperty(myStair.isSpecialEscape) = TRUE
} 





Python Code 변환 예정


44
 		건축법 시행령 제 35조 1 항 1호

1. 5층 이상인 층의 바닥면적의 합계가 200제곱미터 이하인 경우 





//건축법 시행령 35조(피난계단의 설치) 1항1호

Check(EDBA_35_1_1){
	KS
}



KS { 
	Floor myFloor { 
	getObjectProperty(Floor.number) >= 5 
	} 

	getTotalFloorArea(myFloor) <= 200m2 

} 









min_floor_area = 200
min_floor_area_label = "Minimum total floor area"

def Check():
    num = 0
    for storey in SELECT('storey'):
        if num >= 5:
            area_sum = 0
            for space in storey.SELECT('space'):      
                area_sum += space.SELECT('area').UNIT('m2').NUMBER() 
            if area_sum >= min_floor_area:
                storey.SUCCESS("Total floor area:"+ str(area_sum)  + 'm2')
            else:
                storey.FAIL("Total floor area:"+ str(area_sum) + 'm2')
        num += 1 


45
 		건축법 시행령 제 35조 1 항 2호

2. 5층 이상인 층의 바닥면적 200제곱미터 이내마다 방화구획이 되어 있는 경우 





//건축법 시행령 35조(피난계단의 설치) 1항2호

Check(EDBA_35_1_2){

	KS

}



KS { 

	Floor myFloor { 

	 	Floor.number >= 5 

	} 



	isFirePartition(myFloor, a, 200) = TRUE 

} 





Python Code 변환 예정


46
 		건축법 시행령 제 35조 2 항

② 건축물(갓복도식 공동주택은 제외한다)의 11층(공동주택의 경우에는 16층) 이상인 층(바닥면적이 400제곱미터 미만인 층은 제외한다) 또는 지하 3층 이하인 층(바닥면적이 400제곱미터미만인 층은 제외한다)으로부터 피난층 또는 지상으로 통하는 직통계단은 제1항에도 불구하고 특별피난계단으로 설치하여야 한다. <개정 2008.10.29> 





//건축법 시행령 35조 (피난계단의 설치) 2항
check(EDBA_35_2){
	IF (CS1 AND CS2) THEN KS
}

CS1{
	Building.usage != "MultiUnitHouse.SideCorridorTypeMultiUnitHouse"
}

CS2{
	Floor myFloor{
 		IF (Building.usage = "MultiUnitHouse“) 
			THEN getFloorNumber(Floor) >= 16
     		ELSE 		
			getFloorNumber(Floor) >= 11
     		ENDIF

 		OR getFloorNumber(Floor) < -3
		getFloorArea(Floor) >= 400m2
	}

	Stair myStair {
		(isAccessible(Stair, Floor.isEscape) = TRUE
		 OR isAccessible(Stair, Ground) = TRUE)
                        isObjectProperty(Stair.isDirect) = TRUE
	}

	hasObject(myFloor, myStair) = TRUE
}

KS{
	isObjectProperty(myStair.isSpecialEscape) = TRUE
}
 





Python Code 변환 예정


47
 		건축법 시행령 제 35조 3 항

③ 제1항에서 판매시설의 용도로 쓰는 층으로부터의 직통계단은 그 중 1개소 이상을 특별피난계단으로 설치하여야 한다. <개정 2008.10.29> 





//건축법 시행령 35조 (피난계단의 설치) 3항
check(EDBA_35_3){
	IF (CS) THEN KS
CS{
	getResult(EDBA_35_1) = TRUE

	Floor myFloor {
		Floor.usage = “CommercialFacility”
	}

	Stair myStair{
		isObjectProperty(Stair.isDirect) = TRUE
	}

	isAccessible(myFloor, myStair) = TRUE
}

KS{
	isObjectProperty(one.myStair.isSpecialEscape) = TRUE
}
 





Python Code 변환 예정


48
 		건축법 시행령 제 37조

제37조 (지하층과 피난층 사이의 개방공간 설치) 바닥면적의 합계가 3천 제곱미터 이상인 공연장·집회장·관람장 또는 전시장을 지하층에 설치하는 경우에는 각 실에 있는 자가 지하층 각 층에서 건축물 밖으로 피난하여 옥외 계단 또는 경사로 등을 이용하여 피난층으로 대피할 수 있도록 천장이 개방된 외부 공간을 설치하여야 한다. 





Check(EDBA_37){

  IF (CS) THEN KS END IF

  Space mySpace{

        Space.Floor.area > 3000 M2;

        Space.usage="PerformanceHall"

        OR Space.usage="AssemblyHall"

        OR Space.usage="Auditorium"

        OR Space.usage="ExhibitionHall"

  }

}



CS{

    

    mySpace.Floor.number< 0 

    

}



KS{

Stair myStair{
Stair.isOutdoor = TRUE
}
Floor myFloor{
Floor.isEscape = TRUE
}
Space mySpace{
hasObject(Space, Ceiling) != TRUE
}
     (isGoThrough(mySpace, myStair, myFloor)=True

     OR isGoThrough(mySpace, Ramp, myFloor)=True)

     AND isExternal(mySpace)=True

    

} 









std_area = 3000
std_area_label = '기준 바닥면적 합계'

def Check():
    for building in SELECT('building'):
        bldg_use = building.SELECT('building type').STRING()
        sub_use = building.SELECT('prop', '세부용도').STRING()
        if not (bldg_use == '문화 및 집회시설' and sub_use in ['공연장', '집회장', '관람장', '전시장']):
            continue

        base_storey_exist = False
        under_stories = []

        for storey in building.SELECT('storey'):
            if storey.SELECT('prop', '기준 지상층').BOOL():
                base_storey_exist = True
                break
            under_stories.append(storey)

        if base_storey_exist == False:
            building.ERROR('지상층이 존재하지 않습니다.')
            continue

        if len(under_stories) == 0:
            continue

        area_sum = 0.0
        ex_spaces = []

        for storey in under_stories:
            for space in storey.SELECT('space'):
                area_sum += space.SELECT('area').UNIT('m2').NUMBER()
                if space.SELECT('is external').BOOL():
                    ex_spaces.append(space)

        if area_sum < std_area:
            building.SUCCESS('지하공간 바닥면적 합: ' + str(area_sum) + ' < ' + str(std_area))
            continue

        if len(ex_spaces) == 0:
            building.ERROR('지하에 천장이 개방된 외부 공간이 없습니다.')
            continue

        for space in ex_spaces:
            for stair in space.SELECT('stair'):
                if stair.SELECT('is direct').BOOL():
                    space.SUCCESS('피난층으로 대피할 수 있는 외부 공간이 존재합니다.')
                    return

        ex_spaces[0].ERROR('피난층으로 대피할 수 없습니다.') 


49
 		건축법 시행령 제 39조 1 항 1호

1. 문화 및 집회시설(전시장 및 동·식물원은 제외한다) 





// 건축법 시행령 39조 (건축물 바깥쪽으로의 출구 설치) 1항 1호

Check(EDBA_39_1_1){     
KS}

KS {

Building myBuilding{
getBuildingUsage() = “PerformanceHall”
OR getBuildingUsage() = “ReligiousAssemblyFacility ”
OR getBuildingUsage() = “FacilityForProvidingInternetComputerGameService”
}

Space mySpace{
Space.usage = “PerformanceHall”
OR Space.usage = “ReligiousAssemblyFacility ”
OR Space.usage = “FacilityForProvidingInternetComputerGameService”
}

IF isExist(myBuilding) THEN mySpace.FloorSlab.area >= 300 m2

}
 









target_bldg_type_1 = ['제2종 근린생활시설', '문화 및 집회시설', '종교시설', '판매시설', '업무시설', '창고시설', '교육연구시설', '장례시설', '승강기를 설치하여야하는 건축물']
target_bldg_sub_type_2 = ['판매시설']
max_route_length_stair_to_door = 30
max_route_length_space_to_door = 60
min_em_door_count = 2
min_em_door_h = 1.5
min_em_door_w = 0.75

target_bldg_types_1_label = '외부 출입구 방향 적용 대상 건출물 용도'
target_bldg_types_2_label = '외부 출입구 유효너비 대상 건출물 용도'

max_route_length_stair_to_door_label = '직통계단과 외부 출입구 간 최소거리'
max_route_length_space_to_door_label = '거실과 외부 출입구 간 최소거리'
min_em_door_count_label = '최소 비상구 개수'
min_em_door_h_label = '최소 비상구 높이'
min_em_door_w_label = '최소 비상구 유효너비'

def Check():
    for building in SELECT('building'):
        bldg_type = building.SELECT('building type').STRING()
        sub_type = building.SELECT('prop', '세부용도').STRING()
        if (bldg_type in target_bldg_type_1):
            if bldg_type == '제2종 근린생활시설' and sub_type in ['공연장', '종교집회장', '인터넷컴퓨터게임시설제공업소']:
                message =  '검토 대상 건물이 아닙니다.' + '(용도:' + bldg_type + ', 세부용도:' + sub_type + ' )'
                SUCCESS(message)
                break
            elif bldg_type == '문화 및 집회시설' and sub_type in ['전시장', '동물원', '식물원']:
                message =  '검토 대상 건물이 아닙니다.' + '(용도:' + bldg_type + ', 세부용도:' + sub_type + ' )'
                SUCCESS(message)
                break
            elif bldg_type == '업무시설' and sub_type == '청사':
                message =  '검토 대상 건물이 아닙니다.' + '(용도:' + bldg_type + ', 세부용도:' + sub_type + ' )'
                SUCCESS(message)
                break
            elif bldg_type == '교육연구시설' and sub_type == '학교':
                message =  '검토 대상 건물이 아닙니다.' + '(용도:' + bldg_type + ', 세부용도:' + sub_type + ' )'
                SUCCESS(message)
                break
            message =  '검토 대상 건물입니다.' + '(용도:' + bldg_type + ', 세부용도:' + sub_type + ' )'
            SUCCESS(message)

        else:
            message =  '검토 대상 건물이 아닙니다.' + '(용도:' + bldg_type + ', 세부용도:' + sub_type + ' )'
            SUCCESS(message)
            break



        evac_storey_exist = False
        stories = building.SELECT('storey')

        for storey in stories:
            if storey.SELECT('is evacuation storey').BOOL() == True:
                evac_storey_exist = True
                break

        if evac_storey_exist == False:
            ERROR('피난층이 존재하지 않습니다.')
            return

        for storey in stories:
            stairs = storey.SELECT('direct stair')

            if stairs.COUNT() == 0:
                storey.ERROR(storey.SELECT('name').STRING() + '에 직통계단이 존재하지 않습니다.')
                continue

            exDoors = []
            for door in storey.SELECT('door'):
                if door.SELECT('is external').BOOL() == True:
                    exDoors.append(door)

            for stair in stairs:
                route_length = -1
                for route in stair.SELECT('escape route', exDoors):
                    length = route.SELECT('length').UNIT('m').NUMBER()
                    if length > 0:
                        if route_length < 0:
                            route_length = length
                        else:
                            route_length = min([route_length, length])
                if route_length < 0:
                    stair.ERROR(stair.SELECT('name').STRING() + '부터 외부 출입구까지 갈 수 없다.')
                elif route_length > max_route_length_stair_to_door:
                    stair.ERROR(stair.SELECT('name').STRING() + '부터 외부 출입구까지의 거리가 멀다 : ' + str(route_length))
                else:
                    stair.SUCCESS(stair.SELECT('name').STRING() + ' : ' + str(route_length))

            spaces = storey.SELECT('space')

            for space in spaces:
                route_length = -1
                for route in space.SELECT('escape route', exDoors):
                    length = route.SELECT('length').UNIT('m').NUMBER()
                    if length > 0:
                        if route_length < 0:
                            route_length = length
                        else:
                            route_length = min([route_length, length])
                if route_length < 0:
                    space.ERROR(space.SELECT('name').STRING() + '부터 외부 출입구까지 갈 수 없다.')
                elif route_length > max_route_length_space_to_door:
                    space.ERROR(space.SELECT('name').STRING() + '부터 외부 출입구까지의 거리가 멀다 : ' + str(route_length))
                else:
                    space.SUCCESS(space.SELECT('name').STRING() + ' : ' + str(route_length))

            if bldg_type in target_bldg_types_1:
                for door in exDoors:
                    if door.SELECT('is inward').BOOL():
                        door.ERROR('외부 출입구의 방향이 안여닫이입니다.')

                for space in spaces:
                    code = space.SELECT('class code').STRING()
                    if not code in theater_space_codes:
                        continue
                    area = space.SELECT('area').UNIT('m2').NUMBER()
                    if area < 300:
                        continue
                    emExits = []
                    for door in space.SELECT('space door'):
                        if door.SELECT('prop', '비상구').BOOL() or door.SELECT('prop', '보조출입구').BOOL():
                            emExits.append(door)
                    if len(emExits) < min_em_door_count:
                        space.ERROR('비상구(보조출입구) 개수:' + str(len(emExits)) + '(<' + str(min_em_door_count) + ')')
                        continue
                    em_exit_count = 0
                    for exit in emExits:
                        if exit.SELECT('clear opening').UNIT('m').NUMBER() >= min_em_door_w and exit.SELECT('height').UNIT('m').NUMBER() >= min_em_door_h:
                            em_exit_count += 1
                    if em_exit_count < min_em_door_count:
                        space.ERROR('기준(' + str(min_em_door_w) + 'X' + str(min_em_door_h) + ')을 충족하는 비상구(보조출입구) 개수:' + str(em_exit_count) + '(<' + str(min_em_door_count) + ')')
                    else:
                        space.SUCCESS('기준(' + str(min_em_door_w) + 'X' + str(min_em_door_h) + ')을 충족하는 비상구(보조출입구) 개수:' + str(em_exit_count) + '(>=' + str(min_em_door_count) + ')')

            if bldg_type in target_bldg_types_2:
                if storey.SELECT('is evacuation storey').BOOL() == False:
                    continue
                max_area = 0;
                for space in spaces:
                    area = space.SELECT('area').UNIT('m2').NUMBER()
                    if area > max_area:
                        max_area = area
                min_door_w = max_area / 100 * 0.6;

                for door in exDoors:
                    width = door.SELECT('clear opening').UNIT('m')
                    w = width.NUMBER()
                    if (w < min_door_w):
                        width.ERROR('출구 유효너비:' + str(w) + '(<' + str(min_door_w) + ')')
                    else:
                        width.SUCCESS('출구 유효너비:' + str(w) + '(>=' + str(min_door_w) + ')')
 


50
 		건축법 시행령 제 40조 1 항

① 옥상광장 또는 2층 이상인 층에 있는 노대(露臺)나 그 밖에 이와 비슷한 것의 주위에는 높이 1.2미터 이상의 난간을 설치하여야 한다. 다만, 그 노대 등에 출입할 수 없는 구조인 경우에는 그러하지 아니하다. 





//건축법 시행령 40조 (옥상광장 등의 설치) 1항

check(EDBA_40_1){

	IF (CS) THEN KS

}



CS{

	Space myBalcony {

		getSpace(“Balconly”)

		Space.Floor.number >= 2

	}



	Space mySpace{

		getSpace(“RoofTopPlaza”) + getSpace(myBalcony)

	}



	isAccessible(mySpace) = TRUE

}



KS{

	hasElement(mySpace, Railing) = TRUE

	mySpace.Rail.height >= 1.2m

} 









target_space_names = ['옥상광장', '노대']
drop_h = 2.0
barrier_h = 1.2

target_space_names_label = '대상 공간 이름'
drop_h_label = '최소 추락 높이'
barrier_h_label = '최소 난간 높이'

def Check():
    for space in SELECT('space'):
        if space.SELECT('is name in', target_space_names).BOOL() == False:
            continue
        if space.SELECT('space door').COUNT() + space.SELECT('opening').COUNT() == 0:
            space.SUCCESS('출입 불가능')
            continue

        for edge in space.SELECT('edge'):
            drop = edge.SELECT('drop').UNIT('m')
            if drop.COUNT() == 0 or drop.LTE(drop_h): 
                continue

            safetybarrier = edge.SELECT('safety barrier')   
            if safetybarrier.COUNT() == 0 : 
                drop.ERROR('난간 미설치')
                continue
                    
            height = safetybarrier.SELECT('height').UNIT('m')
            height_val = height.NUMBER()
                
            if height_val < barrier_h:
                height.ERROR('난간 높이: ' +  str(height_val) + ' < ' + str(barrier_h))
            else:
                height.SUCCESS('난간 높이: ' +  str(height_val) + ' >= ' + str(barrier_h)) 


51
 		건축법 시행령 제 40조 2 항

② 5층 이상인 층이 문화 및 집회시설(전시장 및 동·식물원은 제외한다), 종교시설, 판매시설, 위락시설 중 주점영업 또는 장례식장의 용도로 쓰는 경우에는 피난 용도로 쓸 수 있는 광장을 옥상에 설치하여야 한다. 





//건축법 시행령 40조 (옥상광장 등의 설치) 2항

Check(EDBA_40_2){

 IF (CS) THEN KS

}



CS{

	Floor myFloor{

		getObjectUsage(Floor) = “ClassIINeighborhoodLivingFacility.PerformanceHall“

		OR getObjectUsage(Floor) = "ClassIINeighborhoodLivingFacility.ReligiousAssemblyFacility"

   	OR getObjectUsage(Floor)= "ClassIINeighborhoodLivingFacility.FacilityForProvidingInternetComputerGameService“ 





Python Code 변환 예정


52
 		건축법 시행령 제 44조

제44조 (피난 규정의 적용례) 건축물이 창문, 출입구, 그 밖의 개구부(開口部)(이하 "창문등"이라 한다)가 없는 내화구조의 바닥 또는 벽으로 구획되어 있는 경우에는 그 구획된 각 부분을 각각 별개의 건축물로 보아 제34조부터 제41조까지를 적용한다. 





//건축법 시행령 44조 (피난 규정의 적용례)



Check(EDBA_44){

   IF CS THEN KS

}



CS{

   Door myDoor{

      isObjectProperty(Door.isEntrance)=True

   }



   Object  myElement {

        getObject(Window)

        getObject(Opening)

        getObject(myDoor)

   }

   

   FloorSlab myFloorSlab{



        getObjectProperty(FloorSlab.isFireResistantStructure)=True

   }



     Wall myWall{

        getObjectProperty(FloorSlab.isFireResistantStructure)=True

        hasObject(Wall, myElement) =False

   }



   isFirePartition(Building, myFloorSlab)=True

   OR  isFirePartition(Building, myWall)=True

   



}



KS{

   getResult(EDBA_34)=True

   getResult(EDBA_35)=True

   getResult(EDBA_36)=True

   getResult(EDBA_37)=True

   getResult(EDBA_38)=True

   getResult(EDBA_39)=True

   getResult(EDBA_40)=True

   getResult(EDBA_41)=True

} 





Python Code 변환 예정


53
 		건축법 시행령 제 46조 1 항

① 법 제49조제2항에 따라 주요구조부가 내화구조 또는 불연재료로 된 건축물로서 연면적이 1천 제곱미터를 넘는 것은 국토해양부령으로 정하는 기준에 따라 내화구조로 된 바닥·벽 및 제64조에 따른 갑종 방화문(국토해양부장관이 정하는 기준에 적합한 자동방화셔텨를 포함한다. 이하 이 조에서 같다)으로 구획(이하 "방화구획"이라 한다)하여야 한다. 다만, 「원자력법」 제2조에 따른 원자로 및 관계시설은 「원자력법」에서 정하는 바에 따른다. 





//건축법 시행령 46조 (방화구획의 설치) 1항

Check(EDBA_46_1){

   IF (!CS1 AND CS2) THEN KS

}





CS1{

  getBuildingUsage()="NuclearReactorAndRelatedFacility"

}



CS2{

  (isObjectProperty(MainStructuralPart.isFireResistantStructure)=TRUE

  OR isObjectProperty(MainStructuralPart.Material.nonCombustibility)=TRUE))

  AND Building.grossFloorArea>1000 m2

}



KS{



  Floor myFloor{

      isObjectProperty(FloorSlab.isFireResistantStructure)=TRUE

  }

  Wall myWall{

      isObjectProperty(Wall.isFireResistantStructure)=TRUE

  }

  Door myDoor{

      isObjectProperty(Door.isStrictFireproofDoor)=TRUE

  }



  isFirePartition(Building, myFloor)=TRUE

  AND  isFirePartition(Building, myWall)=TRUE

  AND  isFirePatrition(Building, myDoor)=TRUE



  AND getResult(REFB_14_1)=TRUE

  AND getResult(REFB_14_2)=TRUE

  AND getResult(REFB_14_3)=TRUE



} 





Python Code 변환 예정


54
 		건축법 시행령 제 46조 2 항 2호

2. 물품의 제조·가공·보관 및 운반 등에 필요한 대형기기 설비의 설치 및 이동식 물류설비의 작업활동을 위하여 불가피한 부분 





//건축법 시행령 46조 (방화구획의 설치) 2항 2호

check(EDBA_46_2_2){

IF CS THEN KS

}



KS{

isExist(StationaryLargeComponent)=TRUE

}



CS{

Floor myFloor{
getFloorNumber()<0
}

AND isAccessible(myFloor, Ground) = TRUE

} 





Python Code 변환 예정


55
 		건축법 시행령 제 46조 2 항 4호

4. 건축물의 최상층 또는 피난층으로서 대규모 회의장·강당·스카이라운지·로비 등의 용도로 쓰는 부분으로서 그 용도로 사용하기 위하여 불가피한 부분 





//건축법 시행령 46조 (방화구획의 설치) 2항 4호

check(EDBA_46_2_4){

KS

}



KS{
Floor myFloor{
getObject(TopFloor)
OR  isObjectProperty(Floor.isEscape)=TRUE
}


 AND 

 (getSpaceUsage(myFloor.Space)="ConferenceRoom"

 OR getSpaceUsage(myFloor.Space)="Hall"

 OR getSpaceUsage(myFloor.Space)="SkyLounge"

 OR getSpaceUsage(myFloor.Space)="Lobby"

 OR isObjectProperty(Zone.isEgressSafetyZone)= TRUE

} 





Python Code 변환 예정


56
 		건축법 시행령 제 46조 2 항 5호

5. 복층형 공동주택의 세대별 층간 바닥 부분 





//건축법 시행령 46조 (방화구획의 설치) 2항 5호
check(EDBA_46_2_5){
	Zone myZone{
		isObjectProperty(Zone.isOccupiedByOneHousehold) = TRUE
	}
	getBuildingUsage() = "DuplexMultiUnitHouses"
	hasSpace(myZone, Floor) = TRUE
	getFloorNumber(Floor) != 1
} 





Python Code 변환 예정


57
 		건축법 시행령 제 46조 4 항

④ 공동주택 중 아파트로서 4층 이상인 층의 각 세대가 2개 이상의 직통계단을 사용할 수 없는 경우에는 발코니에 인접 세대와 공동으로 또는 각 세대별로 다음 각 호의 요건을 모두 갖춘 대피공간을 하나 이상 설치하여야 한다. 이 경우 인접 세대와 공동으로 설치하는 대피공간은 인접 세대를 통하여 2개 이상의 직통계단을 쓸 수 있는 위치에 우선 설치되어야 한다. 





//건축법 시행령 46조 (방화구획의 설치) 4항

check(EDBA_46_4){

IF CS THEN KS1 AND KS2

}



Zone myZone{

     isObjectProperty(Zone.isOccupiedByOneHousehold) = TRUE

}



KS1{
Space mySpace{
Space.isEscape = TRUE
}

isExist(Balcony)=TRUE

AND hasElement(Balcony,mySpace)=TRUE

AND (getResult(EDBA_46_4_1)=TRUE

AND getResult(EDBA_46_4_2)=TRUE

AND getResult(EDBA_46_4_3)=TRUE

AND getResult(EDBA_46_4_4)=TRUE)

}



KS2{
Stair myStair{
Stair.isDirect = TRUE
}

isGoThrough(myZone,mySpace,myZone)=TRUE

AND isGoThrough(mySpace,myZone,myStair)=TRUE

}



CS{

getBuildingUsage()="MultiUnitHouses.ApartmentHouses"

AND Floor.number >=4

AND isDirectlyAccessible(myZone, myStair)=TRUE

AND myStair.Number>=2

} 





Python Code 변환 예정


58
 		건축법 시행령 제 48조 1 항

① 법 제49조제2항에 따라 연면적 200제곱미터를 초과하는 건축물에 설치하는 계단 및 복도는 국토해양부령으로 정하는 기준에 적합하여야 한다. 





//건축법 시행령 48조 (계단ㆍ복도 및 출입구의 설치) 1항

Check(EDBA_48_1){
     IF CS THEN KS 
}

CS{
   getGrossFloorArea()>200 m2
}

KS{
   getResult(REFB_15_1)=True
   getResult(REFB_15_1_1)=True
   getResult(REFB_15_1_2)=True
   getResult(REFB_15_1_3)=True
   getResult(REFB_15_1_4)=True

   getResult(REFB_15_2)=True
   getResult(REFB_15_2_1)=True
   getResult(REFB_15_2_2)=True
   getResult(REFB_15_2_3)=True
   getResult(REFB_15_2_4)=True
   getResult(REFB_15_2_5)=True
   getResult(REFB_15_2_6)=True

   getResult(REFB_15-2_1)=True
   getResult(REFB_15-2_2)=True
   getResult(REFB_15-2_2_1)=True
   getResult(REFB_15-2_2_2)=True
   getResult(REFB_15-2_2_3)=True

   getResult(REFB_15-2_3)=True
   getResult(REFB_15-2_3_1)=True
   getResult(REFB_15-2_3_2)=True
} 










std_floor_area = 200



std_floor_area_label = '기준 연면면적'

def Check():
    for building in SELECT('building'):
        if building.SELECT('area').Unit(m2).NUmber() < 200:
            continue
                         


59
 		건축법 시행령 제 51조 2 항

② 법 제49조제2항에 따라 6층 이상인 건축물로서 문화 및 집회시설, 종교시설, 판매시설, 운수시설, 의료시설, 교육연구시설 중 연구소, 노유자시설 중 아동 관련 시설·노인복지시설, 수련시설 중 유스호스텔, 운동시설, 업무시설, 숙박시설, 위락시설, 관광휴게시설 및 장례식장의 거실에는 국토해양부령으로 정하는 기준에 따라 배연설비(排煙設備)를 하여야 한다. 다만, 피난층인 경우에는 그러하지 아니하다. 





//건축법 시행령 51조 (거실의 채광 등) 2항
Check(EDBA_51_2){
	IF (!CS1 AND CS2) THEN KS
}


CS1{
	Floor myFloor{
		isObjectProperty(Floor.isEscape) = TRUE
	}
	getFloorNumber(Room) = getFloorNumber(myFloor)
}

CS2{
	getBuildingStoriesCount() >= 6
	getResult(EDBA_51_2_1) = True
	OR getResult(EDBA_51_2_2) = True
	OR getResult(EDBA_51_2_3) = True
	OR getResult(EDBA_51_2_4) = True
	OR getResult(EDBA_51_2_5) = True
	OR getResult(EDBA_51_2_6) = True
	OR getResult(EDBA_51_2_7) = True
	OR getResult(EDBA_51_2_8) = True
	OR getResult(EDBA_51_2_9) = True
	OR getResult(EDBA_51_2_10) = True
	OR getResult(EDBA_51_2_11) = True
	OR getResult(EDBA_51_2_12) = True
	OR getResult(EDBA_51_2_13) = True
	OR getResult(EDBA_51_2_14) = True
	OR getResult(EDBA_51_2_15) = True
}

KS{
	hasSpace(Room, SmokeExhaustionSystem) = True
	getResult(RFB_14_1) = True
	getResult(REFB_17_1) = True
	getResult(REFB_17_2) = True
}
 





Python Code 변환 예정


60
 		건축법 시행령 제 52조

제52조 (거실 등의 방습) 법 제49조제2항에 따라 다음 각 호의 어느 하나에 해당하는 거실·욕실 또는 조리장의 바닥 부분에는 국토해양부령으로 정하는 기준에 따라 방습을 위한 조치를 하여야 한다. 





//건축법 시행령 52조 (거실 등의 방습)
Check(EDBA_52){
IF CS THEN KS}

CS{
  getResult(EDBA_52_0_1)=TRUE
  OR getResult(EDBA_52_0_2)=TRUE
  OR getResult(EDBA_52_0_3)=TRUE
  getObject(Floor)
}

KS{
  getResult(REFB_18_1)=TRUE
  AND getResult(REFB_18_2)=TRUE
} 





Python Code 변환 예정


61
 		건축법 시행령 제 56조 1 항 1호

1. 문화 및 집회시설(전시장 및 동·식물원은 제외한다), 종교시설, 위락시설 중 주점영업 및 장례식장의 용도로 쓰는 건축물로서 관람석 또는 집회실의 바닥면적의 합계가 200제곱미터(옥외관람석의 경우에는 1천 제곱미터) 이상인 건축물 





//건축법 시행령 56조 (건축물의 내화구조) 1항 1호

check(EDBA_56_1_1){

	KS

}


Space mySpace{
Space.usage = "Auditorium "
isExternal(Space) = TRUE
}



KS {

        (getBuildingUsage() = "PerformanceHall" | "ReligiousAssemblyFacility"

        AND getFloorArea(getSpace("PerformanceHall" | “ReligiousAssemblyFacility”)) > = 300m2;)

	

        OR (getBuildingUsage() = "CulturalAndAssemblyFacility" 

        AND getBuildingUsage() != "ExhibitionHall" | "ZoologicalAndBotanicalGarden"

        

        OR (getBuildingUsage() = "ReligiousFacility" | "BarBusiness" | "FuneralParlor"

	AND getFloorArea(getSpace(“Seat” | “AssemblyHall”) > = 200m2 

        OR getFloorArea(mySpace) > = 1000m2;)

} 





Python Code 변환 예정


62
 		건축법 시행령 제 56조 1 항 2호

2. 문화 및 집회시설 중 전시장 또는 동·식물원, 판매시설, 운수시설, 수련시설, 운동시설 중 체육관·운동장, 위락시설(주점영업의 용도로 쓰는 것은 제외한다), 창고시설, 위험물저장 및 처리시설, 자동차 관련 시설, 방송통신시설 중 방송국·전신전화국·촬영소, 묘지 관련 시설 중 화장장 또는 관광휴게시설의 용도로 쓰는 건축물로서 그 용도로 쓰는 바닥면적의 합계가 500제곱미터 이상인 건축물 





//건축법 시행령 56조 (건축물의 내화구조) 1항 2호

check(EDBA_56_1_2){

        KS

}

	

KS{

        (getBuildingUsage() = "ExhibitionHall" |  "ZoologicalANDbotanicalGarden" | "CommercialFacility"  | "TransportationFacilities"  | "gymnasium.educationAndresearchFacilities"   | "hall.educationAndresearchFacilities" | "gymnasium" | "sportsfacilities.stadium" | "sports facilities.warehouses"  | "factory.facilitiesForStorageAndreatmentOfDangerousSubstance"  | "factory.facilitiesForMotorVehicles" | "facilitiesforbroadcastingAndTelecommunications.broadcastingStation"  | "facilitiesforbroadcasting andtelecommunications.telegraphAndTelephoneStations" | "facilitiesforbroadcasting and telecommunications.studio" | "cemeteries and relatedfacilities.Crematorium | "facilitiesfortourismandrelaxation"

OR (getBuildingUsage() = "amusementfacilities"

AND getBuildingUsage() != "barbusiness.amusementfacilities"))

AND getFloorArea(getSpace(getBuildingUsage()) > = 500m2))

} 





Python Code 변환 예정


63
 		건축법 시행령 제 56조 1 항 3호

3. 공장의 용도로 쓰는 건축물로서 그 용도로 쓰는 바닥면적의 합계가 2천 제곱미터 이상인 건축물. 다만, 화재의 위험이 적은 공장으로서 국토해양부령으로 정하는 공장은 제외한다. 





//건축법 시행령 56조 (건축물의 내화구조와 방화벽) 1항 3호
check(EDBA_56_1_3){
	IF !(CS) THEN KS
}

CS{
	getResult(REFB_20-2) = TRUE
}

KS{
	Floor myFloor{
		getObjectUsage(Floor) = "Factory"
	}

	getTotalFloorArea(myFloor.Space) >= 2000 m2
} 





Python Code 변환 예정


64
 		건축법 시행령 제 56조 1 항 4호

4. 건축물의 2층이 단독주택 중 다중주택 및 다가구주택, 공동주택, 제1종 근린생활시설(의료의 용도로 쓰는 시설만 해당한다), 의료시설, 노유자시설 중 아동 관련 시설 및 노인복지시설, 수련시설 중 유스호스텔, 업무시설 중 오피스텔, 숙박시설 또는 장례식장의 용도로 쓰는 건축물로서 그 용도로 쓰는 바닥면적의 합계가 400제곱미터 이상인 건축물 





//건축법 시행령 56조 (건축물의 내화구조와 방화벽) 1항 4호
check(EDBA_56_1_4){
	
	Floor myFloor{

		getFloorNumber = 2

		getObjectUsage(Floor) = "DetachedHouse.MultiUserHouse"
		OR getObjectUsage(Floor) = "DetachedHouse.MultiFamilyHouse"
		OR getObjectUsage(Floor) = "DetachedHouse.MultiFamilyHouse"
		OR getObjectUsage(Floor) = "MultiUnitHouse"
		OR getObjectUsage(Floor) = "ClassINeighborhoodLivingFacility.MedicalFacility"
		OR getObjectUsage(Floor) = "ClassIINeighborhoodLivingFacility.CommunalLivingFacility"
		OR getObjectUsage(Floor) = "MedicalFacility"
		OR getObjectUsage(Floor) = "FacilitiesForTheAgedAndChildren.ChildrenRelatedFacility"
		OR getObjectUsage(Floor) = "FacilitiesForTheAgedAndChildren.WelfareFacilityForTheAged "
		OR getObjectUsage(Floor) = "Trainingfacility.YouthHostel"
		OR getObjectUsage(Floor) = "BusinessFacility.Officetel"
		OR getObjectUsage(Floor) = "LodgingFacility"
		OR getObjectUsage(Floor) = "FuneralParlor"
	}
	
	getFloorArea(myFloor) >= 400 m2
} 





Python Code 변환 예정


65
 		건축법 시행령 제 57조 1 항

① 법 제50조제2항에 따라 연면적 1천 제곱미터 이상인 건축물은 방화벽으로 구획하되, 각 구획된 바닥면적의 합계는 1천 제곱미터 미만이어야 한다. 다만, 주요구조부가 내화구조이거나 불연재료인 건축물과 제56조제1항제5호 단서에 따른 건축물 또는 내부설비의 구조상 방화벽으로 구획할 수 없는 창고시설의 경우에는 그러하지 아니하다. 





//  건축법 시행령 57조 (	대규모 건축물의 방화벽 등) 1항
Check(EDBA_57_1){
	IF (CS1 AND CS2) THEN KS
}

CS1{
	getObjectProperty(MainStructuralPart.isFireResistantStructure) = TRUE
	OR getObjectProperty(MainStructuralPart.Material.nonCombustibility) = TRUE
	OR getResult(EDBA_56_1_5) = TRUE
}

CS2{
	getObjectProperty(Building.grossFloorArea) >= 1000m2
}

KS{
	Space mySpace{
		getFloorArea(Space) < 1000m2
	}

	Space mySpace2{
		Space != mySpace
	}

	Wall myWall{
		isObjectProperty(Wall.isFireProofWall) = TRUE
	}

	isPartitioned(mySpace, mySpace2, myWall) = TRUE
} 





Python Code 변환 예정


66
 		건축법 시행령 제 57조 3 항

③ 연면적 1천 제곱미터 이상인 목조 건축물의 구조는 국토해양부령으로 정하는 바에 따라 방화구조로 하거나 불연재료로 하여야 한다. 





//  건축법 시행령 57조 (대규모 건축물의 방화벽 등) 3항

Check(EDBA_57_3){

	IF CS THEN KS

}



CS{

	getObjectProperty(Building.grossFloorArea) >= 1000m2

	getObjectProperty(Building.Structure.materialType) = "Timber"

}



KS{

	getObjectProperty(MainStructuralPart.Material.nonCombustibility) = TRUE

	OR getObjectProperty(MainStructuralPart.isFireProofStructure) = TRUE

} 





Python Code 변환 예정


67
 		건축법 시행령 제 90조 1 항 1호

1. 높이 31미터를 넘는 각 층의 바닥면적 중 최대 바닥면적이 1천500제곱미터 이하인 건축물: 1대 이상 





//건축법 시행령 90조 (비상용 승강기의 설치) 1항 1호
Check(EDBA_90_1_1){
	IF CS THEN KS
}

CS{
	Floor myFloor{
		getObjectHeight(myFloor) > 31 m
	}

	getFloorArea(myFloor) <= 1500 m2
}

KS{
	isExist(Elevator.isEmergency) = TRUE
} 





Python Code 변환 예정


68
 		건축법 시행령 제 90조 1 항 2호

2. 높이 31미터를 넘는 각 층의 바닥면적 중 최대 바닥면적이 1천500제곱미터를 넘는 건축물: 1대에 1천500제곱미터를 넘는 3천 제곱미터 이내마다 1대씩 더한 대수 이상 





//건축법 시행령 90조 (비상용 승강기의 설치) 1항2호
Check(EDBA_1_2){
   IF CS THEN KS
}

 Floor myFloor{
     getObjectHeight(Floor)>31 m
  }

CS{
   getFloorArea(myFloor)>1500 m2
}

KS{
   FA=getFloorArea(myFloor) //FA means floor area
   IF FA>=4500 m2
      THEN   {(FA-1500)/3000}+1 < getObjectCount(EmergencyElevator)
             getObjectCount(EmergencyElevator) < {(FA-1500)/3000}+2
   END IF 
  
  

} 





Python Code 변환 예정


69
 		건축법 시행령 제 56조 1 항

① 법 제50조제1항에 따라 다음 각 호의 어느 하나에 해당하는 건축물(제5호에 해당하는 건축물로서 2층 이하인 건축물은 지하층 부분만 해당한다)의 주요구조부는 내화구조로 하여야 한다. 다만, 연면적이 50제곱미터 이하인 단층의 부속건축물로서 외벽 및 처마 밑면을 방화구조로 한 것과 무대의 바닥은 그러하지 아니하다. <개정 2009.6.30> 





//건축법 시행령 56조 (건축물의 내화구조) 1항

check(EDBA_56_1){

        IF !CS THEN KS

}

Space mySpace{
Space.usage="StagePart"
}

Floor myFloor{

     hasSpace(mySpace, Floor) = TRUE

}



CS {

       getTotalFloorArea()<= 50m2

       AND getBuildingStoriesCount()=1

       AND getBuildingUsage()="AccessoryBuidling"

       AND isFireProofStructure("OuterWall" | "eaves" | myFloor)=TRUE

}



KS {

	getResult(EDBA_56_1_1 = TRUE  

	OR getResult(EDBA_56_1_2) = TRUE  

	OR getResult(EDBA_56_1_3) = TRUE  

	OR getResult(EDBA_56_1_4) = TRUE  

	OR getResult(EDBA_56_1_5) = TRUE  

   		

	AND isFireProofStructure(MainStructuralPart) = TRUE

} 





Python Code 변환 예정


70
 		건축법 시행령 제 56조 1 항 5호

5. 3층 이상인 건축물 및 지하층이 있는 건축물. 다만, 단독주택(다중주택 및 다가구주택은 제외한다), 동물 및 식물 관련 시설, 발전시설(발전소의 부속용도로 쓰는 시설은 제외한다), 교도소·감화원 또는 묘지 관련 시설(화장장은 제외한다)의 용도로 쓰는 건축물과 철강 관련 업종의 공장 중 제어실로 사용하기 위하여 연면적 50제곱미터 이하로 증축하는 부분은 제외한다. 





//건축법 시행령 56조 (건축물의 내화구조) 1항 5호

check(EDBA_56_1_5){

	IF !CS THEN KS

}

Building myBuilding{

     getBuildingUsage() = "PowerPlant"

     isObjectProperty(Building.isAttachedBuilding) = TRUE

}


Building  myBuilding{

     getResult(REFB_*_3_30) = TRUE

     getResult(REFB_*_3_31) = TRUE

}



CS{

         getBuildingUsage() = "facilities for animals and plants"

                                       

                              | "facilities for power generation"

                              | "correctional facilities and military installations.prison"

                              | "correctional facilities and military installations.reformatories 

                              | "myFactory"



	 OR (getBuildingUsage() = "detached houses"

             AND getBuildingUsage() != "detached houses.multi-user houses" 

                                     | "detached houses.multi-family houses" )



	 OR (getBuildingUsage() = "facilities for power generation" 

	 AND (getBuildingUsage() = "myBuilding"



	 OR (getBuildingUsage() = "cemeteries and related facilities"

	 AND getBuildingUsage() != "Crematorium") 





}



KS{

Floor myFloor{
Floor.number < 0
}

          getBuildingStoriesCount() >= 3 

	  AND isExist(myFloor) = TRUE

} 





Python Code 변환 예정


71
 		건축법 시행령 제 34조 1 항

① 건축물의 피난층(직접 지상으로 통하는 출입구가 있는 층을 말한다. 이하 같다) 외의 층에서는 피난층 또는 지상으로 통하는 직통계단(경사로를 포함한다. 이하 같다)을 거실의 각 부분으로부터 계단(거실로부터 가장 가까운 거리에 있는 계단을 말한다)에 이르는 보행거리가 30미터 이하가 되도록 설치하여야 한다. 다만, 건축물(지하층에 설치하는 것으로서 바닥면적의 합계가 300제곱미터 이상인 공연장·집회장·관람장 및 전시장은 제외한다)의 주요구조부가 내화구조 또는 불연재료로 된 건축물은 그 보행거리가 50미터(층수가 16층 이상인 공동주택은 40미터) 이하가 되도록 설치할 수 있으며, 자동화 생산시설에 스프링클러 등 자동식 소화설비를 설치한 공장으로서 국토해양부령으로 정하는 공장인 경우에는 그 보행거리가 75미터(무인화 공장인 경우에는 100미터) 이하가 되도록 설치할 수 있다. <개정 2009.7.16> 





// 건축법 시행령 34조 (직통계단의 설치) 1항

Check(EDBA_34_1){
     KS
}

KS{
Floor myFloor{
      isObjectProperty(Floor.isEscape) = TRUE
}

Space mySpace{
      getObjectProperty(Space.usage)="PerformanceHall"
      OR getObjectProperty(Space.usage)="AssemblyHall"
      OR getObjectProperty(Space.usage)="Auditorium"	
      OR getObjectProperty(Space.usage)="ExhibitionHall"
}

Door myDoor{
     isDirectlyAccessible(Door, Ground)=TRUE
}

Stair myStair{
     isObjectProperty(Stair.isDirect)=TRUE
     isAccessible(Stair,myFloor)=TRUE
     OR isAccessible(Stair,Ground)=TRUE
}

Ramp myRamp{
     isAccessible(Ramp,myFloor)=TRUE
     OR isAccessible(Ramp,Ground)=TRUE
}

Floor myFloor2{
     isObjectProperty(Floor.isEscape)=FALSE
     OR hasObject(Floor, myDoor)=FALSE
}

	Zone myZone{

		isDirectlyAccessible(myStair, Zone)=FALSE

	}

 

IF

	getFloorNumber(mySpace)>0

	getFloorArea(mySpace)<=300 m2

	isFireResistantStructure(MainStructuralPart)=TRUE

	OR isObjectProperty(MainStructuralPart.Material.nonCombustibility)=TRUE 

	THEN IF        getBuildingStoriesCount()>=16

	               getBuildingUsage()="MultiUnitHouse"

	          THEN ED= 40 

	ELSE THEN   ED=50               

	END IF



ELSE IF   

	getBuildingUsage() = "Factory" 

	isExist(ExtinguishingSystem)=TRUE 

	isObjectProperty(ExtinguishingSystem.isAutomatic)=TRUE

	getResult(REFB_8_2)=TRUE

	THEN IF   	getBuildingUsage() = "UnmannedFactory" 

			THEN ED=100

	ELSE THEN  ED=75

	END IF 



ELSE THEN ED=30

	END IF 



	(hasObject(myFloor,myStair)=TRUE

	hasObject(myZone, myStair)=TRUE

	getObjectDistance(Room,myStair, 1)<=ED)

	OR 

	(hasObject(myFloor,myRamp)=TRUE

	hasObject(myZone, myRamp)=TRUE

	getObjectDistance(Room,myRamp, 1)<=ED)

} 









max_route_length = 30

def Check():
    evac_storey_exist = False
    stories = SELECT('storey')

    for storey in stories:
        if storey.SELECT('is evacuation storey').BOOL() == True:
            evac_storey_exist = True
            break

    if evac_storey_exist == False:
        ERROR('피난층이 존재하지 않습니다.')
        return

    for storey in stories:
        if storey.SELECT('is evacuation storey').BOOL() == True:
            continue

        stairs = storey.SELECT('direct stair')

        if stairs.COUNT() == 0:
            storey.ERROR(storey.SELECT('name').STRING() + '에 직통계단이 존재하지 않습니다.')
            continue

        for space in storey.SELECT('space'):
            route_length = -1
            for route in space.SELECT('escape route', stairs):
                length = route.SELECT('length').UNIT('m').NUMBER()
                if length > 0:
                    if route_length < 0:
                        route_length = length
                    else:
                        route_length = min([route_length, length])
            if route_length < 0:
                space.ERROR(space.SELECT('name').STRING() + '부터 직통계단까지 갈 수 없다.')
            elif route_length > max_route_length:
                space.ERROR(space.SELECT('name').STRING() + '부터 직통계단까지의 거리가 멀다 : ' + str(route_length))
            else:
                space.SUCCESS(space.SELECT('name').STRING() + ' : ' + str(route_length)) 


72
 		건축법 시행령 제 34조 2 항

② 법 제49조제1항에 따라 피난층 외의 층이 다음 각 호의 어느 하나에 해당하는 용도 및 규모의 건축물에는 국토해양부령으로 정하는 기준에 따라 피난층 또는 지상으로 통하는 직통계단을 2개소 이상 설치하여야 한다. <개정 2009.7.16> 





//건축법 시행령 34조 (직통계단의 설치) 2항

Check(EDBA_34_2){

   IF (CS1 AND CS2) THEN KS

}



CS1{

	isObjectProperty(Floor.isEscape) = FALSE

}



CS2{

	getResult(EDBA_34_2_1)=TRUE

   	OR getResult(EDBA_34_2_2)=TRUE

   	OR getResult(EDBA_34_2_3)=TRUE  

   	OR getResult(EDBA_34_2_4)=TRUE

   	OR getResult(EDBA_34_2_5)=TRUE

}



KS{

        Floor myFloor{

        isObjectProperty(Floor.isEscape)=TRUE

        }



   	Stair myStair{

      		isObjectProperty(Stair.isDirect) = TRUE

      		isAccessible(myFloor, Stair)= TRUE

      		OR isAccessible(Ground,Stair) = TRUE

   	}



   	getObjectCount(myStair)>2 

   	getResult(REFB_8_1) = True

} 





Python Code 변환 예정


73
 		건축법 시행령 제 34조 2 항 1호

1. 문화 및 집회시설(전시장 및 동·식물원은 제외한다), 종교시설, 위락시설 중 주점영업 또는 장례식장의 용도로 쓰는 층으로서 그 층에서 해당 용도로 쓰는 바닥면적의 합계가 200제곱미터 이상인 것 





//건축법 시행령 34조 (직통계단의 설치) 2항1호

Check(EDBA_34_2_1){

KS

}

KS{

Floor myFloor1{

       getObjectUsage(Floor) ="ClassIINeighborhoodLivingFacility.PerformanceHall"

       OR  getObjectUsage(Floor)="ClassIINeighborhoodLivingFacility.ReligiousAssemblyFacility"

}



Floor myFloor2 {

       getObjectUsage(Floor)="CulturalAndAssemblyFacility"

       getObjectUsage(Floor) != "CulturalAndAssemblyFacility.ExhibitionHall"		

       getObjectUsage(Floor) != "CulturalAndAssemblyFacility.ZoologicalAndBotanicalGarden“

		

       getObjectUsage(Floor) = "ReligiousFacility"

       getObjectUsage(Floor) = “AmusementFacility.BarBusiness"

       getObjectUsage(Floor) = “AmusementFacility.FuneralParlors“

}



	 getTotalFloorArea(myFloor1.Space)>=300 m2

         OR getTotalFloorArea(myFloor2.Space)>=200 m2

        

} 





Python Code 변환 예정


74
 		건축법 시행령 제 34조 2 항 2호

2. 단독주택 중 다중주택·다가구주택, 제2종 근린생활시설 중 학원·독서실, 판매시설, 운수시설(여객용 시설만 해당한다), 의료시설(입원실이 없는 치과병원은 제외한다), 교육연구시설 중 학원, 노유자시설 중 아동 관련 시설·노인복지시설, 수련시설 중 유스호스텔, 숙박시설 또는 장례식장의 용도로 쓰는 3층 이상의 층으로서 그 층의 해당 용도로 쓰는 거실의 바닥면적의 합계가 200제곱미터 이상인 것 





//건축법 시행령 34조 (직통계단의 설치) 2항2호

Check(EDBA_34_2_2){



        Building myBuilding{

              getBuildingUsage()="DentalClinic"

        }


Space mySpace{
getSpaceUsage() = "Ward"
}
	Floor myFloor1 {

		getObjectProperty(Floor.number)>=3

                getObjectUsage(Floor)  = “DetachedHouse.MultiUserHouse”

		OR getObjectUsage(Floor)  = “DetachedHouse.MultiFamilyHouse”

		OR getObjectUsage(Floor)  = “ClassIINeighborhoodLivingFacility.EducationalInstitute”

		OR getObjectUsage(Floor)  = “ClassIINeighborhoodLivingFacility.ReadingRooms” 

                OR getObjectUsage(Floor)  = “CommercialFacility”

                OR getObjectUsage(Floor)  = “TransportationFacility.PassengerTrafficFacilities”

                OR ( getObjectUsage(Floor)  = “MedicalFacility” ADN hasObject(myBuilding, mySpace)=TRUE )

                OR getObjectUsage(Floor)  = “EducationAndResearchFacility.EducationalInstitutes” 

		OR getObjectUsage(Floor)  = “FacilitiesForTheAgedAndChildren.ChildrenRelatedFacilities” 

		OR getObjectUsage(Floor)  = “EducationAndResearchFacility.WelfareFacilityForTheAged” 

		OR getObjectUsage(Floor)  = “Trainingfacility.YouthHostel” 

		OR getObjectUsage(Floor)  = “LodgingFacility”

                

	}



	Floor myFloor2{

		 getObjectUsage(Floor)  = “ClassIINeighborhoodLivingFacility.FacilityForProvidingInternetComputerGameService”

		}



           getTotalFloorArea(myFloor1.Room)>= 200 m2

          OR getTotalFloorArea(myFloor2.Room)>= 300 m2	

} 





Python Code 변환 예정


75
 		건축법 시행령 제 34조 3 항

③ 초고층 건축물에는 피난층 또는 지상으로 통하는 직통계단과 직접 연결되는 피난안전구역(초고층 건축물의 피난·안전을 위하여 지상층으로부터 최대 30개 층마다 설치하는 대피공간을 말한다. 이하 같다)을 설치하여야 한다. <신설 2009.7.16> 





// 건축법 시행령 제 34조 (직통계단의 설치) 3항

check(EDBA_34_3){

		IF CS THEN KS ENDIF

}



CS{

isObjectProperty(Building.isHighriseBuilding) = TRUE

}

KS{

		Stair myStair{

				isObjectProperty(Stair.isDirect) = TRUE			

		}

		Zone myZone{

				isObjectProperty(Zone.isEgressSafetyZone) = TRUE

		}

		Floor myFloor{

				isObjectProperty(Floor.isEscape) = TRUE

		}

isGoThrough(myFloor, myZone, myStair) = TRUE

		OR isGoThrough(myFloor, Ground, myStair) = TRUE



		getObjectCount(myZone) >= getBuildingStoriesCount()/30

} 





Python Code 변환 예정


76
 		건축법 시행령 제 34조 4 항

④ 제3항에 따른 피난안전구역의 규모와 설치기준은 국토해양부령으로 정한다. <신설 2009.7.16> 





// 건축법 시행령 34조 (직통계단의 설치) 4항

check(EDBA_34_4){

		IF !CS THEN KS ENDIF

}

CS{

		Stair myStair{

				isObjectProperty(Stair.isDirect) = TRUE

		}

		Floor myFloor{

				isObjectProperty(Floor.isEscape) = TRUE

		}

		isDirectlyAccessible(myStair, myFloor) = TRUE

		OR isDirectlyAccessible(myStair, Ground) = TRUE

}

				

KS{

		isObjectProperty(Building.isQuasiHighriseBuilding) = TRUE

		Stair myStair{

				isObjectProperty(Stair.isDirect) = TRUE			

		}

		Zone myZone{

				isObjectProperty(Zone.isEgressSafetyZone) = TRUE

		}

		Floor myFloor{

				isObjectProperty(Floor.isEscape) = TRUE

		}

                isGoThrough(myFloor, myZone, myStair) = TRUE

		OR isGoThrough(myFloor, Ground, myStair) = TRUE

		(getBuildingStoriesCount()/2)-5 < getFloorNumber(myZone)

                getFloorNumber(myZone) < (getBuildingStoriesCount()/2)+5

} 





Python Code 변환 예정


77
 		건축법 시행령 제 35조 5 항

⑤ 건축물의 5층 이상인 층으로서 문화 및 집회시설 중 전시장 또는 동·식물원, 판매시설, 운수시설(여객용 시설만 해당한다), 운동시설, 위락시설, 관광휴게시설(다중이 이용하는 시설만 해당한다) 또는 수련시설 중 생활권 수련시설의 용도로 쓰는 층에는 제34조에 따른 직통계단 외에 그 층의 해당 용도로 쓰는 바닥면적의 합계가 2천 제곱미터를 넘는 경우에는 그 넘는 2천 제곱미터 이내마다 1개소의 피난계단 또는 특별피난계단(4층 이하의 층에는 쓰지 아니하는 피난계단 또는 특별피난계단만 해당한다)을 설치하여야 한다. <개정 2008.10.29, 2009.7.16> 





//건축법 시행령 35조 (피난계단의 설치) 5항
check(EDBA_35_5){
	IF (CS) THEN KS
}

CS{
	Floor myFloor{
		Floor.number >= 5
		OR Floor.usage = "CulturalAndAssemblyFacility.ExhibitionHall"
		OR Floor.usage = "CulturalAndAssemblyFacility.ZoologicalAndBotanicalGarden"
		OR Floor.usage = "CommercialFacility"
		OR Floor.usage = "PassengerTrafficFacilities“??
		OR Floor.usage = "SportsFacility"
		OR Floor.usage = "AmusementFacility"
		OR Floor.usage = "FacilityForTourismAndRelaxation“???
		OR Floor.usage = "Trainingfacility.TrainingFacilityInLivingZone“
	}

	isExist(myFloor)=True           
}

KS{	
	Stair myStair2{
		isObjectProperty(Stair.isSpecialEscape) = True
		OR isObjectProperty(Stair.isEscape) = True
	}

	getResult(EDBA_34) = TRUE

	IF (getTotalFloorArea(myFloor.Space) >= 2000m2) 		
		THEN getObjectCount(myStair2) >= 1+ getFloorArea(myFloor.Space)/2000
}
 





Python Code 변환 예정


78
 		건축법 시행령 제 40조 3 항

③ 층수가 11층 이상인 건축물로서 11층 이상인 층의 바닥면적의 합계가 1만 제곱미터 이상인 건축물(지붕을 평지붕으로 하는 경우만 해당한다)의 옥상에는 국토해양부령으로 정하는 기준에 따라 헬리포트를 설치하거나 헬리콥터를 통하여 인명 등을 구조할 수 있는 공간을 확보하여야 한다. <개정 2009.7.16> 





//건축법 시행령 40조 (옥상광장 등의 설치) 3항
Check(EDBA_40_3){
  IF (CS) THEN KS 
}

CS{
	Floor myFloor{
		Floor.number > 11
	}

   	getBuildingStoriesCount() > 11
   	getTotalFloorArea(myFloor) > 10000m2
}

KS{
  getResult(EDBA_40_3_1) = True
  getResult(EDBA_40_3_2) = True
}
 





Python Code 변환 예정


79
 		건축법 시행령 제 87조 6 항

⑥ 연면적이 500제곱미터 이상인 건축물의 대지에는 국토해양부령으로 정하는 바에 따라 「전기사업법」 제2조제2호에 따른 전기사업자가 전기를 배전(配電)하는 데 필요한 전기설비를 설치할 수 있는 공간을 확보하여야 한다. <신설 2009.7.16> 





//건축법 시행령 87조 (건축설비 설치의 원칙) 6항

Check(EDBA_87_6){
      IF CS THEN KS 
}

CS{
    getGrossFloorArea()>= 500 m2
}

KS{
    getResult(RFB_20-2)=True
} 





Python Code 변환 예정


80
 		국토의 계획 및 이용에 관한 법률 제 78조 1 항 1호 가 목

가. 주거지역: 500퍼센트 이하 





// 국토의 계획 및 이용에 관한 법률 78조 (용도지역에서의 용적률) 1항 1호 가목

Check(LPUA_78_1_1_가){
IF CS THEN KS
}

CS{
getObjectProperty(Building.SpecialPurposeArea.type) = "ResidentialArea"
}

KS{
getFloorAreaRatio() <= 500%
}
 





Python Code 변환 예정


81
 		국토의 계획 및 이용에 관한 법률 제 78조 1 항 1호 나 목

나. 상업지역: 1천500퍼센트 이하 





// 국토의 계획 및 이용에 관한 법률 78조 (용도지역에서의 용적률) 1항 1호 나목

Check(LPUA_78_1_1_나){
IF CS THEN KS
}

CS{
getObjectProperty(Building.SpecialPurposeArea.type) = "CommercialArea"
}

KS{
getFloorAreaRatio() <= 1500%
}
 





Python Code 변환 예정


82
 		국토의 계획 및 이용에 관한 법률 제 78조 1 항 1호 다 목

다. 공업지역: 400퍼센트 이하 





// 국토의 계획 및 이용에 관한 법률 78조 (용도지역에서의 용적률) 1항 1호 다목

Check(LPUA_78_1_1_다){
IF CS THEN KS
}

CS{
getObjectProperty(Building.SpecialPurposeArea.type) = "IndustrialArea"
}

KS{
getFloorAreaRatio() <= 400%
}
 





Python Code 변환 예정


83
 		국토의 계획 및 이용에 관한 법률 제 78조 1 항 1호 라 목

라. 녹지지역: 100퍼센트 이하 





// 국토의 계획 및 이용에 관한 법률 78조 (용도지역에서의 용적률) 1항 1호 라목

Check(LPUA_78_1_1_라){
IF CS THEN KS
}

CS{
getObjectProperty(Building.SpecialPurposeArea.type) = "GreenArea"
}

KS{
getFloorAreaRatio() <= 100%
}
 





Python Code 변환 예정


84
 		국토의 계획 및 이용에 관한 법률 제 78조 1 항 2호 가 목

가. 보전관리지역: 80퍼센트 이하 





// 국토의 계획 및 이용에 관한 법률 78조 (용도지역에서의 용적률) 1항 2호 가목

Check(LPUA_78_1_2_가){
IF CS THEN KS
}

CS{
getObjectProperty(Building.SpecialPurposeArea.type) = "ConservationManagementArea"
}

KS{
getFloorAreaRatio() <= 80%
}
 





Python Code 변환 예정


85
 		국토의 계획 및 이용에 관한 법률 제 78조 1 항 2호 나 목

나. 생산관리지역: 80퍼센트 이하 





// 국토의 계획 및 이용에 관한 법률 78조 (용도지역에서의 용적률) 1항 2호 나목

Check(LPUA_78_1_2_나){
IF CS THEN KS
}

CS{
getObjectProperty(Building.SpecialPurposeArea.type) = "ProductionManagementArea"
}

KS{
getFloorAreaRatio() <= 80%
}
 





Python Code 변환 예정


86
 		국토의 계획 및 이용에 관한 법률 제 78조 1 항 2호 다 목

다. 계획관리지역: 100퍼센트 이하 





// 국토의 계획 및 이용에 관한 법률 78조 (용도지역에서의 용적률) 1항 2호 다목

Check(LPUA_78_1_2_다){
IF CS THEN KS
}

CS{
getObjectProperty(Building.SpecialPurposeArea.type) = "PlanningManagementArea"
}

KS{
getFloorAreaRatio() <=100%
}
 





Python Code 변환 예정


87
 		국토의 계획 및 이용에 관한 법률 제 78조 1 항 3호

3. 농림지역: 80퍼센트 이하 





// 국토의 계획 및 이용에 관한 법률 78조 (용도지역에서의 용적률) 1항 3호

Check(LPUA_78_1_3){
IF CS THEN KS
}

CS{
getObjectProperty(Building.SpecialPurposeArea.type) = "AgriculturalAndForestryArea"
}

KS{
getFloorAreaRatio() <= 80%
}
 





Python Code 변환 예정


88
 		국토의 계획 및 이용에 관한 법률 제 78조 1 항 4호

4. 자연환경보전지역: 80퍼센트 이하 





// 국토의 계획 및 이용에 관한 법률 78조 (용도지역에서의 용적률) 1항 4호

Check(LPUA_78_1_4){
IF CS THEN KS
}

CS{
getObjectProperty(Building.SpecialPurposeArea.type) = "NaturalEnvironmentConservationArea"
}

KS{
getFloorAreaRatio() <= 80%
}
 





Python Code 변환 예정


89
 		국토의 계획 및 이용에 관한 법률 제 78조 3 항

③ 제77조제3항제2호부터 제5호까지의 규정에 해당하는 지역에서의 용적률에 대한 기준은 제1항과 제2항에도 불구하고 200퍼센트 이하의 범위에서 대통령령으로 정하는 기준에 따라 특별시·광역시·시 또는 군의 조례로 따로 정한다. 





// 국토의 계획 및 이용에 관한 법률 78조 (용도지역에서의 용적률) 3항

Check(LPUA_78_3){
IF CS THEN KS
}
CS{
	getResult(LPUA_77_3_2) = TRUE
	getResult(LPUA_77_3_3) = TRUE
	getResult(LPUA_77_3_4) = TRUE
	getResult(LPUA_77_3_5) = TRUE
}
KS{
	BFA = getObjectProperty(Building.floorAreaRatio)
	BFA <= 200
	getResult(Unimplemented_LGMO) = TRUE 





Python Code 변환 예정


90
 		국토의 계획 및 이용에 관한 법률 시행령 제 46조 10 항

⑩제1항 내지 제4항 및 제7항의 규정에 의하여 완화하여 적용되는 건폐율 및 용적률은 당해 용도지역 또는 용도지구에 적용되는 건폐율의 150퍼센트 및 용적률의 200퍼센트를 각각 초과할 수 없다. <개정 2004.1.20.> 





//국토의 계획 및 이용에 관한 법률 시행령 46조 (도시지역 내 지구단위계획구역에서의 건폐율 등의 완화적용) 10항

Check(EDLPUA_46_10){
     IF CS THEN KS
}
CS{
	getResult(EDLPUA_46_1)=TRUE
	OR getResult(EDLPUA_46_2)=TRUE
	OR getResult(EDLPUA_46_3)=TRUE
	OR getResult(EDLPUA_46_4)=TRUE
	OR getResult(EDLPUA_46_7)=TRUE
}
KS{
	BBTR = getObjectProperty(Building.buildingToLandRatio)
	BFAR = getObjectProperty(Building.floorAreaRatio)

	(BBTR < 1.5*getObjectProperty(Building.SpecialPurposeArea.buildingToLandRatio)
	OR BBTR < 1.5*getObjectProperty(Building.SpecialPurposeZone.buildingToLandRatio))

	(BFAR < 2*getObjectProperty(Building.SpecialPurposeArea.floorAreaRatio)
	OR BFAR < 2*getObjectProperty(Building.SpecialPurposeZone.floorAreaRatio))

} 





Python Code 변환 예정


91
 		국토의 계획 및 이용에 관한 법률 시행령 제 47조 1 항

①지구단위계획구역(도시지역 외에 지정하는 경우로 한정한다. 이하 이 조에서 같다)에서는 법 제52조제3항에 따라 지구단위계획으로 당해 용도지역 또는 개발진흥지구에 적용되는 건폐율의 150퍼센트 및 용적률의 200퍼센트 이내에서 건폐율 및 용적률을 완화하여 적용할 수 있다. <개정 2005.1.15, 2007.4.19, 2012.4.10> 





//EDLPUA 47조 1항



Check(EDLPUA_47_1){

     IF CS THEN KS

}



CS{

     getObjectUsage(Zone)="DistrictUnitPlanningZones"

}



KS{
SpecialPurposeArea mySpecialPurposeArea{
getObjectProperty(Building.SpecialPurposeArea.type) = "DevelopmentPromotionDistrict"
}

BLR= getObjectProperty(Building.SpecialPurposeArea.buildingToLandRatio) OR getObjectProperty(mySpecialPurposeArea.buildingToLandRatio)

FAR= getObjectProperty(Building.SpecialPurposeArea.floorAreaRatio) OR getObjectProperty(mySpecialPurposeArea.floorAreaRatio)


   getBuildingToLandRatio()<=BLR*150%

   getFloorAreaRatio(FAR)<=200%

} 





Python Code 변환 예정


92
 		국토의 계획 및 이용에 관한 법률 시행령 제 85조 1 항 1호

1. 제1종전용주거지역 : 50퍼센트 이상 100퍼센트 이하 





//	국토의 계획 및 이용에 관한 법률 시행령 85조 (용도지역 안에서의 용적률) 1항 1호
Check(EDLPUA_85_1_1){
	IF CS THEN KS
}

CS{
	getBuildingUsage() = "ClassIExclusiveResidentialArea"
}

KS{
	getFloorAreaRatio() >= 50
	getFloorAreaRatio() <= 100
} 





Python Code 변환 예정


93
 		국토의 계획 및 이용에 관한 법률 시행령 제 85조 1 항 2호

2. 제2종전용주거지역 : 100퍼센트 이상 150퍼센트 이하 





//	국토의 계획 및 이용에 관한 법률 시행령 85조 (용도지역 안에서의 용적률) 1항 2호
Check(EDLPUA_85_1_2){
	IF CS THEN KS
}

CS{
	getBuildingUsage() = "ClassIIExclusiveResidentialArea"
}

KS{
	getFloorAreaRatio() >= 100
	getFloorAreaRatio() <= 150
} 





Python Code 변환 예정


94
 		국토의 계획 및 이용에 관한 법률 시행령 제 85조 1 항 3호

3. 제1종일반주거지역 : 100퍼센트 이상 200퍼센트 이하 





//	국토의 계획 및 이용에 관한 법률 시행령 85조 (용도지역 안에서의 용적률) 1항 3호
Check(EDLPUA_85_1_3){
	IF CS THEN KS
}

CS{
	getBuildingUsage() = "ClassIGeneralResidentialArea"
}

KS{
	getFloorAreaRatio() >= 100
	getFloorAreaRatio() <= 200
} 





Python Code 변환 예정


95
 		국토의 계획 및 이용에 관한 법률 시행령 제 85조 1 항 4호

4. 제2종일반주거지역 : 150퍼센트 이상 250퍼센트 이하 





//	국토의 계획 및 이용에 관한 법률 시행령 85조 (용도지역 안에서의 용적률) 1항 4호
Check(EDLPUA_85_1_4){
	IF CS THEN KS
}

CS{
	getBuildingUsage() = "ClassIIGeneralResidentialArea"
}

KS{
	getFloorAreaRatio() >= 150
	getFloorAreaRatio() <= 250
} 





Python Code 변환 예정


96
 		국토의 계획 및 이용에 관한 법률 시행령 제 85조 1 항 5호

5. 제3종일반주거지역 : 200퍼센트 이상 300퍼센트 이하 





//	국토의 계획 및 이용에 관한 법률 시행령 85조 (용도지역 안에서의 용적률) 1항 5호
Check(EDLPUA_85_1_5){
	IF CS THEN KS
}

CS{
	getBuildingUsage() = "ClassIIIGeneralResidentialArea"
}

KS{
	getFloorAreaRatio() >= 200
	getFloorAreaRatio() <= 300
} 





Python Code 변환 예정


97
 		국토의 계획 및 이용에 관한 법률 시행령 제 85조 1 항 6호

6. 준주거지역 : 200퍼센트 이상 500퍼센트 이하 





//	국토의 계획 및 이용에 관한 법률 시행령 85조 (용도지역 안에서의 용적률) 1항 6호
Check(EDLPUA_85_1_6){
	IF CS THEN KS
}

CS{
	getBuildingUsage() = "QuasiResidentialArea"
}

KS{
	getFloorAreaRatio() >= 200
	getFloorAreaRatio() <= 500
} 





Python Code 변환 예정


98
 		국토의 계획 및 이용에 관한 법률 시행령 제 85조 1 항 7호

7. 중심상업지역 : 400퍼센트 이상 1천500퍼센트 이하 





//	국토의 계획 및 이용에 관한 법률 시행령 85조 (용도지역 안에서의 용적률) 1항 7호
Check(EDLPUA_85_1_7){
	IF CS THEN KS
}

CS{
	getBuildingUsage() = "CentralCommercialArea"
}

KS{
	getFloorAreaRatio() >= 400
	getFloorAreaRatio() <= 1500
} 





Python Code 변환 예정


99
 		국토의 계획 및 이용에 관한 법률 시행령 제 85조 1 항 8호

8. 일반상업지역 : 300퍼센트 이상 1천300퍼센트 이하 





//	국토의 계획 및 이용에 관한 법률 시행령 85조 (용도지역 안에서의 용적률) 1항 8호
Check(EDLPUA_85_1_8){
	IF CS THEN KS
}

CS{
	getBuildingUsage() = "GeneralCommercialArea"
}

KS{
	getFloorAreaRatio() >= 300
	getFloorAreaRatio() <= 1300
} 





Python Code 변환 예정


100
 		국토의 계획 및 이용에 관한 법률 시행령 제 85조 1 항 9호

9. 근린상업지역 : 200퍼센트 이상 900퍼센트 이하 





//	국토의 계획 및 이용에 관한 법률 시행령 85조 (용도지역 안에서의 용적률) 1항 9호
Check(EDLPUA_85_1_9){
	IF CS THEN KS
}

CS{
	getBuildingUsage() = "NeighboringCommercialArea"
}

KS{
	getFloorAreaRatio() >= 200
	getFloorAreaRatio() <= 900
} 





Python Code 변환 예정


  ◁prev 1   2   3   next▷