(2025-05-05 기준) 설계품질검토용 건축법 및 관련법규 - KBIMCode (문장단위)
      KBIMCode - KBimAssess Python Code     KBIMCode - 체크리스트 단위     KBIMCode - 조항단위
    1      
1 / 1 page Total 2500 / 4000 records
Select
ALL
None
#
Law
Jo
JO Name
HANG
HO
MOK
Text
Search!
1
건축물의 구조기준 등에 관한 규칙 제 35조

제35조(개구부)





//건축물의 구조기준 등에 관한 규칙 35조 (개구부) 1항
Check(RSSB_35_1){
        getResult(RSSB_28_2) = TRUE AND getResult(RSSB_28_1) = TRUE AND getResult(RSSB_3_3) = TRUE AND IF CS THEN KS
}
CS{
	Wall myWall1{
	isObjectProperty(myWall.Structure.isMansoryStructure) = TRUE
	}
	isInstalled(Window, myWall) = TRUE
	OR isInstalled(Door, myWall) = TRUE
	OR isInstalled(Opening, myWall) = TRUE
}
KS{
	getResult(RSSB_35_1_1) = TRUE
	getResult(RSSB_35_1_2) = TRUE
} 




Python Code 변환 예정



2
건축물의 설비기준 등에 관한 규칙 제 10조 2호 나 목

나. 승강장은 각층의 내부와 연결될 수 있도록 하되, 그 출입구(승강로의 출입구를 제외한다)에는 갑종방화문을 설치할 것. 다만, 피난층에는 갑종방화문을 설치하지 아니할 수 있다.





//건축물의 설비기준 등에 관한 규칙 10조 (비상용승강기의 승강장 및 승강로의 구조) 2호 나목
Check(RFB_10_0_2_나){
	KS1 AND IF !(CS) THEN KS2
}
	Space mySpace{
	hasObject(Floor,Space)=TRUE
	isAccessible(Platform,Space) = TRUE
	}
KS1{
	isExist(mySpace)=TRUE
}
CS{
	isAccessible(Platform, myFloor) = TRUE
}
KS2{
	Door myDoor{
		hasSpace(Platform, Door) =TRUE
		hasSpace(mySpace, Door) =TRUE
		Door != ElevatorShaft.Opening
	}
	isObjectProperty(myDoor.isStrictFireproofDoor)= TRUE
}
 




Python Code 변환 예정



3
건축물의 설비기준 등에 관한 규칙 제 13조 1 항 1호

1. 보일러는 거실외의 곳에 설치하되, 보일러를 설치하는 곳과 거실사이의 경계벽은 출입구를 제외하고는 내화구조의 벽으로 구획할 것





//	건축물의 설비기준 등에 관한 규칙 13조 (개별난방설비) 1항 1호
Check(RFB_13_1_1){
	KS
}

KS{
	hasSpace(Room, Boiler) = FALSE
	
	Room myRoom{
		hasSpace(Room, Boiler) = TRUE
	}

	Room myRoom2{
		hasAdjacent(myRoom, Room) = TRUE
	}

	Wall myWall{
		isPartitioned(myRoom, myRoom2, Wall) = TRUE
		hasObject(Wall, Door.isEntrance) = FALSE
		isObjectProperty(Wall.isfireResistantStructure) = TRUE
	}

	isExist(myWall) = TRUE
} 




Python Code 변환 예정



4
건축물의 설비기준 등에 관한 규칙 제 13조 1 항 6호

6. 오피스텔의 경우에는 난방구획마다 내화구조로 된 벽·바닥과 갑종방화문으로 된 출입문으로 구획할 것





//	건축물의 설비기준 등에 관한 규칙 13조 (개별난방설비) 1항 6호

Check(RFB_13_1_6){

	IF CS THEN KS

}



CS{

	getBuildingUsage() = "Officetel"

}



KS{

	Wall myWall{

		isObjectProperty(Wall.isfireResistantStructure)

	}



	FloorSlab myFloorSlab{

		isObjectProperty(FloorSlab.isFireResistantStructure) = TRUE

	}



	Door myDoor{

		isObjectProperty(Door.isStrictFireproofDoor) = TRUE

	}


Zone myZone{
isObjectProperty(Zone.isHeatingSection) = TRUE
}
	isPartitioned(myZone, myWall) = TRUE

	OR isPartitioned(myZone, myFloorSlab) = TRUE

	OR isPartitioned(myZone, myDoor) = TRUE

} 




Python Code 변환 예정



5
건축물의 설비기준 등에 관한 규칙 제 13조 2 항

②가스보일러에 의한 난방설비를 설치하고 가스를 중앙집중공급방식으로 공급하는 경우에는 제1항의 규정에 불구하고 가스관계법령이 정하는 기준에 의하되, 오피스텔의 경우에는 난방구획마다 내화구조로 된 벽·바닥과 갑종방화문으로 된 출입문으로 구획하여야 한다. <신설 1999.5.11.>





//	건축물의 설비기준 등에 관한 규칙 13조 (개별난방설비) 2항

Check(RFB_13_2){

	IF CS THEN KS

}



CS{

	getBuildingUsage() = "Officetel"

}



KS{

	Wall myWall{

		isObjectProperty(Wall.isfireResistantStructure)

	}



	FloorSlab myFloorSlab{

		isObjectProperty(FloorSlab.isFireResistantStructure) = TRUE

	}



	Door myDoor{

		isObjectProperty(Door.isStrictFireproofDoor) = TRUE

	}


Zone myZone{
isObjectProperty(Zone.isHeatingSection) = TRUE
}
	isPartitioned(myZone, myWall) = TRUE

	OR isPartitioned(myZone, myFloorSlab) = TRUE

	OR isPartitioned(myZone, myDoor) = TRUE

} 




Python Code 변환 예정



6
건축물의 에너지절약설계기준 제 5조 11호 나 목

나. "역률개선용콘덴서”라 함은 역률을 개선하기 위하여 변압기 또는 전동기 등에 병렬로 설치하는 콘덴서를 말한다.





//	비상콘센트설비의 화재안전기준(nfsc 504) 4조 (전원 및 콘센트 등) 5항 3호
Check(NFSC504_4_5_3){
	IF (CS1 THEN KS1) OR (CS2 THEN KS2)
}

CS1{
	Building myBuilding{
		getBuildingUsage() = "ApartmentHouse"
	}

	Floor myFloor{
		getFloorArea(Floor) < 1000m2
	}

	Floor myFloor2{
		hasSpace(myBuilding, Floor) = TRUE
	}

	isExist(myFloor) = TRUE
	OR isExist(myFloor2) = TRUE
}

KS1{
	Door myDoor{
		isObjectProperty(Door.isEntrance) = TRUE
	}

	getObjectDistance(myDoor.Stair.Space, EmergencyPowerOutlet) < 5m
	OR getObjectDistance(myDoor.Stair.AncillaryRoom, EmergencyPowerOutlet) < 5m
}

CS2{
	Building myBuilding{
		getBuildingUsage() = "ApartmentHouse"
	}

	Floor myFloor{
		getFloorArea(Floor) >= 1000m2
		hasSpace(myBuilding, Floor) = FALSE
	}

	isExist(myFloor) = TRUE
}

KS2{
	Door myDoor{
		isObjectProperty(Door.isEntrance) = TRUE
	}

	getObjectDistance(myDoor.Stair.Space, EmergencyPowerOutlet) < 5m
	OR getObjectDistance(myDoor.Stair.AncillaryRoom, EmergencyPowerOutlet) < 5m
} 




Python Code 변환 예정



7
건축물의 에너지절약설계기준 제 5조 11호 다 목

다. "전압강하”라 함은 인입전압(또는 변압기 2차전압)과 부하측전압과의 차를 말하며 저항이나 인덕턴스에 흐르는 전류에 의하여 강하하는 전압을 말한다.





//	비상콘센트설비의 화재안전기준(nfsc 504) 4조 (전원 및 콘센트 등) 5항 3호 가목
Check(NFSC504_4_5_3_1){
	IF CS THEN KS
}

Door myDoor{
		isObjectProperty(Door.isEntrance) = TRUE
	}

Floor myFloor{
	getFloorNumber(Floor) < 0
}

CS{
	getFloorArea(myFloor) >= 3000m2
}

KS{
	getObjectDistance(myDoor.Stair.Space, EmergencyPowerOutlet) > 25m
	OR getObjectDistance(myDoor.Stair.AncillaryRoom, EmergencyPowerOutlet) > 25m
}
 




Python Code 변환 예정



8
건축물의 에너지절약설계기준 제 5조 11호 라 목

라. "고효율조명기기”라 함은 광원, 안정기, 기타 조명기기로서 고효율인증제품 또는 산업통상자원부 고시 「효율관리기자재 운용규정」에서 고효율조명기기로 정의하는 제품을 말한다.





//	비상콘센트설비의 화재안전기준(nfsc 504) 4조 (전원 및 콘센트 등) 5항 3호 나목
Check(NFSC504_4_5_3_2){
	IF CS THEN KS
}

CS{
	getResult(NFSC504_4_5_3_1) = FALSE
}

KS{
	getObjectDistance(myDoor.Stair.Space, EmergencyPowerOutlet) > 25m
	OR getObjectDistance(myDoor.Stair.AncillaryRoom, EmergencyPowerOutlet) > 25m
}
 




Python Code 변환 예정



9
건축물의 에너지절약설계기준 제 5조 11호 바 목

바. "수용률”이라 함은 부하설비 용량 합계에 대한 최대 수용전력의 백분율을 말한다.





//	비상콘센트설비의 화재안전기준(nfsc 504) 5조 (보호함) 1호

Check(NFSC504_5_0_1){

	KS

}



KS{

	isInstalled(Door, EmergencyPowerOutletProtectiveBox) = TRUE

} 




Python Code 변환 예정



10
건축물의 에너지절약설계기준 제 5조 5호

5. "고효율에너지기자재인증제품”(이하 "고효율인증제품”이라 한다)이라 함은 산업통상자원부 고시 「고효율에너지기자재 보급촉진에 관한규정」(이하 "고효율인증규정”이라 한다)에서 정한 기준을 만족하여 에너지관리공단에서 인증서를 교부받은 제품을 말한다.





//	옥내소화전설비의 화재안전기준(nfsc 102) 6조 (배관 등) 6항

Check(NFSC102_6_6){

	IF (CS1 THEN KS1) OR (CS2 THEN KS2) OR (CS3 THEN KS3) OR (CS4 THEN KS4)

}

Port myPort{
Port.typeForWater = "IndoorFireHydrantDischarge"
}

	Pipe myPipe{

		isObjectProperty(Pipe.isBranchLines) = TRUE

		isConnectedTo(Pipe, myPort) = TRUE

	}



	Pipe myPipe2{

		isObjectProperty(Pipe.isRiser) = TRUE

	}



CS1{

	getObjectProperty(myPipe.systemType) = "HoseReelHydrantSystem"

}



KS1{

	getObjectProperty(myPipe.diameter) >= 25mm

}



CS2{

	getObjectProperty(myPipe.systemType) != "HoseReelHydrantSystem"

}



KS2{

	getObjectProperty(myPipe.diameter) >= 40mm

}



CS3{

	getObjectProperty(myPipe2.systemType) = "HoseReelHydrantSystem"

}



KS3{

	getObjectProperty(myPipe2.diameter) >= 32mm

}



CS4{

	getObjectProperty(myPipe2.systemType) != "HoseReelHydrantSystem"

}



KS4{

	getObjectProperty(myPipe2.diameter) >= 50mm

} 




Python Code 변환 예정



11
건축물의 에너지절약설계기준 제 5조 9호 다 목

다. "거실의 외벽”이라 함은 거실의 벽 중 외기에 직접 또는 간접 면하는 부위를 말한다. 다만, 복합용도의 건축물인 경우에는 해당 용도로 사용하는 공간이 다른 용도로 사용하는 공간과 접하는 부위를 외벽으로 볼 수 있다.





//  옥내소화전설비의 화재안전기준(nfsc 102) 6조 (배관 등) 13항 3호

Check(NFSC503A_6_13_3){

  KS

}

KS{

	Port myPort{ 

	getObjectProperty(IndoorFireHydrantSystem.Port.typeForWater) = "FireDepartmentConnection" 

 	}

 	getObjectVerticalDistance(Ground, myPort) >= 0.5m

 	getObjectVerticalDistance(Ground, myPort) <= 1m

} 




Python Code 변환 예정



12
건축물의 에너지절약설계기준 제 5조 9호 러 목

러. "일사조절장치"라 함은 태양열의 실내 유입을 조절하기 위한 목적으로 설치하는 장치를 말한다.





//  옥내소화전설비의 화재안전기준(nfsc 102) 7조 (함 및 방수구 등) 2항 1호

Check(NFSC503A_7_2_1){

	KS2 AND IF CS THEN KS1

}

KS2{

	isInstalled(옥내소화전방수구, SpecificFireFightingBuilding.Floor.One) = TRUE

	getElementDistance(SpecificFireFightingBuilding.Wall|SpecificFireFightingBuilding.Column, 옥내소화전방수구.One) <= 25m

}

CS{

	getBuildingUsage() = "MultiUnitHouse"

}	

KS2{

	Door myDoor{

	isObjectProperty(Door.isEntrance) = TRUE

	}

	Floor myFloor{

	isInstalled(myDoor, Floor) = TRUE

	}

Port myPort{
Port.typeForWater="IndoorFireHydrantDischarge"
}
	isInstalled(myPort, myFloor.One) = TRUE

} 




Python Code 변환 예정



13
건축물의 에너지절약설계기준 제 5조 9호 마 목

마. "최상층에 있는 거실의 반자 또는 지붕”이라 함은 최상층으로서 거실인 경우의 반자 또는 지붕을 말하며, 기타 층으로서 거실의 반자 또는 지붕 부위가 외기에 직접 또는 간접적으로 면한 부위를 포함한다. 다만, 복합용도의 건축물인 경우에는 다른 용도로 사용하는 공간과 접하는 부위를 최상층에 있는 거실의 반자 또는 지붕으로 볼 수 있다.





//  옥내소화전설비의 화재안전기준(nfsc 102) 7조 (함 및 방수구 등) 2항 2호

Check(NFSC503A_7_2_2){

  KS

}

KS{
Port myPort{
Port.typeForWater="IndoorFireHydrantDischarge"
}

	getObjectVerticalLocation(myPort, FloorSlab) > 0

 	getObjectVerticalDistance(FloorSlab, myPort) <= 1.5m

} 




Python Code 변환 예정



14
건축물의 에너지절약설계기준 제 5조 9호 바 목

바. "외기에 직접 면하는 부위”라 함은 바깥쪽이 외기이거나 외기가 직접 통하는 공간에 면한 부위를 말한다.





//  옥내소화전설비의 화재안전기준(nfsc 102) 7조 (함 및 방수구 등) 2항 3호

Check(NFSC503A_7_2_3){

  IF (CS1 THEN KS1) OR (CS2 THEN KS2)

}

CS1{


	! HoseReelIndoorFireHydrantSystem

}

KS2{

	isObjectPropertyt(Hose.diameter) >= 40mm

}

CS1{

	HoseReelIndoorFireHydrantSystem

}

KS2{

	isObjectPropertyt(Hose.diameter) >= 25mm

} 




Python Code 변환 예정



15
건축물의 에너지절약설계기준 제 5조 9호 아 목

아. "방풍구조”라 함은 출입구에서 실내외 공기 교환에 의한 열출입을 방지할 목적으로 설치하는 방풍실 또는 회전문 등을 설치한 방식을 말한다.





//  옥내소화전설비의 화재안전기준(nfsc 102) 7조 (함 및 방수구 등) 3항 1호



Check(NFSC503A_7_3_1){

	KS

}

KS{

	IndicatingLamp myIndicatingLamp{

	isObjectProerpty(IndicatingLamp.systemType) = "IndoorFireHydrantSystem"

	}

	isInstalled(myIndicatingLamp, IndoorFireHydrantSystemCabinet.TopSurface) = TRUE

} 




Python Code 변환 예정



16
건축물의 에너지절약설계기준 제 5조 9호 자 목

자. "기밀성 창”, "기밀성 문”이라 함은 창 및 문으로서 한국산업규격(KS) F 2292 규정에 의하여 기밀성 등급에 따른 기밀성이 1∼5등급(통기량 5㎥/h·㎡ 미만)인 것을 말한다.





//	옥내소화전설비의 화재안전기준(NFSC 102) 7조 (함 및 방수구 등) 3항 2호

Check(NFSC102_7_3_2){

	KS

}



KS{

	isInstalled(IndicatingLamp, IndoorFireHydrantSystemCabinet, a, Top) = TRUE

} 




Python Code 변환 예정



17
건축물의 에너지절약설계기준 제 6조 1호 가 2) 목

2) 지면 및 토양에 접한 바닥 부위로서 난방공간의 외벽 내표면까지의 모든 수평거리가 10미터를 초과하는 바닥부위





//스프링클러설비의 화재안전기준(NFSC 103) 6조 (폐쇄형스프링클러설비의 방호구역·유수검지장치) 4호 



Check(NFSC103_6_4){

    KS 

}



KS{

	Material myMaterial{

	getObjectProperty(Object.Material)="ProtectiveWireMesh"

	}

	isExternal(WaterflowIndicator)=FALSE

	OR isPartitioned(WaterflowIndicator, , myMaterial) = TRUE

	 getObjectVerticalDistance(FloorSlab, WaterflowIndicator, a)0.8m >=



 getObjectVerticalDistance(FloorSlab, WaterflowIndicator, a)0.8m <= 1.5m



	Door myDoor{

	getObjectProperty(Door.width) >= 0.5m

	getObjectProperty(Door.height) >= 1m

	}

	hasObject(WaterflowIndicator.Space,myDoor)=TRUE

} 




Python Code 변환 예정



18
건축물의 에너지절약설계기준 제 8조 2호 다 목

다. 기기배관 및 덕트는 국토교통부에서 정하는 「건축기계설비공사표준시방서」의 보온두께 이상 또는 그 이상의 열저항을 갖도록 단열조치를 하여야 한다. 다만, 건축물내의 벽체 또는 바닥에 매립되는 배관 등은 그러하지 아니할 수 있다.





//	스프링클러설비의 화재안전기준(nfsc 103) 15조 (헤드의 설치제외) 1항 14호
Check(NFSC103_15_1_14){
	KS
}

KS{
	(getBuildingUsage() = "Indoor.TennisCourts"
	OR getBuildingUsage() = "Indoor.게이트볼장"
	OR getBuildingUsage() = "Indoor.정구장")

	(getObjectProperty(Floor.InteriorFinish.Material.nonCombustibility) = TRUE
	OR getObjectProperty(Floor.InteriorFinish.Material.quasiNonCombustibility) TRUE)

	(getObjectProperty(Wall.InteriorFinish.Material.nonCombustibility) = TRUE
	OR getObjectProperty(Wall.InteriorFinish.Material.quasiNonCombustibility) TRUE)

	(getObjectProperty(Ceiling.InteriorFinish.Material.nonCombustibility) = TRUE
	OR getObjectProperty(Ceiling.InteriorFinish.Material.quasiNonCombustibility) TRUE)

	isObjectProperty(Space.hasCombustible) = FALSE
	hasSpace(Auditorium, SportsFacility) = FALSE
	getObjectProperty(Floor.number) > 0
} 




Python Code 변환 예정



19
건축물의 에너지절약설계기준 제 9조

제9조(기계부문의 권장사항) 에너지절약계획서 제출대상 건축물의 건축주와 설계자 등은 다음 각 호에서 정하는 사항을 제13조의 규정에 적합하도록 선택적으로 채택할 수 있다.





//	스프링클러설비의 화재안전기준(NFSC 103) 16조 (수원 및 가압송수장치의 펌프 등의 겸용) 2항

Check(NFSC103_16_2){

	IF CS THEN KS

}



	Pump myPump{

		isInstalled(SprinklerSystem, PressurizedWaterSupplySystem) = TRUE

		getObjectUsage(Pump) = "PressurizedWaterSupplySystem"

	}



	Pump myPump2{

		isInstalled(IndoorFireHydrantSystem, PressurizedWaterSupplySystem) = TRUE

		getObjectUsage(Pump) = "PressurizedWaterSupplySystem"

	}



	Pump myPump3{

		isInstalled(SimpleSprinklerSystem, PressurizedWaterSupplySystem) = TRUE

		getObjectUsage(Pump) = "PressurizedWaterSupplySystem"

	}



	Pump myPump4{

		isInstalled(SprinklerSystemForEarlyFireSuppression, PressurizedWaterSupplySystem) = TRUE

		getObjectUsage(Pump) = "PressurizedWaterSupplySystem"

	}



	Pump myPump5{

		isInstalled(WaterSprayExtingushingSystem, PressurizedWaterSupplySystem) = TRUE

		getObjectUsage(Pump) = "PressurizedWaterSupplySystem"

	}



	Pump myPump6{

		isInstalled(FoamExtinguishingSystem, PressurizedWaterSupplySystem) = TRUE

		getObjectUsage(Pump) = "PressurizedWaterSupplySystem"

	}



	Pump myPump7{

		isInstalled(OutdoorFireHydrantSystem, PressurizedWaterSupplySystem) = TRUE

		getObjectUsage(Pump) = "PressurizedWaterSupplySystem"

	}





CS{

	isShared(myPump, myPump2) = TRUE

	OR isShared(myPump, myPump3) = TRUE

	OR isShared(myPump, myPump4) = TRUE

	OR isShared(myPump, myPump5) = TRUE

	OR isShared(myPump, myPump6) = TRUE

	OR isShared(myPump, myPump7) = TRUE

}



KS{

	getObjectProperty(myPump.ratedDischargeRate) = PRD



	getObjectProperty(myPump2.ratedDischargeRate) + getObjectProperty(myPump3.ratedDischargeRate) + getObjectProperty(myPump4.ratedDischargeRate) + getObjectProperty(myPump5.ratedDischargeRate) + getObjectProperty(myPump6.ratedDischargeRate) + getObjectProperty(myPump7.ratedDischargeRate) = TPRD



	PRD >= TPRD

} 




Python Code 변환 예정



20
건축물의 에너지절약설계기준 제 10조 3호 가 목

가. 조명기기 중 안정기내장형램프, 형광램프, 형광램프용안정기를 채택할 때에는 제5조제11호라목에 따른 고효율 조명기기를 사용하여야 하며, 유도등 및 주차장 조명기기는 고효율에너지기자재 인증제품에 해당하는 LED 조명을 설치하여야 한다.





//간이스프링클러설비의 화재안전기준(nfsc 103a) 6조 (간이스프링클러설비의 방호구역·유수검지장치) 4호



Check(NFSC503A_6_0_4){

	KS

}

KS{


	(isExternal(WaterflowIndicator)=FALSE

	OR isPartitioned(WaterflowIndicator, ProtectiveWireMesh) = TRUE)

	0.8m <= getObjectVerticalDistance(FloorSlab, WaterflowIndicator, a) <= 1.5m



	Door myDoor{

	getObjectProperty(Door.width) >= 0.5m

	getObjectProperty(Door.height) >= 1m

	}

	hasObject(WaterflowIndicator.Space,myDoor)=TRUE

} 




Python Code 변환 예정



21
건축물의 에너지절약설계기준 제 28조 2 항

② 국토교통부장관은 제1항 업무의 효율적 수행을 위하여 제로에너지빌딩 지원센터로 하여금 시행세칙을 제정하여 운영토록 할 수 있다.





//연결살수설비의 화재안전기준(nfsc 503) 6조 (연결살수설비의 헤드) 2항 1호
Check(NFSC503_6_2_1){
	KS
}

KS{
	Ceiling myCeiling{
		isAdjacent(Ceiling, Indoors) = TRUE
	}

	CeilingCovering myCeilingCovering{
		isAdjacent(CeilingCovering, Indoors) = TRUE
	}

	isInstalled(myCeiling, Sensor) = TRUE
	OR isInstalled(myCeilingCovering, Sensor) = TRUE
} 




Python Code 변환 예정



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

제10조(관람석등으로부터의 출구의 설치기준) ①영 제38조 각호의 1에 해당하는 건축물의 관람석 또는 집회실로부터 바깥쪽으로의 출구로 쓰이는 문은 안여닫이로 하여서는 아니된다.





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 10조 (관람석등으로부터의 출구의 설치기준) 1항

check(REFB_10_1){

    Space mySpace = getSpace("Auditorium") + getSpace("AssemblyHall")



    Door myExit {

        isAccessible(mySpace, Door) = TRUE

        isObjectProperty(Door.isEntrance) = TRUE

    }

getObjectProperty(myExit.panelOperationType) != "OpeningInDoor"


} 








SUCCESS
theater_code = '00000'
std_floor_area = 300


theater_code_label = '관람석 공간분류코드'
std_floor_area_label = '기준 바닥면적'

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

        for storey in building.SELECT('storey'):
            for space in storey.SELECT('space'):
                if space.SELECT('name').STRING() not in ['관람석', '집회실':
                    continue
                for door in space.Select('door'):
                    if door.SELECT('type') is '안여닫이' :
                        door.ERROR('본 공간의 문은 안여닫이입니다.')
                    else:
                        door.SUCCESS('본 공간의 문은 안여닫이가 아닙니다.')
                         





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

1. 관람석별로 2개소 이상 설치할 것





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 10조 (관람석등으로부터의 출구의 설치기준) 2항 1호

check(REFB_10_2_1){

    Door myExit {

        Door.Space.name = "individualSeats"

        getFloorArea(Door.Space) >= 300

        isObjectProperty(Door.isEntrance) = TRUE

    }



    getObjectCount(myExit) >= 2

} 








SUCCESS
theater_code = '00000'
std_floor_area = 300


theater_code_label = '관람석 공간분류코드'
std_floor_area_label = '기준 바닥면적'

def Check():
    for building in SELECT('building'):
        if building.SELECT('prop', '연면적').NUMBER() <= std_floor_area:
            continue

        bldg_use = building.SELECT('building type').STRING()
        sub_use = building.SELECT('prop', '세부용도').STRING()

        if not (bldg_use == '문화 및 집회시설' and sub_use == '공연장'):
            building.SUCESS('검토 대상 건물이 아닙니다.')
            continue
        for storey in building.SELECT('storey'):
            for space in storey.SELECT('space'):
                if space.SELECT('class code').STRING() != theater_code:
                    continue
                if space.SELECT('area').UNIT(m2).NUMBER() < std_floor_area:
                    continue
                door_w_total = 0
                door_cnt = 0
                for door in space.Select('door'):
                    door_cnt += 1 
                    door_w = door.SELECT('width').Unit(m).number()
                    door_w_total += door_w
                    if door_w >= 1.5:
                        door.SUCCESS('출구의 너비' + door_w +'>= 1.5m')
                    else:
                        door.ERROR('출구의 너비' + door_w +'< 1.5m')
                min_door_w_total = space.SELECT('area').UNIT(m2).NUMBER()
                min_door_w_total = min_door_w_total/100*0.6
                if door_w_total >= min_door_w_total :
                    space.SUCCESS('출구의 너비의 총합' + door_w_total +'>='+ min_door_w_total)
                else:
                    space.ERROR('출구의 너비의 총합' + door_w_total +'<' + min_door_w_total)
                if door_cnt >= 2:
                    space.SUCCESS('출구의 개수' + door_w_total +'>='+ '2')
                else:
                    space.ERROR('출구의 개수' + door_w_total +'<'+ '2')
 





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

2. 각 출구의 유효너비는 1.5미터 이상일 것





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 10조 (관람석등으로부터의 출구의 설치기준) 2항 2호

check(REFB_10_2_2){

    Door myExit {

        Door.Space.name = "individualSeats"

        getFloorArea(Door.Space) >= 300

        isObjectProperty(Door.isEntrance) = TRUE

    }



    getObjectWidth(myExit) >= 1.5m

} 








SUCCESS
theater_code = '00000'
std_floor_area = 300


theater_code_label = '관람석 공간분류코드'
std_floor_area_label = '기준 바닥면적'

def Check():
    for building in SELECT('building'):
        if building.SELECT('prop', '연면적').NUMBER() <= std_floor_area:
            continue

        bldg_use = building.SELECT('building type').STRING()
        sub_use = building.SELECT('prop', '세부용도').STRING()

        if not (bldg_use == '문화 및 집회시설' and sub_use == '공연장'):
            building.SUCESS('검토 대상 건물이 아닙니다.')
            continue
        for storey in building.SELECT('storey'):
            for space in storey.SELECT('space'):
                if space.SELECT('class code').STRING() != theater_code:
                    continue
                if space.SELECT('area').UNIT(m2).NUMBER() < std_floor_area:
                    continue
                door_w_total = 0
                door_cnt = 0
                for door in space.Select('door'):
                    door_cnt += 1 
                    door_w = door.SELECT('width').Unit(m).number()
                    door_w_total += door_w
                    if door_w >= 1.5:
                        door.SUCCESS('출구의 너비' + door_w +'>= 1.5m')
                    else:
                        door.ERROR('출구의 너비' + door_w +'< 1.5m')
                min_door_w_total = space.SELECT('area').UNIT(m2).NUMBER()
                min_door_w_total = min_door_w_total/100*0.6
                if door_w_total >= min_door_w_total :
                    space.SUCCESS('출구의 너비의 총합' + door_w_total +'>='+ min_door_w_total)
                else:
                    space.ERROR('출구의 너비의 총합' + door_w_total +'<' + min_door_w_total)
                if door_cnt >= 2:
                    space.SUCCESS('출구의 개수' + door_w_total +'>='+ '2')
                else:
                    space.ERROR('출구의 개수' + door_w_total +'<'+ '2')
 





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

3. 개별 관람석 출구의 유효너비의 합계는 개별 관람석의 바닥면적 100제곱미터마다 0.6미터의 비율로 산정한 너비 이상으로 할 것





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 10조 (관람석등으로부터의 출구의 설치기준) 2항 3호

check(REFB_10_2_3){

    Door myExit {

        Door.Space.name = "individualSeats"

        getFloorArea(Door.Space) >= 300

        isObjectProperty(Door.isEntrance) = TRUE

    }



    getTotalObjectWidth(myExit) >= getFloorArea(myExit.Space)/100*0.6

} 








SUCCESS
theater_code = '00000'
std_floor_area = 300


theater_code_label = '관람석 공간분류코드'
std_floor_area_label = '기준 바닥면적'

def Check():
    for building in SELECT('building'):
        if building.SELECT('prop', '연면적').NUMBER() <= std_floor_area:
            continue

        bldg_use = building.SELECT('building type').STRING()
        sub_use = building.SELECT('prop', '세부용도').STRING()

        if not (bldg_use == '문화 및 집회시설' and sub_use == '공연장'):
            building.SUCESS('검토 대상 건물이 아닙니다.')
            continue
        for storey in building.SELECT('storey'):
            for space in storey.SELECT('space'):
                if space.SELECT('class code').STRING() != theater_code:
                    continue
                if space.SELECT('area').UNIT(m2).NUMBER() < std_floor_area:
                    continue
                door_w_total = 0
                door_cnt = 0
                for door in space.Select('door'):
                    door_cnt += 1 
                    door_w = door.SELECT('width').Unit(m).number()
                    door_w_total += door_w
                    if door_w >= 1.5:
                        door.SUCCESS('출구의 너비' + door_w +'>= 1.5m')
                    else:
                        door.ERROR('출구의 너비' + door_w +'< 1.5m')
                min_door_w_total = space.SELECT('area').UNIT(m2).NUMBER()
                min_door_w_total = min_door_w_total/100*0.6
                if door_w_total >= min_door_w_total :
                    space.SUCCESS('출구의 너비의 총합' + door_w_total +'>='+ min_door_w_total)
                else:
                    space.ERROR('출구의 너비의 총합' + door_w_total +'<' + min_door_w_total)
                if door_cnt >= 2:
                    space.SUCCESS('출구의 개수' + door_w_total +'>='+ '2')
                else:
                    space.ERROR('출구의 개수' + door_w_total +'<'+ '2')
 





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

제12조(회전문의 설치기준) 영 제39조제2항의 규정에 의하여 건축물의 출입구에 설치하는 회전문은 다음 각 호의 기준에 적합하여야 한다. <개정 2005.7.22.>





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 12조 (회전문의 설치기준)  
Check(REFB_12){    
IF CS THEN KS
}

CS {
Door myDoor {
isObjectProperty(Door.isEntrance) = TRUE
Door.panelOperationType=“RevolvingDoor”
}
isExist(myDoor) = TRUE
}

KS {
getResult(REFB_12_1)=TRUE
}
 




Python Code 변환 예정



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

1. 계단이나 에스컬레이터로부터 2미터 이상의 거리를 둘 것





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 12조 (회전문의 설치기준) 1항
Check(REFB_12_1){
KS
}

KS {
getElementDistance(myDoor, Stair, a)>= 2 m
OR getElementDistance(myDoor, Escalator, a)>= 2 m
}
 




Python Code 변환 예정



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

1. 공동주택등의 출입구와 위락시설등의 출입구는 서로 그 보행거리가 30미터 이상이 되도록 설치할 것





// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 14조의2 (복합건축물의 피난시설 등) 1호

Check(REFB_14-2_0_1){
        KS
}

KS{
 Space mySpace{
  Space.usage="MultiUnitHouse"  
  OR Space.usage="MedicalFacility"
  OR Space.usage="ChildrenRelatedFacility"
  OR Space.usage="WelfareFacilityForTheAged"
 }
 
 Space mySpace2{
  Space.usage="AmusementFacility"  
  OR Space.usage="FacilityForStorageAndTreatmentOfDangerousSubstance"
  OR Space.usage="Factory"
  OR Space.usage="AutomobileRepairShop"
 }


getSpaceDiatance(mySpace.Door, mySpace2.Door)>=30 m

}
 




Python Code 변환 예정



29
건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 30조 1호 나 목

나. 승강장은 각 층의 내부와 연결될 수 있도록 하되, 그 출입구에는 갑종방화문을 설치할 것. 이 경우 방화문은 언제나 닫힌 상태를 유지할 수 있는 구조이어야 한다.





// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 1호 나목
check(REFB_30_0_1_나){
      KS
}
KS{
	isConnectedTo(Platform, Floor.One.Space) = TRUE
	Door myDoor{
	isObjectProperty(Door.isEntrance) = TRUE
	isInstalled(Door, Floor.One) = TRUE
	}
	isObjectProperty(myDoor.isStrictFireproofDoor) = TRUE
} 




Python Code 변환 예정



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

가. 출입구를 제외한 부분은 해당 건축물의 다른 부분과 내화구조의 바닥 및 벽으로 구획할 것





// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 3호 가목

check(REFB_30_0_3_가){

      KS

}

KS{

	FloorSlab myFloorSlab{

	isFireResistantStructure(FloorSlab) = TRUE

}

	Wall myWall{

	isFireResistantStructure(Wall) = TRUE

}

	Door myDoor{

	isObjectProperty(Door.isEntrance) = TRUE

	}

	Object myElement{

		getObject(Space.Object) - getObject(myDoor)

	}

	isPartitioned(myElement, , myFloorSlab) = TRUE

	isPartitioned(myElement, , myWall) = TRUE

} 




Python Code 변환 예정



31
건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 30조 3호 나 목

나. 출입구에는 갑종방화문을 설치할 것





// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 30조 (피난용승강기의 설치기준) 3호 나목
check(REFB_30_0_3_나){
      KS
}
KS{
	Door myDoor{
	isObjectProperty(Door.isEntrance) = TRUE
	}
	isObjectProperty(myDoor.isStrictFireproofDoor) = TRUE
} 




Python Code 변환 예정



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

가. 계단실은 창문·출입구 기타 개구부(이하 "창문등"이라 한다)를 제외한 당해 건축물의 다른 부분과 내화구조의 벽으로 구획할 것





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 1호 가목
check(REFB_9_2_1_1){
     KS
}
KS{
Wall myWall{
	hasElement(Stair.Space, Wall) = TRUE
	hasElement(Wall, Window) = FALSE
	hasElement(Wall, Door) = FALSE
	hasElement(Wall, Opening) = FALSE
}
Stair myStair{
            isObjectProperty(Stair.isEscape)= TRUE
}

isFireResistantStructure(myWall)= TRUE
isPartitioned (myStair, 0, myWall) = TRUE
 	
}
 




Python Code 변환 예정



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

마. 건축물의 내부와 접하는 계단실의 창문등(출입구를 제외한다)은 망이 들어 있는 유리의 붙박이창으로서 그 면적을 각각 1제곱미터 이하로 할 것





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 1호 마목
check(REFB_9_2_1_5){
     KS
}
KS{

Opening myOpening3{
	getObject(Opening)!= Door
	isConnectedToExternal(Opening) = FALSE
	hasElement(Stair.Space, Opening) = TRUE
}

	getObjectProperty(myOpening3.material)= “WireContainedGlass”
	getObjectProperty(myOpening3.type)= “FixedSashWindow”
	getObjectProperty(myOpening3.area)=< 1㎡
	
}    
 




Python Code 변환 예정



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

바. 건축물의 내부에서 계단실로 통하는 출입구의 유효너비는 0.9미터 이상으로 하고, 그 출입구에는 피난의 방향으로 열 수 있는 것으로서 언제나 닫힌 상태를 유지하거나 화재로 인한 연기, 온도, 불꽃 등을 가장 신속하게 감지하여 자동적으로 닫히는 구조로 된 제26조에 따른 갑종방화문을 설치할 것





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

Check(REFB_9_2_1_6){

     KS

}

KS {

	Door myDoor{

	isConnectedToExternal(Opening) = FALSE

}

	Space mySpace{

		isExternal(Space)=FALSE

}

	isGoThrough(mySpace,myDoor,Stair.Space.) = TRUE

	isObjectProperty(Door.effectiveWidth) >= 0.9m

	isEgressDirection(Door) = TRUE;



} 




Python Code 변환 예정



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

가. 계단은 그 계단으로 통하는 출입구외의 창문등(망이 들어 있는 유리의 붙박이창으로서 그 면적이 각각 1제곱미터 이하인 것을 제외한다)으로부터 2미터 이상의 거리를 두고 설치할 것





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

check(REFB_9_2_2_1){

    IF (CS) THEN KS

}





CS {

Opening myOpening1{			getObjectProperty(Opening.material)= “WireContainedGlass”

	getObjectProperty(Window.panelOperationType)= “FixedSashWindow”

	getObjectProperty(Opening.area)=< 1㎡	

}

Door myDoor {

	isAccessible(Stair, Door)=TRUE

}

Opening myOpening2{

	getObject(Opening) != myOpening1 

	getObject(Opening) != myDoor	

}

isExist(myOpening2) = TRUE

}



KS{

getElementDistance(Stair, myOpening2, a)>=2m;	

} 




Python Code 변환 예정



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

나. 건축물의 내부에서 계단으로 통하는 출입구에는 제26조에 따른 갑종방화문을 설치할 것





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 9조 (피난계단 및 특별피난계단의 구조) 2항 2호 나목
check(REFB_9_2_2_2){
	IF (CS) THEN KS     
}
CS {
	Space mySpace{
		isExternal(Space)=FALSE
}
	Door myDoor{
		isGoThrough(mySpace,Door,Stair) = TRUE
}
isExist(myDoor) = TRUE
}

KS {
	isObjectProperty(myDoor.strictFireproofDoor) = TRUE
	
}
 




Python Code 변환 예정



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

카. 출입구의 유효너비는 0.9미터 이상으로 하고 피난의 방향으로 열 수 있을 것





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

check (REFB_9_2_3_카){
	KS
}

KS{
getObjectProperty(Door.effectiveWidth) >= 0.9m
isObjectProperty(Door.isEscapeDirection)=TRUE
} 




Python Code 변환 예정



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

③영 제35조제1항에 따른 피난계단 또는 특별피난계단은 돌음계단으로 하여서는 아니되며, 영 제40조에 따라 옥상광장을 설치하여야 하는 건축물의 피난계단 또는 특별피난계단은 해당 건축물의 옥상으로 통하도록 설치하여야 한다. 이 경우 옥상으로 통하는 출입문은 피난방향으로 열리는 구조로서 피난시 이용에 장애가 없어야 한다. <개정 2010.4.7>





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

Check(REFB_9_3) {

	KS

}

KS {

	Stair myStair1{

		isObjectProperty(Stair.isEscape)=TRUE

		OR isObjectProperty(Stair.isSpecialEscape)=TRUE

}

	Space mySpace{

		getObjectProperty(Space.usage) = “RooftopPlaza”
}
		hasObject(Rooftop, mySpace)=TRUE



}

	Stair myStair2{

		hasObject(mySpace.Building,myStair1)=TRUE 

}	

	getObjectProperty(myStair.type)!= “WindingStair”

	isAccessible(myStair2,mySpace)=TRUE

	isEgressDirection(mySpace.Door) = TRUE

} 




Python Code 변환 예정



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

①영 제39조제1항의 규정에 의하여 건축물의 바깥쪽으로 나가는 출구를 설치하는 경우 피난층의 계단으로부터 건축물의 바깥쪽으로의 출구에 이르는 보행거리(가장 가까운 출구와의 보행거리를 말한다. 이하 같다)는 영 제34조제1항의 규정에 의한 거리이하로 하여야 하며, 거실(피난에 지장이 없는 출입구가 있는 것을 제외한다)의 각 부분으로부터 건축물의 바깥쪽으로의 출구에 이르는 보행거리는 영 제34조제1항의 규정에 의한 거리의 2배 이하로 하여야 한다.





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 1항

Check(REFB_11_1){ 
IF CS THEN KS1 AND KS2
}

CS {
Door myDoor{
	isObjectProperty(Door.isEntrance)=TRUE
}
isExist(myDoor)
}

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

getObjectDistance(myFloor.Stair, myDoor,a) <= EDBA_34_1.distance

}

KS2 {

getObjectDistance(Room, myDoor) <= (EDBA_34_1.distance)*2

}

 




Python Code 변환 예정



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

②영 제39조제1항에 따라 건축물의 바깥쪽으로 나가는 출구를 설치하는 건축물중 문화 및 집회시설(전시장 및 동·식물원을 제외한다), 종교시설, 장례식장 또는 위락시설의 용도에 쓰이는 건축물의 바깥쪽으로의 출구로 쓰이는 문은 안여닫이로 하여서는 아니된다. <개정 2010.4.7>





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 2항



Check(REFB_11_2){
     

IF CS1 AND CS2 THEN KS


}





CS1 {

Building myBuilding{

getBuildingUsage() = “CulturalAndAssemblyFacility”

OR getBuildingUsage() = “ReligiousFacility”

OR getBuildingUsage() = “AmusementFacility”

OR getBuildingUsage() = “FuneralParlor”

getBuildingUsage() != “ExhibitionHall”

getBuildingUsage() != “ZoologicalAndBotanicalGarden”

}



Door myDoor{

isObjectProperty(myBuilding.Door.isEntrance)=TRUE

}

isExist(myDoor) = TRUE

}



KS {

getObjectProperty(myDoor.panelOperationType) != “OpeningInDoor”



} 




Python Code 변환 예정



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

③영 제39조제1항의 규정에 의하여 건축물의 바깥쪽으로 나가는 출구를 설치하는 경우 관람석의 바닥면적의 합계가 300제곱미터 이상인 집회장 또는 공연장에 있어서는 주된 출구외에 보조출구 또는 비상구를 2개소 이상 설치하여야 한다.





// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 3항

Check(REFB_11_3){
     

IF CS1 AND CS2 THEN KS


}





CS1 {

Building myBuilding{

getBuildingUsage() = “AssemblyHall”

OR getBuildingUsage() = “PerformanceHall”

}



Space mySpace{

myBuilding.Space.name = “Auditorium”

Space.FloorSlab.area >= 300 m2

}



isExist(mySpace) = TRUE

}



CS2 {

Door myDoor{

isObjectProperty(Door.isEntrance)=TRUE

}

hasObject(myBuilding,myDoor) = TRUE

}



KS {

Door myDoor{

getObjectProperty(Door.functionType) = "Auxiliary"

OR getObjectProperty(Door.functionType) = "Emergency" 

}



getObjectCount(myDoor) >=2

} 




Python Code 변환 예정



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

④판매시설의 용도에 쓰이는 피난층에 설치하는 건축물의 바깥쪽으로의 출구의 유효너비의 합계는 해당 용도에 쓰이는 바닥면적이 최대인 층에 있어서의 해당 용도의 바닥면적 100제곱미터마다 0.6미터의 비율로 산정한 너비 이상으로 하여야 한다. <개정 2010.4.7>





//건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 4항
Check(REFB_11_4){     
IF CS THEN KS
}

CS {
Floor myFloor{
getObjectUsage(Floor) = “CommercialFacility”
isObjectProperty(Floor.isEscape)=TRUE
}
Door myDoor{
isObjectProperty(Door.isEntrance)=TRUE
}

hasObject(myFloor,myDoor) = TRUE
}

KS{

myFloor.myDoor.effectiveWidth >= 

}
 




Python Code 변환 예정



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

⑥법 제39조제1항에 따라 영 제39조제1항 각 호의 어느 하나에 해당하는 건축물의 바깥쪽으로 나가는 출입문에 유리를 사용하는 경우에는 안전유리를 사용하여야 한다. <신설 2006.6.29>





// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 11조 (건축물의 바깥쪽으로의 출구의 설치기준) 6항
Check(REFB_11_6){  
   KS
}

KS{
    Door myDoor{
       isObjectProperty(Door.isEntrance)=TRUE
    }
    IF getObjectMaterial(myDoor)="Glass"
         THEN getObjectType(Glass)="Safety"  

} 




Python Code 변환 예정



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

③제1항 및 제2항의 규정을 적용함에 있어서 수시로 개방할 수 있는 미닫이로 구획된 2개의 거실은 이를 1개의 거실로 본다.





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

check(REFB_17_3){

	IF CS THEN KS

}



CS{

Door myDoor{
getObjectProperty(Door.panelOperationType) = "SlidingDoor"
}

	Room myRoom{

		isPartitioned(Room, myDoor, Room) = TRUE

	}

}



KS{

	myRoom = Room

} 




Python Code 변환 예정



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

3. 방화벽에 설치하는 출입문의 너비 및 높이는 각각 2.5미터 이하로 하고, 해당 출입문에는 제26조에 따른 갑종방화문을 설치할 것





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

Check(REFB_21_1_3){
      KS
}

KS{
     Door myDoor{
      isObjectProperty(Door.isEntrance)=True
      isInstalled(Door, myWall)=True
    }

    getObjectWidth(myDoor)<=2.5 m
    getObjectHeight(myDoor)<=2.5 m
    isObjectProperty(myDoor.isStrictFireproofDoor)=True
  
} 




Python Code 변환 예정



46
건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 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 변환 예정



47
건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 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 변환 예정



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

2. 비상탈출구의 문은 피난방향으로 열리도록 하고, 실내에서 항상 열 수 있는 구조로 하여야 하며, 내부 및 외부에는 비상탈출구의 표시를 할 것





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

Check(REFB_25_2_2){

Door myDoor{
Door.functionType = "Emergency"
 < 0
}
	isEgressDirection(myDoor) = TRUE

} 




Python Code 변환 예정



49
건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 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 변환 예정



50
건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 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 변환 예정



51
건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 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 변환 예정



52
건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 제 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 변환 예정



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

자. 건축물의 내부에서 노대 또는 부속실로 통하는 출입구에는 제26조에 따른 갑종방화문을 설치하고, 노대 또는 부속실로부터 계단실로 통하는 출입구에는 제26조에 따른 갑종방화문 또는 을종방화문을 설치할 것. 이 경우 갑종방화문 또는 을종방화문은 언제나 닫힌 상태를 유지하거나 화재로 인한 연기, 온도, 불꽃 등을 가장 신속하게 감지하여 자동적으로 닫히는 구조로 하여야 한다.





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

check (REFB_9_2_3_9){

IF(CS1) THEN KS1 OR (CS2) TEHN KS2

}

Space mySpace1 {

	isExternal(Space)=FALSE

}

Space mySpace2 = getSpace(“Balcony”) + getSpace(“AncillaryRoom”)

CS1{

	

	isGoThrough(mySpace1,Door,mySpace2) = TRUE

}

KS1 {

	isObjectProperty(Door.isStrictFireproofDoor)= TRUE

}



CS2{

	isGoThrough(mySpace2,Door,Stair.Space) = TRUE

}

KS2{

	isObjectProperty(Door.isFireproofDoor)= TRUE

} 




Python Code 변환 예정



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

4. 출입구는 유효너비 0.9미터 이상으로 하고, 그 출입구에는 갑종방화문을 설치할 것





// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 13조 (헬리포트 및 구조공간 설치 기준) 3항 4호



Check(REFB_13_3_4){

  KS

}



KS{

     isObjectProperty(Door.isEntrance)=True

  getObjectProperty( myDoor.effectiveWidth) > 0.9 m

   isObjectProperty(Door.isStrictFireproofDoor)=True 




Python Code 변환 예정



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

②영 제61조제1항제4호나목에서 "국토교통부령으로 정하는 출구"란 건축물의 내부의 각 부분으로부터 출구(가장 가까운 거리에 있는 출구를 말한다)에 이르는 보행거리가 30미터 이하가 되도록 설치된 유효너비 1.5미터 이상의 출구를 말한다. <개정 2008.3.14, 2010.12.30, 2013.3.23>





// 건축물의 피난ㆍ방화구조 등의 기준에 관한 규칙 24조의2 (소규모 공장용도 건축물의 마감재료) 2항
check(REFB_24-2_2){
      KS
}
KS{
	Door myDoor{
	isObjectProperty(Door.isEntrance) = TRUE
	}
	getObjectDistance(Building.IndoorElement, Door) <= 30
	isObjectProperty(Door.effectiveWidth) >= 1.5m
} 




Python Code 변환 예정



56
건축법 제 49조 1 항

① 대통령령으로 정하는 용도 및 규모의 건축물과 그 대지에는 국토교통부령으로 정하는 바에 따라 복도, 계단, 출입구, 그 밖의 피난시설과 저수조(貯水槽), 대지 안의 피난과 소화에 필요한 통로를 설치하여야 한다. <개정 2013.3.23, 2018.4.17>





//건축법 49조 (건축물의 피난시설 및 용도제한 등) 1항
Check(BA_49_1){
   IF CS THEN KS 
}

CS{
  getResult(EDBA_34_2)= TRUE
  OR getResult(EDBA_35_1) = TRUE
  OR getResuLt(EDBA_35_2) = TRUE
  OR getResuLt(EDBA_35_3) = TRUE
  OR getResuLt(EDBA_35_5) = TRUE
  OR getResult (EDBA_38) = TRUE
  OR getResuLt(EDBA_39_1) = TRUE
  OR getResuLt(EDBA_39_2) = TRUE
}

KS{

Door myDoor{
isObjectProperty(Door.isEntrance)=TRUE
}

   isExist(Corridor) = TRUE
   isExist(Stair) = TRUE
   isExist(myDoor) = TRUE
   isExist(EvacuationFacility) = TRUE
   isExist(FireHydrant) = TRUE
   isExist(Tank) = TRUE
   isExist(ExtinguishingSystem)= TRUE
   isExist(Passage)=True

   getResult(REFB_11_1)= TRUE
   getResult(REFB_11_2)= TRUE
   getResult(REFB_11_3)= TRUE
   getResult(REFB_11_4)= TRUE
   getResult(REFB_11_5)= TRUE
} 




Python Code 변환 예정



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

①건축물의 대지 안에는 그 건축물 바깥쪽으로 통하는 주된 출구와 지상으로 통하는 피난계단 및 특별피난계단으로부터 도로 또는 공지(공원, 광장, 그 밖에 이와 비슷한 것으로서 피난 및 소화를 위하여 해당 대지의 출입에 지장이 없는 것을 말한다. 이하 이 조에서 같다)로 통하는 통로를 다음 각 호의 기준에 따라 설치하여야 한다. <개정 2010.12.13, 2015.9.22, 2016.5.17, 2017.2.3>





Check(EDBA_41_1){

    KS

}







KS{



   Door  myDoor {
getObjectProperty(Door.functionType) = "Main"
   }

   Stair myStair{
isAccessible(Stair, Ground) = TRUE
isObjectProperty(Stair.isEscape) = TRUE

       OR isObjectProperty(Stair.isSpecialEscape) = TRUE



   }

   Passage  myPassage{

       isGoThrough(myStair, Road, Passage)=True

       OR isGoThrough(myStair, OpenSpace, Passage )=True

   }



   isExist(myDoor)=True

   isExist(myPassage)=True

   getResult(EDBA_41_1_1)=True

   getResult(EDBA_41_1_2)=True

   getResult(EDBA_41_1_3)=True

} 








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)) 





58
건축법 시행령 제 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('피난층으로 대피할 수 없습니다.') 





59
건축법 시행령 제 38조

제38조 (관람석 등으로부터의 출구 설치) 법 제49조제1항에 따라 다음 각 호의 어느 하나에 해당하는 건축물에는 국토해양부령으로 정하는 기준에 따라 관람석 또는 집회실로부터의 출구를 설치하여야 한다.





//건축법 시행령 38조(관람석 등으로부터의 출구 설치)

Check(EDBA_38){

  IF (CS) THEN  KS ENDIF

}



CS{

    getResult(EDBA_38_0_1) = TRUE

    OR getResult(EDBA_38_0_2) = TRUE

    OR getResult(EDBA_38_0_3) = TRUE

    OR getResult(EDBA_38_0_4) = TRUE

    OR getResult(EDBA_38_0_5) = TRUE

}



KS {

    Space mySpace = getSpace("Auditorium")+getSpace("AssemblyHall")



    Door myExit {

        isObjectProperty(Door.isEntrance) = TRUE

        isAccessible(mySpace, Door) = TRUE

        getResult(REFB_10_1) = TRUE

    }



    hasElement(mySpace, myExit)=TRUE 

} 








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) + '㎡)') 





60
건축법 시행령 제 39조 1 항

① 법 제49조제1항에 따라 다음 각 호의 어느 하나에 해당하는 건축물에는 국토해양부령으로 정하는 기준에 따라 그 건축물로부터 바깥쪽으로 나가는 출구를 설치하여야 한다.





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

Check(EDBA_39_1){     
IF  CS THEN KS
}

CS {
getResult(EDBA_39_1_1) = TRUE
OR getResult(EDBA_39_1_2) = TRUE
OR getResult(EDBA_39_1_3) = TRUE
OR getResult(EDBA_39_1_4) = TRUE
OR getResult(EDBA_39_1_5) = TRUE
OR getResult(EDBA_39_1_6) = TRUE
OR getResult(EDBA_39_1_7) = TRUE
OR getResult(EDBA_39_1_8) = TRUE
OR getResult(EDBA_39_1_9) = TRUE
OR getResult(EDBA_39_1_10) = TRUE
}

KS {
Door myDoor{
 isObjectProperty(Door.isEntrance)=TRUE
}

isExist(myDoor)=TRUE

getResult(REFB_11_1)=TRUE
getResult(REFB_11_2)=TRUE
getResult(REFB_11_3)=TRUE
getResult(REFB_11_4)=TRUE
getResult(REFB_11_5)=TRUE
getResult(REFB_11_6)=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) + ')')
 





61
건축법 시행령 제 39조 2 항

② 법 제49조제1항에 따라 건축물의 출입구에 설치하는 회전문은 국토해양부령으로 정하는 기준에 적합하여야 한다.





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

Check(EDBA_39_2){     
IF  CS THEN KS
}

CS {
Door myDoor {
isObjectProperty(Door.isEntrance) = TRUE
Door.panelOperationType=“RevolvingDoor”
}
isExist(myDoor) = TRUE
}

KS {
getResult(REFB_11_2)=TRUE
}
 




Python Code 변환 예정



62
건축법 시행령 제 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 변환 예정



63
건축법 시행령 제 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 변환 예정



64
건축법 시행령 제 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)) 





65
다중이용업소의 안전관리에 관한 특별법 시행령 제 2조 5호

5. 「게임산업진흥에 관한 법률」 제2조제6호ㆍ제6호의2ㆍ제7호 및 제8호의 게임제공업ㆍ인터넷컴퓨터게임시설제공업 및 복합유통게임제공업. 다만, 게임제공업 및 인터넷컴퓨터게임시설제공업의 경우에는 영업장(내부계단으로 연결된 복층구조의 영업장은 제외한다)이 지상 1층 또는 지상과 직접 접하는 층에 설치되고 그 영업장의 주된 출입구가 건축물 외부의 지면과 직접 연결된 구조에 해당하는 경우는 제외한다.





//다중이용업소의 안전관리에 관한 특별법 시행령 2조 (다중이용업) 5호


Check(ERSASP_2_0_5){
KS1 AND IF CS THEN !KS2
}


KS1{
getObjectProperty(Building.business)= "GIPA_2_0_6"
OR getObjectProperty(Building.business)= "GIPA_2_0_6-2"
OR getObjectProperty(Building.business)= "GIPA_2_0_7"
OR getObjectProperty(Building.business)= "GIPA_2_0_8"
}


CS{
getObjectProperty(Building.business)= "GIPA_2_0_6"
OR getObjectProperty(Building.business)= "GIPA_2_0_7"
}

KS2{
Space mySpace{
Space.usage = "GIPA_2_0_6"
OR Space.usage = "GIPA_2_0_7"
}
Floor myFloor{
hasObject(Floor,mySpace)=TRUE
}
Door myDoor{
isObjectProperty(mySpace.Door.isEntrance)=TRUE
}

(getObjectProperty(myFloor.number)=1
OR isDirectlyAccessible(myFloor, Ground)=TRUE)
isConnectedToExternal(myDoor)=TRUE
} 




Python Code 변환 예정



66
연결살수설비의 화재안전기준(NFSC 503) 제 5조 3 항

③폐쇄형헤드를 사용하는 연결살수설비의 주배관은 옥내소화전설비의 주배관(옥내소화전설비가 설치된 경우에 한한다) 및 수도배관(연결살수설비가 설치된 건축물 안에 설치된 수도배관 중 구경이 가장 큰 배관을 말한다) 또는 옥상에 설치된 수조(다른 설비의 수조를 포함한다)에 접속하여야 한다. 이 경우 연결살수설비의 주배관과 옥내소화전설비의 주배관·수도배관·옥상에 설치된 수조의 접속부분에는 체크밸브를 설치하되, 점검하기 쉽게 하여야 한다.





//  연결살수설비의 화재안전기준(nfsc 503) 5조 (배관 등) 3항



Check(NFSC503_5_3){

	IF CS THEN KS

}

	Head myHead{

	isObjectProperty(Head.openAndCloseType) = "EnclosedType"

	}

	Pipe myPipe1{

	isObjectProperty(Pipe.isRiser) = TRUE

	isObjectProperty(myPipe.systemType) = "HookingUpSprinklerSystem"

	}

CS{

	isInstalled(myHead, myPipe1) = TRUE

}

KS{

	Pipe myPipe2{

	isObjectProperty(Pipe.isRiser) = TRUE

	isObjectProperty(myPipe.systemType) = "IndoorFireHydrantSystem"

	}

	Tank myTank{

	isInstalled(Tank, Rooftop) = TRUE

	}

	Pipe myPipe3{
	Pipe.isForWater = TRUE

	연결살수설비가 설치된 건축물 안에 설치된 수도배관 중 구경이 가장 큰 배관

	}

	Valve myValve{

	isObjectProperty(Valve.isCheckValve) = TRUE

	}

	(isConnectedTo(myPipe1, myPipe2) = TRUE

	isInstalled(myValve, myPipe1) = TRUE

	isInstalled(myValve, myPipe2) = TRUE)



	OR (isConnectedTo(myPipe1, myPipe3) = TRUE

	isInstalled(myValve, myPipe1) = TRUE

	isInstalled(myValve, myPipe3) = TRUE)



	OR (isConnectedTo(myPipe1, myTank) = TRUE

	isInstalled(myValve, myPipe1) = TRUE

	isInstalled(myValve, myTank) = TRUE)

} 




Python Code 변환 예정



67
연결살수설비의 화재안전기준(NFSC 503) 제 6조 2 항 1호

1. 천장 또는 반자의 실내에 면하는 부분에 설치할 것





//연결살수설비의 화재안전기준(nfsc 503) 6조 (연결살수설비의 헤드) 2항 1호
Check(NFSC503_6_2_1){
	KS
}

KS{
	SprinklerHead mySprinklerHead{
		isInstalled(SprinklerHead, HookingUpSprinklerSystem) = TRUE
	}

	isAdjacent(mySprinklerHead.Head.AttachingToSurface, Indoors) = TRUE
	(isAdjacent(mySprinklerHead.Head.AttachingToSurface, Ceiling) = TRUE
	OR isAdjacent(mySprinklerHead.Head.AttachingToSurface, CeilingCovering) = TRUE)
} 




Python Code 변환 예정



68
연결송수관설비의 화재안전기준(NFSC 502) 제 5조 4 항

④ 연결송수관설비의 배관은 주배관의 구경이 100㎜ 이상인 옥내소화전설비·스프링클러설비 또는 물분무등소화설비의 배관과 겸용할 수 있다.[종전의 제2항에서 이동 2014.8.18]





//연결송수관설비의 화재안전기준(NFSC 502) 5조 (배관) 4항

Check(NFSC502_5_4){
	IF CS THEN KS
}
CS2{
	isObjectProperty(Pipe.systemType) = "FireDepartmentConnectionSystem"
}
KS{
	Pipe myPipe1{
	isObjectProperty(Pipe.isRiser) = TRUE
	getObjectProperty(Pipe.diameter) >= 100mm
	isObjectProperty(Pipe.systemType) = "IndoorFireHydrantSystem"
	}
	Pipe myPipe2{
	isObjectProperty(Pipe.isRiser) = TRUE
	getObjectProperty(Pipe.diameter) >= 100mm
	isObjectProperty(Pipe.systemType) = "WaterSprayExtingushingSystem"
	}
	isShared(Pipe,myPipe1) = TRUE
	OR isShared(Pipe,myPipe2) = TRUE
	OR isShared(Pipe,myPipe1) != TRUE
	OR isShared(Pipe,myPipe2) != TRUE
} 




Python Code 변환 예정



69
연결송수관설비의 화재안전기준(NFSC 502) 제 6조 1호 다 목

다. 송수구가 부설된 옥내소화전을 설치한 특정소방대상물(집회장·관람장·백화점·도매시장·소매시장·판매시설·공장·창고시설 또는 지하가를 제외한다)로서 다음의 어느 하나에 해당하는 층 (1) 지하층을 제외한 층수가 4층 이하이고 연면적이 6,000㎡ 미만인 특정소방대상물의 지상층 (2) 지하층의 층수가 2 이하인 특정소방대상물의 지하층





//연결송수관설비의 화재안전기준(NFSC 502) 6조 (방수구) 1호 다목



Check(NFSC502_6_0_1_다목){

         KS

}



KS{

       getBuildingUsage()!="AssemblyHall"

       getBuildingUsage()!="Auditorium"

       getBuildingUsage()!="DepartmentStore"

       getBuildingUsage()!="WholesaleMarket"

       getBuildingUsage()!="CommercialFacility"

       getBuildingUsage()!="Factory"

       getBuildingUsage()!="Warehouse"

       getBuildingUsage()!="UndergroundMarket"



      

FireHydrant myFireHydrant{
isExternal(FireHydrant)  = FALSE
         isInstalled(FireDepartmentConnection, FireHydrant)=True

    }       



    isInstalled(myIndoorFireHydrant,SpecificFireFightingBuilding)=True



    Floor myFloor{

            Floor.number>0

    }

    Floor myFloor2{

            Floor.number<0

    }

    (

    gerObjectCount(myFloor)<=4 

    getGrossFloorArea()<6000 m2

    Floor.number>0

    )



    OR 

    (

     getObjectCount(myFloor)<=2

     Floor.number<0        

    )

    



    

} 




Python Code 변환 예정



70
연결송수관설비의 화재안전기준(NFSC 502) 제 6조 5호

5. 방수구는 연결송수관설비의 전용방수구 또는 옥내소화전방수구로서 구경 65㎜의 것으로 설치할 것





//연결송수관설비의 화재안전기준(NFSC 502) 6조 (방수구) 5호



Check(NFSC502_6_0_5){

      KS

}



KS{

    getObjectProperty(FireDepartmentConnectionSystem.Port.isShared)= FALSE

    OR getObjectProperty(FireDepartmentConnectionSystem.Port.typeForWater)="IndoorFireHydrantDischarge"


Port myPort{
Port.typeForWater = "Delivery"
}
    getObjectProperty(myPortt.diameter)=65 mm 

} 




Python Code 변환 예정



71
연소방지설비의 화재안전기준(NFSC 506) 제 8조 2호

2. 방화벽에 출입문을 설치하는 경우에는 방화문으로 할 것





//	연소방지설비의 화재안전기준(nfsc 506) 8조 (방화벽의 설치기준) 2호
Check(NFSC506_8_0_2){
	IF CS THEN KS
}
	Wall myWall{
		isObjectProperty(Wall.isFireProofWall) = TRUE
	}

	Door myDoor{
		isObjectProperty(Door.isEntrance) = TRUE
	}

CS{
	isInstalled(myDoor, myWall) = TRUE
}


KS{
	isObjectProperty(myDoor.isStrictFireproofDoor) = TRUE
	OR isObjectProperty(myDoor.isFireproofDoor) = TRUE
} 




Python Code 변환 예정



72
유도등 및 유도표지의 화재안전기준(NFSC 303) 제 5조 1 항 1호

1. 옥내로부터 직접 지상으로 통하는 출입구 및 그 부속실의 출입구





//유도등 및 유도표지의 화재안전기준(nfsc 303) 5조 (피난구유도등) 1항 1호

Check(NFSC303_5_1_1){
     KS
}

KS{
    Door myDoor {

        isObjectProperty(Door.isEntrance)=True
        isDirectlyAccessible(Door, Ground)=True          
    }

    LeadingLight myLeadingLight{
        isObjectProperty(LeadingLight.isForExit)=True
    }

   isEnstalled(myLeadingLight,myDoor)=True

   IF hasObject(AncillaryRoom, myDoor)=True
   THEN isEnstalled(myLeadingLight, AncillaryRoom )=True
} 




Python Code 변환 예정



73
유도등 및 유도표지의 화재안전기준(NFSC 303) 제 5조 1 항 2호

2. 직통계단·직통계단의 계단실 및 그 부속실의 출입구





//유도등 및 유도표지의 화재안전기준(nfsc 303) 5조 (피난구유도등) 1항 2호

Check(NFSC303_5_1_2){
     KS
}

KS{
   Stair myStair {

        isObjectProperty(Stair.isDirect)=True       
    }

  Door myDoor{
      isObjectProperty(Door.isEntrance)=True     
     OR hasObject( myStair, Door)=True
     OR hasObject(myStair.Space,Door)=True
     OR hasObject(myStair.AncillaryRoom,Door)=True

  }

    LeadingLight myLight{
        isObjectProperty(LeadingLight.isForExit)=True
    }

   isEnstalled(myLight,myDoor)=True
   
   
} 




Python Code 변환 예정



74
유도등 및 유도표지의 화재안전기준(NFSC 303) 제 5조 1 항 3호

3. 제1호와 제2호에 따른 출입구에 이르는 복도 또는 통로로 통하는 출입구





//유도등 및 유도표지의 화재안전기준(nfsc 303) 5조(피란구유도등) 1항 3호 

Check(NFSC303){
           KS
}
  Door myDoor{
      isObjectProperty(Door.isEntrance)=True     
     (OR hasObject( myStair, Door)=True
     OR hasObject(myStair.Space,Door)=True
     OR hasObject(myStair.AncillaryRoom,Door)=True)

       OR isDirectlyAccessible(Door, Ground)=True          
    }
 LeadingLight myLeadingLight{
        isObjectProperty(LeadingLight.isForExit)=True
    }

  Passage myPassage{
     isAccessible(myDoor, Passage)=True
   }
  Corridor myCorriodr{
     isAccessible(myDoor, Corridor)=True
  }

  Door myDoor2{
      isObjectProperty(Door.isEntrance)=True    
     isAccessible(myPassage, Door)=True
     or isAccessible(myCorridor, Door)=True
  }

isInstalled(myLeadingLight, myDoor2)=True

} 




Python Code 변환 예정



75
유도등 및 유도표지의 화재안전기준(NFSC 303) 제 8조의2조 2 항 1호

1. 구획된 각 실로부터 주출입구 또는 비상구까지 설치할 것





//	유도등 및 유도표지의 화재안전기준(nfsc 303)  8조의2 (피난유도선 설치기준) 2항 1호

Check(NFSC303_8-2_2_1){

	KS

}



KS{

	

	Door myDoor{

		isObjectProperty(Door.isEntrance) = TRUE

		getObjectProperty(Door.functionType) = "Main"

	}



	Door myDoor2{

		getObjectProperty(Door.functionType) = "Emergency"

	}



	getObjectCountInInterval(LeadingLine, Room, myDOor) >=1

	OR getObjectCountInInterval(LeadingLine, Rom, myDoor2) >=1

} 




Python Code 변환 예정



76
장애인ㆍ노인ㆍ임산부 등의 편의증진 보장에 관한 법률 시행규칙 제 별표1조

1. 장애인등의 통행이 가능한 접근로 가. 유효폭 및 활동공간 (1) 휠체어사용자가 통행할 수 있도록 접근로의 유효폭은 1.2미터 이상으로 하여야 한다. (2) 휠체어사용자가 다른 휠체어 또는 유모차 등과 교행할 수 있도록 50미터마다 1.5미터×1.5미터 이상의 교행구역을 설치할 수 있다. (3) 경사진 접근로가 연속될 경우에는 휠체어사용자가 휴식할 수 있도록 30미터마다 1.5미터×1.5미터 이상의 수평면으로 된 참을 설치할





//장애인ㆍ노인ㆍ임산부 등의 편의증진보장에 관한 법률 시행규칙 별표1 편의시설의 구조·재질등에 관한 세부기준(제2조제1항관련)

Check(ERCDAPA_2_1_*_1_4_나_1){
	IF (CS1 THEN KS1) OR (CS2 THEN KS2)

	ParkingUnit myParkingUnit{
		isObjectProperty(ParkingUnit.isParallelParking) = TRUE
	}

	CS1{
		isObjectProperty(ParkingUnit.isParallelParking) = TRUE
	}

	KS1{
		getObjectWidth(ParkingLotArea.isHandicapParking, a) >= 3.3 m
		getElementLength(ParkingLotArea.isHandicapParking) >= 5 m
	}

	CS2{
		isObjectProperty(ParkingLotArea.isParallelParking) = FALSE
	}

	KS2{
		getObjectWidth(ParkingLotArea.isHandicapParking, a) >= 2 m
		getElementLength(ParkingLotArea.isHandicapParking) >= 6 m
	}
}


check(ERCDAPA_2_1_*_1_4_나_2){
	getObjectGradient(ParkingSpace.Floor) <= 1/50
}


check(ERCDAPA_2_1_*_1_6_가_1){
	
	Door myDoor1{
		isObjectProperty(Door.isEntrance) = TRUE
	}

	Door myDoor2{
		isObjectProperty(Door.isEntrance) = TRUE
		getObject(Door.isEntrance) != getObject(myDoor1)
	}

	getObjectWidth(Door.isEntrance) >= 0.8 m
	isEgressDirection(myDoor1) = isEgressDirection(myDoor2)
	getObjectDistance(myDoor1, myDoor2) >= 1.2 m
}


check(ERCDAPA_2_1_*_1_6_가_2){
	
	isObjectProperty(Door.isAutomatic) = FALSE
	isObjectProperty(Door.isSillFree) = TRUE
}

check(ERCDAPA_2_1_*_1_8_가_2){
	
	getObjectVerticalDistance(FloorSurface,Door.Bottom)
}

check(ERCDAPA_2_1_*_1_8_나){
	
	Stair myStair{
		isObjectProperty(Stair.isEscape) = TRUE
		isObjectProperty(Stair.isOutdoor) = TRUE
	}

	getObjectWidth(myStair) >= 0.9 m 
	getObjectWidth(myStair.StairLanding) >= 0.9 m

	Stair myStair2{
		isObjectProperty(Stair.isEscape) = FALSE
		isObjectProperty(Stair.isOutdoor) = FALSE
	}

	getObjectWidth(myStair2) >= 1.2 m 
	getObjectWidth(myStair2.StairLanding) >= 1.2 m
}


check(ERCDAPA_2_1_*_1_8_다_1){
	
	hasObject(Stair, VerticalSurfaceStair) = TRUE
}

check(ERCDAPA_2_1_*_1_8_다_2){
	
	getObjectWidth(Stair.threadWidth) >= 0.28 m
	getObjectHeight(Stair.riserHeight) <= 0.18m
}

check(ERCDAPA_2_1_*_1_8_다_3){
	
	getObjectGradient(Stair.riserGradient) >= 60
	getObjectLength(Stair.nosingLength) < 3 cm
} 




Python Code 변환 예정



77
장애인ㆍ노인ㆍ임산부 등의 편의증진 보장에 관한 법률 시행령 제 별표2조

1. 삭제 <2006.1.19> 2. 공원<표-EDCDAPA_*_2_T1> (편의시설의 종류 :설치기준) 가. 장애인 등의 출입이 가능한 출입구 :공원 외부에서 내부로 이르는 출입구는 주출입구를 포함하여 적어도 하나 이상을 장애인등의 출입이 가능하도록 유효폭·형태 및 부착물 등을 고려하여 설치하여야 한다. 나. 장애인등의 통행이 가능한 보도 :공원시설(공중이 직접 이용하는 시설에 한한다)에 접근할 수 있는 공원안의 보도중 적어도 하나는 장애인등이 통행할





// 장애인ㆍ노인ㆍ임산부 등의 편의증진보장에 관한 법률 시행령 별표2 대상시설별 편의시설의 종류 및 설치기준(제4조관련)



Check(EDCDAPA_*_2_3_가_2_가){

IF CS1 AND CS2 THEN KS

}



ParkingLot myParkingLot{

isObjectProperty(ParkingLot.isAttachedParking) = TRUE

}

CS1 {

isExist(myParkingLot) = TRUE

}

CS2 {

getObjectProperty(myParkingLot.numberOfParkingUnit) >= 10

}

KS1 {

Area myArea{

isObjectProperty(ParkingLotArea.isHandicapParking)=TRUE

}

hasSpace(myParkingLot, myArea) = TRUE

getResult(EDPA_*_1) = TRUE

}



Check(EDCDAPA_*_2_3_가_4_가){

KS1 IF CS1 THEN KS2

}



Door myDoor1{

	isObjectProperty(Door.isEntrance)=TRUE

	isObjectProperty(myDoor1.isHandicapAccessible)=TRUE

}

Door myDoor2{

Door.Space.usage = “Office”

isObjectProperty(myDoo2.isHandicapAccessible)=TRUE

}

KS1 {

isExist(myDoor1) = TRUE

isExist(myDoor2) = TRUE

}

CS1{

Building.usage = “BusinessFacility.GovernmentOfficeBuilding”

Building.usage != “ClassINeighborhoodLivingFacility”

}

KS2 {

isObjectProperty(myDoor1.isAutomatic)=TRUE

isObjectProperty(myDoo2.isAutomatic)=TRUE

}







ParkingLot myParkingLot{

isObjectProperty(ParkingLotArea.isHandicapParking)=TRUE

}





Building myBuilding1_1{

	Building.usage = “ClassINeighborhoodLivingFacility.RetailStore”

	Building.usage = “ClassINeighborhoodLivingFacility.Barbershop”

	Building.usage = “ClassINeighborhoodLivingFacility.BeautyShop”

	Building.usage = “ClassINeighborhoodLivingFacility.Bathhouse”

}

Building myBuilding1_2{

	Building.usage = “ClassINeighborhoodLivingFacility.CommunityCenter”

	Building.usage = “ClassINeighborhoodLivingFacility.PoliceBox”

	Building.usage = “ClassINeighborhoodLivingFacility.PoliceSubstation”

	Building.usage = “ClassINeighborhoodLivingFacility.PostOffice”

Building.usage = “ClassINeighborhoodLivingFacility.HealthCenter”

	Building.usage = “ClassINeighborhoodLivingFacility.PublicLibrary”

	Building.usage = “ClassINeighborhoodLivingFacility.NationalHealthInsuranceService_NationalPensionService_Korea EmploymentAgencyForTheDisabled_KoreaWorkersCompensationAndWelfareServiceOffice”

}

Building myBuilding1_3{

	Building.usage = “ClassINeighborhoodLivingFacility.Clinic_ DentalClinic_OrientalMedicalClinic_MaternityClinic”

}

Building myBuilding1_4{

	Building.usage = “ClassINeighborhoodLivingFacility.CommunityChildCenter”

	Building.facilityArea >= 300 m2

}

Building myBuilding1_5{

	Building.usage = “ClassINeighborhoodLivingFacility.Shelter”

}

Building myBuilding1_6{

	Building.usage = “ClassINeighborhoodLivingFacility.PublicToilet”

}

Building myBuilding2_1{

	Building.usage = “ClassIINeighborhoodLivingFacility.Restaurant”

	Building.usage = “ClassIINeighborhoodLivingFacility.RestingRestaurant”

	Building.usage = “ClassIINeighborhoodLivingFacility.Bakery”

	Building.usage != “ClassINeighborhoodLivingFacility”

Building.facilityArea >= 300 m2

}

Building myBuilding2_2{

	Building.usage = “ClassIINeighborhoodLivingFacility.MassageParlor”

}

Building myBuilding3_1{

	Building.usage = “CulturalAndAssemblyFacility.PerformanceHall”

Building.usage = “CulturalAndAssemblyFacility.Auditorium”

}

Building myBuilding3_2{

	Building.usage = “CulturalAndAssemblyFacility.AssemblyHall”

}

Building myBuilding3_3{

	Building.usage = “CulturalAndAssemblyFacility.ExhibitionHall”

Building.usage = “CulturalAndAssemblyFacility.ZoologicalAndBotanicalGarden”

}

Building myBuilding4_1{

	Building.usage = “ReligiousFacility.ReligiousAssemblyFacility”

	Building.facilityArea >= 500 m2

}

Building myBuilding5_1{

	Building.usage = “CommercialFacility.WholesaleMarket”

	Building.usage = “CommercialFacility.RetailMarket”

	Building.usage = “CommercialFacility.Shop”

	Building.facilityArea >= 1000 m2

}

Building myBuilding6_1{

	Building.usage = “MedicalFacility.Hospital”

	Building.usage = “MedicalFacility.DetentionHospital”

}

Building myBuilding7_1{

	Building.usage = “EducationAndResearchFacility.School”

	Building.usage = “EducationAndResearchFacility.SpecialSchool”

	Building.usage != “EducationAndResearchFacility.Kindergarten”

}

Building myBuilding7_2{

	Building.usage = “EducationAndResearchFacility.Kindergarten”

}

Building myBuilding7_3{

	Building.usage = “EducationAndResearchFacility.TrainingInstitute”

	Building.usage = “EducationAndResearchFacility.VocationalTrainingCenter”

	Building.usage != “EducationAndResearchFacility.EducationalInstitute”

Building.facilityArea >= 500 m2

}

Building myBuilding8_1{

	Building.usage = “FacilitiesForTheAgedAndChildren.ChildrenRelatedFacility”

Building.usage = “FacilitiesForTheAgedAndChildren.WelfareFacilityForTheAged”

Building.usage = “FacilitiesForTheAgedAndChildren.SocialWelfareFacility”

Building.usage = “경로당”

Building.usage = “ResidentialFacilityForTheDisabled”

Building.facilityArea >= 500 m2

}

Building myBuilding9_1{

	Building.usage = “Trainingfacility.TrainingFacilityInLivingZone”

	Building.usage = “Trainingfacility.TrainingFacilityInNatureZone”

}

Building myBuilding10_1{

	Building.usage = “SportsFacility”

Building.facilityArea >= 500 m2

}

Building myBuilding11_1{

	Building.usage = “BusinessFacility.GovernmentOfficeBuilding”

Building.facilityArea >= 500 m2

}

Building myBuilding11_2{

	Building.usage = “BusinessFacility.FinanceBusiness”

	Building.usage = “BusinessFacility.Office”

	Building.usage = “BusinessFacility.NewspaperOffice”

	Building.usage = “BusinessFacility.Officetel”

Building.facilityArea >= 500 m2

}

Building myBuilding12_1{

	Building.usage = “LodgingFacility.GeneralLodgingFacility”

}

Building myBuilding12_2{

	Building.usage = “LodgingFacility.TouristAccommodation”

}

Building myBuilding13_1{

	Building.usage = “Factory”

}

Building myBuilding14_1{

	Building.usage = “FacilityForMotorVehicle.ParkingLot”

Building.usage = “FacilityForMotorVehicle.DrivingSchool”

}

Building myBuilding15_1{

	Building.usage = “FacilityForBroadcastingAndTelecommunication.BroadcastingStation”

Building.facilityArea >= 1000 m2

}

Building myBuilding15_2{

	Building.usage = “FacilityForBroadcastingAndTelecommunication.TelegraphAndTelephoneStation”

Building.facilityArea >= 1000 m2

}

Building myBuilding16_1{

	Building.usage = “CorrectionalFacilityAndMilitaryInstallation.Prison”

Building.usage = “CorrectionalFacilityAndMilitaryInstallation.DetentionCenter”

}

Building myBuilding17_1{

	Building.usage = “CemeteryAndRelatedFacility.CremationFacility”

	Building.usage = “CemeteryAndRelatedFacility.CharnelHouse”

	Building.usage != “ReligiousFacility”

}

Building myBuilding18_1{

	Building.usage = “FacilityForTourismAndRelaxation.BandStand”

	Building.usage = “FacilityForTourismAndRelaxation.OutdoorTheater”

	Building.usage = “FacilityForTourismAndRelaxation.ChildrenCenter”

}

Building myBuilding18_2{

	Building.usage = “FacilityForTourismAndRelaxation.RestArea”

}

Building myBuilding19_1{

	Building.usage = “FuneralParlor”

}







Check(EDCDAPA_*_2_3_나){

IF (CS1 THEN KS1) OR (CS2 THEN KS2)

}



CS1{

Building myBuilding20_1 {

getObject(myBuilding1_1 | myBuilding12_2)

}

KS1{

hasSpace(myBuilding20_1, myParkingLot) = TRUE 

OR hasSpace(myBuilding20_1, myParkingLot) = FALSE

}

CS2{

 Building myBuilding20_2 {

getObject(myBuilding1_2 | myBuilding1_3 | myBuilding1_4 | myBuilding2_1 | myBuilding2_2 | myBuilding3_1 | myBuilding3_2 | myBuilding3_3 | myBuilding4_1 | myBuilding5_1 | Building myBuilding6_1 | Building myBuilding7_1 | myBuilding7_2 | myBuilding7_3 | myBuilding8_1 | myBuilding9_1 | myBuilding10_1 | myBuilding11_1 | myBuilding11_2 | myBuilding12_1 | myBuilding13_1 | myBuilding14_1 | myBuilding15_1 | myBuilding15_2 | myBuilding16_1 | myBuilding17_1 | myBuilding18_1 | myBuilding18_2 | myBuilding19_1) 

}

KS2{

hasSpace(Building20_2, myParkingLot) = TRUE

}



Check(EDCDAPA_*_2_3_나){

IF CS THEN KS



CS{

Building myBuilding20_3{

getObject(myBuilding1_1 | myBuilding1_2 | myBuilding1_3 | myBuilding1_4 | myBuilding1_5 | myBuilding1_6 | myBuilding2_1 | myBuilding2_2 | myBuilding3_1 | myBuilding3_2 | myBuilding3_3 | myBuilding4_1 | myBuilding5_1 | Building myBuilding6_1 | Building myBuilding7_1 | myBuilding7_2 | myBuilding7_3 | myBuilding8_1 | myBuilding9_1 | myBuilding10_1 | myBuilding11_1 | myBuilding11_2 | myBuilding12_1 | myBuilding13_1 | myBuilding14_1 | myBuilding15_1 | myBuilding15_2 | myBuilding16_1 | myBuilding17_1 | myBuilding18_1 | myBuilding18_2 | myBuilding19_1) 

}

KS{

isObjectProperty(myBuilding20_3.Door.isSillFree) = TRUE

} 




Python Code 변환 예정



78
주차장법 시행령 제 별표1조

부설주차장의 설치대상 시설물 종류 및 설치기준(제6조제1항 관련) (시설물 :설치기준) 1. 위락시설 :○ 시설면적 100㎡당 1대(시설면적/100㎡) 2. 문화 및 집회시설(관람장은 제외한다), 종교시설, 판매시설, 운수시설, 의료시설(정신병원·요양병원 및 격리병원은 제외한다), 운동시설(골프장·골프연습장 및 옥외수영장은 제외한다), 업무시설(외국공관 및 오피스텔은 제외한다), 방송통신시설 중 방송국, 장례식장 :○ 시설면적 150㎡당 1대(시설면적/





//주차장법 시행령 별표1 부설주차장의 설치대상 시설물 종류 및 설치기준





Check(EDPA_*_1_1){

IF CS THEN KS

}

Space mySpace1{

getBuildingUsage()=” AmusementFacility”

myTotalFloorArea = getTotalFloorArea(mySpace1)

CS{

isExist(mySpace1)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea/100

}





Check(EDPA_*_1_2){

IF CS THEN KS

}

Space mySpace2{

(getBuildingUsage()= “CulturalAndAssemblyFacility”

AND getBuildingUsage() !=” Auditorium”)

OR (getBuildingUsage() = “ReligiousFacility | CommercialFacility | TransportationFacilit”

OR getBuildingUsage() = ”MedicalFacility”

AND getBuildingUsage() != “MentalHospital | ConvalescentHospital | DetentionHoispital”)

OR (getBuildingUsage() = “SportsFacility” 

AND getBuildingUsage() != “GolfCourse | GolfDrivingRange | OurdoorSwimmingPool”)

OR (getBuildingUsage()= “BusinessFacility”

AND getBuildingUsage() != “ForeignOfficialResidence | Officetels” )

}

myTotalFloorArea2 = getTotalFloorArea(mySpace2)

}

CS{

isExist(mySpace2)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea2/150

}



Check(EDPA_*_1_3){

IF CS THEN KS

}

Space mySpace3{

 ((getBuildingUsage ()=” ClassINeighborhoodLivingFacility”

AND getSpaceUsage != “PublicToilet | Shelter | CommunityChildCenter”)

OR getBuildingUsage ()=”ClassIINeighborhoodLivingFacility”

OR getBuildingUsage ()=”LodgingFacility”)

}

myTotalFloorArea3 = getTotalFloorArea(mySpace3)

}

CS{

isExist(mySpace3)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea3/200

}





Check(EDPA_*_1_4){

IF CS1 THEN KS1 OR CS2 THEN KS2

}

Space mySpace1{

getBuildingUsage ()=” DetachedHouse”

}

myTotalFloorArea = getTotalFloorArea(mySpace1)

}

CS1{

myTotalFloorArea>50 

AND myTotalFloorArea<=150

}

KS1{

isObjectProperty(parkingLot.numberofParkingUnit)=1

}

CS2{

myTotalFloorArea>150 

}

KS2{

(myTotalFloorArea-150)/100+1=ParkingLot.numberofParkingUnit

}





Check(EDPA_*_1_7){

IF CS THEN KS

}

Space mySpace7{

getBuildingUsage ()=”Trainingfacility” 

getBuildingUsage ()=”Factory”

getBuildingUsage () != ”AptartmentTypeFactory”

}

myTotalFloorArea7 = getTotalFloorArea(myspace7)

CS{

isExist(mySpace7)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea7/400

}



Check(EDPA_*_1_8){

IF CS THEN KS

}

Space mySpace8{

getBuildingUsage ()= “Warehouse”

}

myTotalFloorArea8 = getTotalFloorArea(mySpace8)

}

CS{

isExist(mySpace8)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea8/400

}



Check(EDPA_*_1_9){

IF CS THEN KS

}

Space mySpace9{

getBuildingUsage ()= “DormitoryForStudents”

}

myTotalFloorArea9 = getTotalFloorArea(myspace9)

CS{

isExist(mySpace9)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea9/400

}





Check(EDPA_*_1_10){

IF CS THEN KS

}

Space mySpace10 { 

getObject(Space) != myspace1 | myspace2 | myspace3 | myspace4 | myspace5 | myspace6 | myspace7 | myspace8 | myspace9 |

}

myTotalFloorArea10 = getTotalFloorArea(mySpace10)

}

CS{

isExist(mySpace9)=TRUE

} 

KS{

ParkingLot.numberOfParkingUnit<=myTotalFloorArea10/300

}





Check(EDPA_*_1_0_1){

IF CS THEN KS

}

CS{

getResult(EDPA_*_1_0_1_가)= TRUE

OR getResult(EDPA_*_1_0_1_나)= TRUE

OR getResult(EDPA_*_1_0_1_다)= TRUE

OR getResult(EDPA_*_1_0_1_라)= TRUE

OR getResult(EDPA_*_1_0_1_마)= TRUE

OR getResult(EDPA_*_1_0_1_바)= TRUE

OR getResult(EDPA_*_1_0_1_사)= TRUE

}

KS{

isExist(ParkingLot.isAttachedParking)=FALSE

}



Check(EDPA_*_1_0_1_가){

KS

}

isExist(ClassINeighborhoodLivingFacility.Substation)=TRUE

OR isExist(ClassINeighborhoodLivingFacility.PumpingStation)=TRUE

OR isExist(ClassINeighborhoodLivingFacility.PurificationPlant)=TRUE

OR isExist(ClassINeighborhoodLivingFacility.Shelter)=TRUE

OR isExist(ClassINeighborhoodLivingFacility.PublicToilet)=TRUE

Check(EDPA_*_1_0_1_나){

KS

}

isExist(ReligiousFacility.Monastery)=TRUE

OR isExist(ReligiousFacility.Convent)=TRUE

OR isExist(ReligiousFacility.Chapel)=TRUE

OR isExist(ReligiousFacility.Shrine)=TRUE

Check(EDPA_*_1_0_1_다){

KS

}

isExist(getBuildingUsage()=”FacilityForAnimalAndPlant”)=TRUE

AND isExist(getBuildingUsage()=”SlaughterHouse”)=FALSE

AND isExist(getBuildingUsage()=”ChickenSlaughterHouse”)=FALSE

Check(EDPA_*_1_0_1_라){

KS

}

isExist(FacilityForBroadcastingAndTelecommunication.TransmitAndReceptionAndTransitFacility)=TRUE

Check(EDPA_*_1_0_1_마){

KS

}

getObjectProperty(Building.isExclusiveUseOfParkingLot) = FALSE

(getBuildingUsage() != "CommercialFacility.DepartmentStore" OR "CommercialFacility.ShoppingCenter" OR  "LargeStore"

OR getBuildingUsage() != "CulturalAndAssemblyFacility.MovieTheater" OR  "CulturalAndAssemblyFacility.ExhibitionHall" OR "CulturalAndAssemblyFacility.WeddingHall"

Check(EDPA_*_1_0_1_바){

KS

}

getBuildingUsage()= “Station”

Check(EDPA_*_1_0_1_사){

KS

}

getResult(EDBA_6_1_4)=TRUE









Check(EDPA_*_1_0_4){

KS

}

Space mySpace{

getBuildingUsage()= “DetachedHouse”

getBuildingUsage() !=”Multi-familyHouses”

}

getTotalArea(mySpace)<=50m2

getTotalArea(mySpace)/100 = ParkingLot.numberOfParkingUnit 




Python Code 변환 예정



    1