change to Linux

This commit is contained in:
liuyihui 2022-10-16 17:16:25 +08:00
parent c73aff1d91
commit e7a39b42c3
177 changed files with 135091 additions and 135094 deletions

View File

@ -1,208 +1,208 @@
--- ---
Language: Cpp Language: Cpp
# BasedOnStyle: Google # BasedOnStyle: Google
AccessModifierOffset: -4 AccessModifierOffset: -4
AlignAfterOpenBracket: Align AlignAfterOpenBracket: Align
AlignArrayOfStructures: None AlignArrayOfStructures: None
AlignConsecutiveMacros: None AlignConsecutiveMacros: None
AlignConsecutiveAssignments: None AlignConsecutiveAssignments: None
AlignConsecutiveBitFields: None AlignConsecutiveBitFields: None
AlignConsecutiveDeclarations: None AlignConsecutiveDeclarations: None
AlignEscapedNewlines: Left AlignEscapedNewlines: Left
AlignOperands: Align AlignOperands: Align
AlignTrailingComments: true AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true AllowAllParametersOfDeclarationOnNextLine: true
AllowShortEnumsOnASingleLine: true AllowShortEnumsOnASingleLine: true
AllowShortBlocksOnASingleLine: Never AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All AllowShortFunctionsOnASingleLine: All
AllowShortLambdasOnASingleLine: All AllowShortLambdasOnASingleLine: All
AllowShortIfStatementsOnASingleLine: WithoutElse AllowShortIfStatementsOnASingleLine: WithoutElse
AllowShortLoopsOnASingleLine: true AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterDefinitionReturnType: None AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: true AlwaysBreakBeforeMultilineStrings: true
AlwaysBreakTemplateDeclarations: Yes AlwaysBreakTemplateDeclarations: Yes
AttributeMacros: AttributeMacros:
- __capability - __capability
BinPackArguments: true BinPackArguments: true
BinPackParameters: true BinPackParameters: true
BraceWrapping: BraceWrapping:
AfterCaseLabel: false AfterCaseLabel: false
AfterClass: false AfterClass: false
AfterControlStatement: Never AfterControlStatement: Never
AfterEnum: false AfterEnum: false
AfterFunction: false AfterFunction: false
AfterNamespace: false AfterNamespace: false
AfterObjCDeclaration: false AfterObjCDeclaration: false
AfterStruct: false AfterStruct: false
AfterUnion: false AfterUnion: false
AfterExternBlock: false AfterExternBlock: false
BeforeCatch: false BeforeCatch: false
BeforeElse: false BeforeElse: false
BeforeLambdaBody: false BeforeLambdaBody: false
BeforeWhile: false BeforeWhile: false
IndentBraces: false IndentBraces: false
SplitEmptyFunction: true SplitEmptyFunction: true
SplitEmptyRecord: true SplitEmptyRecord: true
SplitEmptyNamespace: true SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None BreakBeforeBinaryOperators: None
BreakBeforeConceptDeclarations: true BreakBeforeConceptDeclarations: true
BreakBeforeBraces: Attach BreakBeforeBraces: Attach
BreakBeforeInheritanceComma: false BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true BreakStringLiterals: true
ColumnLimit: 120 ColumnLimit: 120
CommentPragmas: '^ IWYU pragma:' CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: true ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 4 ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4 ContinuationIndentWidth: 4
Cpp11BracedListStyle: true Cpp11BracedListStyle: true
DeriveLineEnding: true DeriveLineEnding: true
DerivePointerAlignment: true DerivePointerAlignment: true
DisableFormat: false DisableFormat: false
EmptyLineAfterAccessModifier: Never EmptyLineAfterAccessModifier: Never
EmptyLineBeforeAccessModifier: LogicalBlock EmptyLineBeforeAccessModifier: LogicalBlock
ExperimentalAutoDetectBinPacking: false ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true FixNamespaceComments: true
ForEachMacros: ForEachMacros:
- foreach - foreach
- Q_FOREACH - Q_FOREACH
- BOOST_FOREACH - BOOST_FOREACH
IfMacros: IfMacros:
- KJ_IF_MAYBE - KJ_IF_MAYBE
IncludeBlocks: Regroup IncludeBlocks: Regroup
IncludeCategories: IncludeCategories:
- Regex: '^[<"].*\.h[>"]' - Regex: '^[<"].*\.h[>"]'
Priority: 0 Priority: 0
SortPriority: 0 SortPriority: 0
CaseSensitive: false CaseSensitive: false
- Regex: '^[<"].*\.hh[>"]' - Regex: '^[<"].*\.hh[>"]'
Priority: 1 Priority: 1
SortPriority: 1 SortPriority: 1
CaseSensitive: false CaseSensitive: false
- Regex: '.*' - Regex: '.*'
Priority: 2 Priority: 2
SortPriority: 2 SortPriority: 2
CaseSensitive: false CaseSensitive: false
IncludeIsMainRegex: '([-_](test|unittest))?$' IncludeIsMainRegex: '([-_](test|unittest))?$'
IncludeIsMainSourceRegex: '' IncludeIsMainSourceRegex: ''
IndentAccessModifiers: false IndentAccessModifiers: false
IndentCaseLabels: true IndentCaseLabels: true
IndentCaseBlocks: false IndentCaseBlocks: false
IndentGotoLabels: true IndentGotoLabels: true
IndentPPDirectives: None IndentPPDirectives: None
IndentExternBlock: AfterExternBlock IndentExternBlock: AfterExternBlock
IndentRequires: false IndentRequires: false
IndentWidth: 4 IndentWidth: 4
IndentWrappedFunctionNames: false IndentWrappedFunctionNames: false
InsertTrailingCommas: None InsertTrailingCommas: None
JavaScriptQuotes: Leave JavaScriptQuotes: Leave
JavaScriptWrapImports: true JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false KeepEmptyLinesAtTheStartOfBlocks: false
LambdaBodyIndentation: Signature LambdaBodyIndentation: Signature
MacroBlockBegin: '' MacroBlockBegin: ''
MacroBlockEnd: '' MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1 MaxEmptyLinesToKeep: 1
NamespaceIndentation: None NamespaceIndentation: None
ObjCBinPackProtocolList: Never ObjCBinPackProtocolList: Never
ObjCBlockIndentWidth: 2 ObjCBlockIndentWidth: 2
ObjCBreakBeforeNestedBlockParam: true ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: false ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2 PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 1 PenaltyBreakBeforeFirstCallParameter: 1
PenaltyBreakComment: 300 PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120 PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000 PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10 PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000 PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 200 PenaltyReturnTypeOnItsOwnLine: 200
PenaltyIndentedWhitespace: 0 PenaltyIndentedWhitespace: 0
PointerAlignment: Left PointerAlignment: Left
PPIndentWidth: -1 PPIndentWidth: -1
RawStringFormats: RawStringFormats:
- Language: Cpp - Language: Cpp
Delimiters: Delimiters:
- cc - cc
- CC - CC
- cpp - cpp
- Cpp - Cpp
- CPP - CPP
- 'c++' - 'c++'
- 'C++' - 'C++'
CanonicalDelimiter: '' CanonicalDelimiter: ''
BasedOnStyle: google BasedOnStyle: google
- Language: TextProto - Language: TextProto
Delimiters: Delimiters:
- pb - pb
- PB - PB
- proto - proto
- PROTO - PROTO
EnclosingFunctions: EnclosingFunctions:
- EqualsProto - EqualsProto
- EquivToProto - EquivToProto
- PARSE_PARTIAL_TEXT_PROTO - PARSE_PARTIAL_TEXT_PROTO
- PARSE_TEST_PROTO - PARSE_TEST_PROTO
- PARSE_TEXT_PROTO - PARSE_TEXT_PROTO
- ParseTextOrDie - ParseTextOrDie
- ParseTextProtoOrDie - ParseTextProtoOrDie
- ParseTestProto - ParseTestProto
- ParsePartialTestProto - ParsePartialTestProto
CanonicalDelimiter: pb CanonicalDelimiter: pb
BasedOnStyle: google BasedOnStyle: google
ReferenceAlignment: Pointer ReferenceAlignment: Pointer
ReflowComments: true ReflowComments: true
ShortNamespaceLines: 1 ShortNamespaceLines: 1
SortIncludes: CaseSensitive SortIncludes: CaseSensitive
SortJavaStaticImport: Before SortJavaStaticImport: Before
SortUsingDeclarations: true SortUsingDeclarations: true
SpaceAfterCStyleCast: false SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements SpaceBeforeParens: ControlStatements
SpaceAroundPointerQualifiers: Default SpaceAroundPointerQualifiers: Default
SpaceBeforeRangeBasedForLoopColon: true SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: false SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 2 SpacesBeforeTrailingComments: 2
SpacesInAngles: Never SpacesInAngles: Never
SpacesInConditionalStatement: false SpacesInConditionalStatement: false
SpacesInContainerLiterals: true SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false SpacesInCStyleCastParentheses: false
SpacesInLineCommentPrefix: SpacesInLineCommentPrefix:
Minimum: 1 Minimum: 1
Maximum: -1 Maximum: -1
SpacesInParentheses: false SpacesInParentheses: false
SpacesInSquareBrackets: false SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false SpaceBeforeSquareBrackets: false
BitFieldColonSpacing: Both BitFieldColonSpacing: Both
Standard: Auto Standard: Auto
StatementAttributeLikeMacros: StatementAttributeLikeMacros:
- Q_EMIT - Q_EMIT
StatementMacros: StatementMacros:
- Q_UNUSED - Q_UNUSED
- QT_REQUIRE_VERSION - QT_REQUIRE_VERSION
TabWidth: 8 TabWidth: 8
UseCRLF: false UseCRLF: false
UseTab: Never UseTab: Never
WhitespaceSensitiveMacros: WhitespaceSensitiveMacros:
- STRINGIZE - STRINGIZE
- PP_STRINGIZE - PP_STRINGIZE
- BOOST_PP_STRINGIZE - BOOST_PP_STRINGIZE
- NS_SWIFT_NAME - NS_SWIFT_NAME
- CF_SWIFT_NAME - CF_SWIFT_NAME
... ...

12
.gitignore vendored
View File

@ -1,6 +1,6 @@
# build or cache # build or cache
build/ build/
__pycache__ __pycache__
# visual environment # visual environment
DESCSS/ DESCSS/

View File

@ -1,23 +1,22 @@
{ {
"configurations": [ "configurations": [
{ {
"name": "Win32", "name": "Linux",
"includePath": [ "includePath": [
"${default}", "${default}",
"${workspaceFolder}/include", "${workspaceFolder}/include",
"D:/Geant4/dist/include/Geant4", "/home/fox/G4Kit/Geant4/include",
"D:/ROOT/include" "/home/fox/G4Kit/ROOT/include"
], ],
"defines": [ "defines": [
"_DEBUG", "_DEBUG",
"UNICODE", "UNICODE",
"_UNICODE" "_UNICODE"
], ],
"windowsSdkVersion": "10.0.19041.0", "compilerPath": "/usr/bin/gcc",
"compilerPath": "D:/Microsoft/VisualStudio/2022/Community/VC/Tools/MSVC/14.31.31103/bin/Hostx64/x64/cl.exe",
"cStandard": "c17", "cStandard": "c17",
"cppStandard": "c++17", "cppStandard": "c++17",
"intelliSenseMode": "windows-msvc-x64", "intelliSenseMode": "linux-gcc-x64",
"configurationProvider": "ms-vscode.cmake-tools" "configurationProvider": "ms-vscode.cmake-tools"
} }
], ],

View File

@ -1,3 +0,0 @@
{
"C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools"
}

View File

@ -1,36 +1,37 @@
cmake_minimum_required(VERSION 3.16) cmake_minimum_required(VERSION 3.16)
set(Geant4_DIR D:/Geant4/dist/lib/Geant4-11.0.1) set(Geant4_DIR D:/Geant4/dist/lib/Geant4-11.0.1)
project(DESCSS) project(DESCSS)
option(WITH_GEANT4_UIVIS "Build example with Geant4 UI and Vis drivers" ON) # set(Geant4_DIR ${Geant4_DIR})
if(WITH_GEANT4_UIVIS) option(WITH_GEANT4_UIVIS "Build example with Geant4 UI and Vis drivers" ON)
find_package(Geant4 REQUIRED ui_all vis_all) if(WITH_GEANT4_UIVIS)
else() find_package(Geant4 REQUIRED ui_all vis_all)
find_package(Geant4 REQUIRED) else()
endif() find_package(Geant4 REQUIRED)
endif()
include(${Geant4_USE_FILE})
include_directories(${PROJECT_SOURCE_DIR}/include) include(${Geant4_USE_FILE})
include_directories(${PROJECT_SOURCE_DIR}/include)
file(GLOB sources ${PROJECT_SOURCE_DIR}/src/*.cpp)
file(GLOB headers ${PROJECT_SOURCE_DIR}/include/*.h) file(GLOB sources ${PROJECT_SOURCE_DIR}/src/*.cpp)
file(GLOB headers ${PROJECT_SOURCE_DIR}/include/*.h)
add_executable(DESCSS main.cpp ${sources} ${headers})
target_link_libraries(DESCSS ${Geant4_LIBRARIES}) add_executable(DESCSS main.cpp ${sources} ${headers})
target_link_libraries(DESCSS ${Geant4_LIBRARIES})
set(DESCSS_SCRIPTS
vis.mac set(DESCSS_SCRIPTS
run.bat vis.mac
assets/model.txt run.bat
) assets/model.txt
)
foreach(_script ${DESCSS_SCRIPTS})
configure_file( foreach(_script ${DESCSS_SCRIPTS})
${PROJECT_SOURCE_DIR}/${_script} configure_file(
${PROJECT_BINARY_DIR}/Release/${_script} ${PROJECT_SOURCE_DIR}/${_script}
COPYONLY ${PROJECT_BINARY_DIR}/${_script}
) COPYONLY
endforeach() )
endforeach()
install(TARGETS DESCSS DESTINATION bin)
install(TARGETS DESCSS DESTINATION bin)

View File

@ -1,140 +1,140 @@
{ {
"folders": [ "folders": [
{ {
"path": "." "path": "."
} }
], ],
"settings": { "settings": {
"files.associations": { "files.associations": {
"*.icc": "cpp", "*.icc": "cpp",
"line": "cpp", "line": "cpp",
"plane": "cpp", "plane": "cpp",
"qrot": "cpp", "qrot": "cpp",
"cmath": "cpp", "cmath": "cpp",
"string": "cpp", "string": "cpp",
"vector": "cpp", "vector": "cpp",
"algorithm": "cpp", "algorithm": "cpp",
"array": "cpp", "array": "cpp",
"atomic": "cpp", "atomic": "cpp",
"bit": "cpp", "bit": "cpp",
"cctype": "cpp", "cctype": "cpp",
"cfenv": "cpp", "cfenv": "cpp",
"charconv": "cpp", "charconv": "cpp",
"chrono": "cpp", "chrono": "cpp",
"clocale": "cpp", "clocale": "cpp",
"compare": "cpp", "compare": "cpp",
"complex": "cpp", "complex": "cpp",
"concepts": "cpp", "concepts": "cpp",
"condition_variable": "cpp", "condition_variable": "cpp",
"csetjmp": "cpp", "csetjmp": "cpp",
"csignal": "cpp", "csignal": "cpp",
"cstdarg": "cpp", "cstdarg": "cpp",
"cstddef": "cpp", "cstddef": "cpp",
"cstdint": "cpp", "cstdint": "cpp",
"cstdio": "cpp", "cstdio": "cpp",
"cstdlib": "cpp", "cstdlib": "cpp",
"cstring": "cpp", "cstring": "cpp",
"ctime": "cpp", "ctime": "cpp",
"cwchar": "cpp", "cwchar": "cpp",
"deque": "cpp", "deque": "cpp",
"exception": "cpp", "exception": "cpp",
"format": "cpp", "format": "cpp",
"forward_list": "cpp", "forward_list": "cpp",
"fstream": "cpp", "fstream": "cpp",
"functional": "cpp", "functional": "cpp",
"future": "cpp", "future": "cpp",
"initializer_list": "cpp", "initializer_list": "cpp",
"iomanip": "cpp", "iomanip": "cpp",
"ios": "cpp", "ios": "cpp",
"iosfwd": "cpp", "iosfwd": "cpp",
"iostream": "cpp", "iostream": "cpp",
"istream": "cpp", "istream": "cpp",
"iterator": "cpp", "iterator": "cpp",
"limits": "cpp", "limits": "cpp",
"list": "cpp", "list": "cpp",
"locale": "cpp", "locale": "cpp",
"map": "cpp", "map": "cpp",
"memory": "cpp", "memory": "cpp",
"mutex": "cpp", "mutex": "cpp",
"new": "cpp", "new": "cpp",
"numeric": "cpp", "numeric": "cpp",
"optional": "cpp", "optional": "cpp",
"ostream": "cpp", "ostream": "cpp",
"queue": "cpp", "queue": "cpp",
"ratio": "cpp", "ratio": "cpp",
"regex": "cpp", "regex": "cpp",
"set": "cpp", "set": "cpp",
"sstream": "cpp", "sstream": "cpp",
"stack": "cpp", "stack": "cpp",
"stdexcept": "cpp", "stdexcept": "cpp",
"stop_token": "cpp", "stop_token": "cpp",
"streambuf": "cpp", "streambuf": "cpp",
"system_error": "cpp", "system_error": "cpp",
"thread": "cpp", "thread": "cpp",
"tuple": "cpp", "tuple": "cpp",
"type_traits": "cpp", "type_traits": "cpp",
"typeinfo": "cpp", "typeinfo": "cpp",
"unordered_map": "cpp", "unordered_map": "cpp",
"utility": "cpp", "utility": "cpp",
"xfacet": "cpp", "xfacet": "cpp",
"xhash": "cpp", "xhash": "cpp",
"xiosbase": "cpp", "xiosbase": "cpp",
"xlocale": "cpp", "xlocale": "cpp",
"xlocbuf": "cpp", "xlocbuf": "cpp",
"xlocinfo": "cpp", "xlocinfo": "cpp",
"xlocmes": "cpp", "xlocmes": "cpp",
"xlocmon": "cpp", "xlocmon": "cpp",
"xlocnum": "cpp", "xlocnum": "cpp",
"xloctime": "cpp", "xloctime": "cpp",
"xmemory": "cpp", "xmemory": "cpp",
"xstddef": "cpp", "xstddef": "cpp",
"xstring": "cpp", "xstring": "cpp",
"xtr1common": "cpp", "xtr1common": "cpp",
"xtree": "cpp", "xtree": "cpp",
"xutility": "cpp", "xutility": "cpp",
"matrix": "cpp", "matrix": "cpp",
"vec2f": "cpp", "vec2f": "cpp",
"vec3f": "cpp", "vec3f": "cpp",
"vec4f": "cpp", "vec4f": "cpp",
"sf_vec": "cpp", "sf_vec": "cpp",
"sf_vec3f": "cpp", "sf_vec3f": "cpp",
"aida_ntuple": "cpp", "aida_ntuple": "cpp",
"handle": "cpp", "handle": "cpp",
"img": "cpp", "img": "cpp",
"mat": "cpp", "mat": "cpp",
"mapmanip": "cpp", "mapmanip": "cpp",
"basket": "cpp", "basket": "cpp",
"branch": "cpp", "branch": "cpp",
"dummy": "cpp", "dummy": "cpp",
"graph": "cpp", "graph": "cpp",
"info": "cpp", "info": "cpp",
"iros": "cpp", "iros": "cpp",
"leaf": "cpp", "leaf": "cpp",
"named": "cpp", "named": "cpp",
"obj_array": "cpp", "obj_array": "cpp",
"obj_list": "cpp", "obj_list": "cpp",
"stl_vector": "cpp", "stl_vector": "cpp",
"tree_index": "cpp", "tree_index": "cpp",
"vector3": "cpp", "vector3": "cpp",
"style_parser": "cpp", "style_parser": "cpp",
"vmanip": "cpp", "vmanip": "cpp",
"element": "cpp", "element": "cpp",
"tree": "cpp", "tree": "cpp",
"vertices": "cpp", "vertices": "cpp",
"c1d": "cpp", "c1d": "cpp",
"dps": "cpp", "dps": "cpp",
"rotf": "cpp", "rotf": "cpp",
"vec2": "cpp", "vec2": "cpp",
"vec3": "cpp", "vec3": "cpp",
"vec4": "cpp", "vec4": "cpp",
"bsf": "cpp", "bsf": "cpp",
"senum": "cpp", "senum": "cpp",
"value": "cpp", "value": "cpp",
"ntuple": "cpp", "ntuple": "cpp",
"free_seg": "cpp", "free_seg": "cpp",
"base_histo": "cpp", "base_histo": "cpp",
"c2d": "cpp", "c2d": "cpp",
"c3d": "cpp" "c3d": "cpp"
} }
} }
} }

762
README.md
View File

@ -1,381 +1,381 @@
<style> <style>
td {min-width: 80px;} td {min-width: 80px;}
.tg {border-collapse:collapse;border-spacing:0;} .tg {border-collapse:collapse;border-spacing:0;}
.tg td{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px; .tg td{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;
overflow:hidden;padding:10px 5px;word-break:normal;} overflow:hidden;padding:10px 5px;word-break:normal;}
.tg th{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px; .tg th{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;
font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;} font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg .tg-wa1i{font-weight:bold;text-align:center;vertical-align:middle} .tg .tg-wa1i{font-weight:bold;text-align:center;vertical-align:middle}
.tg .tg-uzvj{border-color:inherit;font-weight:bold;text-align:center;vertical-align:middle} .tg .tg-uzvj{border-color:inherit;font-weight:bold;text-align:center;vertical-align:middle}
.tg .tg-nrix{text-align:center;vertical-align:middle} .tg .tg-nrix{text-align:center;vertical-align:middle}
</style> </style>
# DESCSS # DESCSS
Dose Estimation by Simulation of China Space Station Dose Estimation by Simulation of China Space Station
中国空间站模拟剂量评估 中国空间站模拟剂量评估
## 空间辐射环境 ## 空间辐射环境
### 轨道 ### 轨道
1. 空间站轨道根数(`TLE`, `2022.05.11`[^1] 1. 空间站轨道根数(`TLE`, `2022.05.11`[^1]
``` ```
1 48274U 21035A 22131.00000000 .00018566 00000-0 21317-3 0 9998 1 48274U 21035A 22131.00000000 .00018566 00000-0 21317-3 0 9998
2 48274 41.4696 84.9802 0011517 308.1456 44.4159 15.61130380 58963 2 48274 41.4696 84.9802 0011517 308.1456 44.4159 15.61130380 58963
``` ```
<div align=center> <div align=center>
| 偏心率 | 倾角<br/>deg | 升交点赤经<br/>deg | 近地点辐角<br/>deg | 平近点角<br/>deg | | 偏心率 | 倾角<br/>deg | 升交点赤经<br/>deg | 近地点辐角<br/>deg | 平近点角<br/>deg |
|:--------:|:------------:|:-----------------:|:-----------------:|:---------------:| |:--------:|:------------:|:-----------------:|:-----------------:|:---------------:|
| 0.001152 | 41.4696 | 84.9802 | 308.1456 | 44.4159 | | 0.001152 | 41.4696 | 84.9802 | 308.1456 | 44.4159 |
</div> </div>
2. 轨道参数 2. 轨道参数
平近点角$M$与偏近点角$E$满足: 平近点角$M$与偏近点角$E$满足:
$$ $$
M = E - e\cdot\sin{E} M = E - e\cdot\sin{E}
$$ $$
真近点角$T$与偏近点角$E$满足: 真近点角$T$与偏近点角$E$满足:
$$ $$
\tan{\frac{T}{2}}=\sqrt{\frac{1+e}{1-e}}\tan{\frac{E}{2}} \tan{\frac{T}{2}}=\sqrt{\frac{1+e}{1-e}}\tan{\frac{E}{2}}
$$ $$
由此有: 由此有:
<div align=center> <div align=center>
| 近地点<br/>km | 远地点<br/>km | 倾角<br/>deg | 升交点赤经<br/>deg | 近地点辐角<br/>deg | 偏近点角<br/>deg | 真近点角<br/>deg | | 近地点<br/>km | 远地点<br/>km | 倾角<br/>deg | 升交点赤经<br/>deg | 近地点辐角<br/>deg | 偏近点角<br/>deg | 真近点角<br/>deg |
|:----------:|:----------:|:------------:|:-----------------:|:-----------------:|:---------------:|:---------------:| |:----------:|:----------:|:------------:|:-----------------:|:-----------------:|:---------------:|:---------------:|
| 379.2 | 393.8 | 41.4696 | 84.9802 | 308.1456 | 44.4167 | 44.4629 | | 379.2 | 393.8 | 41.4696 | 84.9802 | 308.1456 | 44.4167 | 44.4629 |
</div> </div>
3. 生成轨道 3. 生成轨道
使用`SPENVIS`的`Coordinate generators`生成预计轨道总计30天保存为`assets/orbit.csv`文件。 使用`SPENVIS`的`Coordinate generators`生成预计轨道总计30天保存为`assets/orbit.csv`文件。
<div align=center><img src="docs/orbit.png" style="max-width: 50%;"></div> <div align=center><img src="docs/orbit.png" style="max-width: 50%;"></div>
### 辐射环境 ### 辐射环境
#### 银河宇宙射线[^2] #### 银河宇宙射线[^2]
银河宇宙射线 (`GCR``Galactic cosmic rays`) 是从系外进入太阳系的高能带电粒子,其通量与太阳活动负相关,主要由质子、电子和完全电离的原子核组成,核成分约占$98\%$,分别为`H`$\approx87\%$)、`He`$\approx12\%$)和少量较重的原子核($\approx1\%$)。 银河宇宙射线 (`GCR``Galactic cosmic rays`) 是从系外进入太阳系的高能带电粒子,其通量与太阳活动负相关,主要由质子、电子和完全电离的原子核组成,核成分约占$98\%$,分别为`H`$\approx87\%$)、`He`$\approx12\%$)和少量较重的原子核($\approx1\%$)。
`GCR`一般各向同性,通量约为$1\sim10\ \mathrm{cm^{-2}s^{1}}$,以高能粒子为主(可达到$10^{11}\ \mathrm{GeV}$),贡献绝大部分有效剂量。一般在太阳活动极小时最大(还取决太阳磁性)。 `GCR`一般各向同性,通量约为$1\sim10\ \mathrm{cm^{-2}s^{1}}$,以高能粒子为主(可达到$10^{11}\ \mathrm{GeV}$),贡献绝大部分有效剂量。一般在太阳活动极小时最大(还取决太阳磁性)。
`GCR`中还包含有所谓异常成分(`anomalous component`),星际间的中性粒子进入太阳系后,太阳辐射使其失去电子,离子太阳风作用和碰撞加速,其穿透地磁场的能力比其他成分更大,又可分为部分电离(`singly-ionized anomalous component`)和完全电离(`fully-ionized anomalous component`)。 `GCR`中还包含有所谓异常成分(`anomalous component`),星际间的中性粒子进入太阳系后,太阳辐射使其失去电子,离子太阳风作用和碰撞加速,其穿透地磁场的能力比其他成分更大,又可分为部分电离(`singly-ionized anomalous component`)和完全电离(`fully-ionized anomalous component`)。
考虑异常部分,我们使用`SPENVIS`+`CREME86`模型进行模拟获取1号`H`至28号`Ni`)元素在$90\%$最坏情况下的`GCR`通量(即实际情况大约只有$10\%$的可能通量大于这一估计值,`M=3`)。 考虑异常部分,我们使用`SPENVIS`+`CREME86`模型进行模拟获取1号`H`至28号`Ni`)元素在$90\%$最坏情况下的`GCR`通量(即实际情况大约只有$10\%$的可能通量大于这一估计值,`M=3`)。
<div align=center><img src="docs/spectra-M3.png"></div> <div align=center><img src="docs/spectra-M3.png"></div>
#### 太阳辐射[^3] #### 太阳辐射[^3]
太阳辐射的主要来源是日冕抛射和太阳耀斑具有明显的周期性主要的周期有11年、22年等。太阳辐射以质子为主$90\sim95\%$),通量可达$10^9\ \mathrm{cm^{-2}s^{1}}$;其次为α粒子($5\sim8\%$)。太阳活动较强时,质子的比例会上升。 太阳辐射的主要来源是日冕抛射和太阳耀斑具有明显的周期性主要的周期有11年、22年等。太阳辐射以质子为主$90\sim95\%$),通量可达$10^9\ \mathrm{cm^{-2}s^{1}}$;其次为α粒子($5\sim8\%$)。太阳活动较强时,质子的比例会上升。
使用`SPENVIS`+`SAPPHIRE`模型太阳质子和太阳α粒子任务期间总通量,置信概率为$95\%$(即实际情况大约只有$5\%$的可能通量大于这一估计值)。 使用`SPENVIS`+`SAPPHIRE`模型太阳质子和太阳α粒子任务期间总通量,置信概率为$95\%$(即实际情况大约只有$5\%$的可能通量大于这一估计值)。
<div align=center><img src="docs/spectra-sun.png" style="max-width: 80%;"></div> <div align=center><img src="docs/spectra-sun.png" style="max-width: 80%;"></div>
可以发现,整个任务期间的总通量不超过$10^3\ \mathrm{cm^{-2}}$,远远小于银河宇宙射线和俘获辐射带的通量,因此在后续模拟中忽略这一因素的剂量。 可以发现,整个任务期间的总通量不超过$10^3\ \mathrm{cm^{-2}}$,远远小于银河宇宙射线和俘获辐射带的通量,因此在后续模拟中忽略这一因素的剂量。
#### 俘获辐射带[^3] #### 俘获辐射带[^3]
近地俘获辐射带被称为`Van Allen`带,是部分宇宙射线、宇宙射线与地球磁场和大气层作用产生的带电粒子被地磁场俘获形成的辐射带,分为内外两个辐射带。 近地俘获辐射带被称为`Van Allen`带,是部分宇宙射线、宇宙射线与地球磁场和大气层作用产生的带电粒子被地磁场俘获形成的辐射带,分为内外两个辐射带。
电子能量可达$7\ \mathrm{MeV}$,质子能量可达$600\ \mathrm{MeV}$,重带电粒子可达$50\ \mathrm{MeV/u}$,绝大部分是中低能量。 电子能量可达$7\ \mathrm{MeV}$,质子能量可达$600\ \mathrm{MeV}$,重带电粒子可达$50\ \mathrm{MeV/u}$,绝大部分是中低能量。
内带的高度一般在$600\ \mathrm{km}$以上,但是在高纬度地区和南大西洋地区,由于地磁异常,内袋高度会下降至$\sim300\ \mathrm{km}$,因此只有经过这些区域时才会有明显的俘获带电粒子通量。 内带的高度一般在$600\ \mathrm{km}$以上,但是在高纬度地区和南大西洋地区,由于地磁异常,内袋高度会下降至$\sim300\ \mathrm{km}$,因此只有经过这些区域时才会有明显的俘获带电粒子通量。
<div align=center><img src="docs/fluxmap.png" style="max-width: 80%;"></div> <div align=center><img src="docs/fluxmap.png" style="max-width: 80%;"></div>
使用`VDL`的`AE8/AP8`模型,计算轨道上的太阳活动极大时的俘获质子通量和太阳活动极小时的俘获电子通量,对整个任务期间求均值,获得俘获质子/电子通量的能谱。同时使用`AE9/AP9`模型进行计算,通量略高于`AE8/AP8`模型。保险起见,采用`AE9/AP9`模型的结果。 使用`VDL`的`AE8/AP8`模型,计算轨道上的太阳活动极大时的俘获质子通量和太阳活动极小时的俘获电子通量,对整个任务期间求均值,获得俘获质子/电子通量的能谱。同时使用`AE9/AP9`模型进行计算,通量略高于`AE8/AP8`模型。保险起见,采用`AE9/AP9`模型的结果。
<div align=center><img src="docs/spectra-ep.png" style="max-width: 80%;"><br /><span style="color: gray;font-size: 12px;">AE8/AP8模型结果</span></div> <div align=center><img src="docs/spectra-ep.png" style="max-width: 80%;"><br /><span style="color: gray;font-size: 12px;">AE8/AP8模型结果</span></div>
<div align=center><img src="docs/spectra-ep-9.png" style="max-width: 80%;"><br /><span style="color: gray;font-size: 12px;">AE9/AP9模型结果</span></div> <div align=center><img src="docs/spectra-ep-9.png" style="max-width: 80%;"><br /><span style="color: gray;font-size: 12px;">AE9/AP9模型结果</span></div>
### 辐射环境拟合 ### 辐射环境拟合
#### 银河宇宙射线[^4] #### 银河宇宙射线[^4]
考虑`GCR`中1号`H`至28号`Ni`)元素的强度模型,定义粒子刚度(`particle rigidity`$R=\frac{pc}{Ze}$,其中$p$是粒子动量,$c$为光速,$Ze$是粒子电荷量,则有: 考虑`GCR`中1号`H`至28号`Ni`)元素的强度模型,定义粒子刚度(`particle rigidity`$R=\frac{pc}{Ze}$,其中$p$是粒子动量,$c$为光速,$Ze$是粒子电荷量,则有:
$$ $$
F(p,t) = \frac{C_i\beta^{\alpha_i}}{R(p)^{\gamma_i}}\left[\frac{R(p)}{R(p)+(0.37+3\times10^{-4}W(t)^{1.45})}\right]^{b\cdot W(t)+c}\frac{A_i}{Z_i}\frac{1}{\beta} F(p,t) = \frac{C_i\beta^{\alpha_i}}{R(p)^{\gamma_i}}\left[\frac{R(p)}{R(p)+(0.37+3\times10^{-4}W(t)^{1.45})}\right]^{b\cdot W(t)+c}\frac{A_i}{Z_i}\frac{1}{\beta}
$$ $$
其中$pc=\sqrt{2m_0c^2E+E^2}$,不考虑$t$,则$W(t)$为常数,$C_i$$\gamma_i$$\alpha_i$为与粒子有关的常数,$A_i$$Z_i$分别为质量数与电荷数,$\beta=\frac{v}{c}=\frac{pc}{\sqrt{m_0^2c^4+E^2}}$,则可简化为: 其中$pc=\sqrt{2m_0c^2E+E^2}$,不考虑$t$,则$W(t)$为常数,$C_i$$\gamma_i$$\alpha_i$为与粒子有关的常数,$A_i$$Z_i$分别为质量数与电荷数,$\beta=\frac{v}{c}=\frac{pc}{\sqrt{m_0^2c^4+E^2}}$,则可简化为:
$$ $$
F(pc) = \frac{C_1\beta^{\alpha-1}}{pc}\left(\frac{pc}{pc+C_2}\right)^{C_3} F(pc) = \frac{C_1\beta^{\alpha-1}}{pc}\left(\frac{pc}{pc+C_2}\right)^{C_3}
$$ $$
同时考虑简单的双指数模型: 同时考虑简单的双指数模型:
$$ $$
F(E)=C_1e^{-C_2E}(1-e^{-C_3E+C_4}) F(E)=C_1e^{-C_2E}(1-e^{-C_3E+C_4})
$$ $$
两者同时进行拟合与比较,同时考虑简洁性,除`H`以外,其余元素均采用双指数模型,`H`采用简化模型。 两者同时进行拟合与比较,同时考虑简洁性,除`H`以外,其余元素均采用双指数模型,`H`采用简化模型。
#### 俘获辐射带 #### 俘获辐射带
1. 电子[^5] 1. 电子[^5]
在轨道较高($L>2.5$)的内带中,电子能谱中有$\sim64\%$符合指数分布,$\sim4\%$符合幂律分布。 在轨道较高($L>2.5$)的内带中,电子能谱中有$\sim64\%$符合指数分布,$\sim4\%$符合幂律分布。
但在本例中,轨道较低($L\sim1.06$),因此使用指数模型$j = j_0e^{-\frac{E}{E_0}}$和幂律模型$j=j_0E^{-\alpha}$进行拟合,随后使用`Origin Lab`对两者进行`BIC test`,最终选用指数模型$j_0=1.333680\times10^6,\ E_0=0.0824$。 但在本例中,轨道较低($L\sim1.06$),因此使用指数模型$j = j_0e^{-\frac{E}{E_0}}$和幂律模型$j=j_0E^{-\alpha}$进行拟合,随后使用`Origin Lab`对两者进行`BIC test`,最终选用指数模型$j_0=1.333680\times10^6,\ E_0=0.0824$。
<div align=center> <div align=center>
| Model | $R^2$ | BIC | BIC diff | | Model | $R^2$ | BIC | BIC diff |
|:-----:|:-------:|:---------:|:--------:| |:-----:|:-------:|:---------:|:--------:|
| Ex | 0.98107 | 402.50208 | 0 | | Ex | 0.98107 | 402.50208 | 0 |
| Pow | 0.94279 | 423.51296 | 21.01088 | | Pow | 0.94279 | 423.51296 | 21.01088 |
</div> </div>
<div align=center><img src="docs/ExFit-trapped-electron.png" style="max-width: 80%;"><br /></div> <div align=center><img src="docs/ExFit-trapped-electron.png" style="max-width: 80%;"><br /></div>
2. 质子 2. 质子
与电子保持一致,幂律模型修改为$j=j_0(E-\beta)^{-\alpha}$,进行`BIC test`,最终选用幂律模型$j_0=559.76377,\ \alpha=2.40873,\ \beta=-1.53424$。 与电子保持一致,幂律模型修改为$j=j_0(E-\beta)^{-\alpha}$,进行`BIC test`,最终选用幂律模型$j_0=559.76377,\ \alpha=2.40873,\ \beta=-1.53424$。
<div align=center> <div align=center>
| Model | $R^2$ | BIC | BIC diff | | Model | $R^2$ | BIC | BIC diff |
|:-----:|:-------:|:--------:|:--------:| |:-----:|:-------:|:--------:|:--------:|
| Ex | 0.9957 | 67.24594 | 0 | | Ex | 0.9957 | 67.24594 | 0 |
| Pow-T | 0.99883 | 39.11969 | 28.12625 | | Pow-T | 0.99883 | 39.11969 | 28.12625 |
</div> </div>
<div align=center><img src="docs/ExFit-trapped-proton.png" style="max-width: 80%;"><br /></div> <div align=center><img src="docs/ExFit-trapped-proton.png" style="max-width: 80%;"><br /></div>
## 辐射源设置 ## 辐射源设置
考虑在`World`球面上均匀随机发射粒子(各向同性),保证入射方向为球内,则球面上的计数率为: 考虑在`World`球面上均匀随机发射粒子(各向同性),保证入射方向为球内,则球面上的计数率为:
$$ $$
F = A\int_{E_a}^{E_b} \phi(E)\mathrm{d}E,\ A=4\pi R^2 F = A\int_{E_a}^{E_b} \phi(E)\mathrm{d}E,\ A=4\pi R^2
$$ $$
`GCR`的单位为$\mathrm{m^{-2}sr^{-1}s^{-1}}$,乘以$4\pi A$即可得到计数率;俘获辐射的单位为$\mathrm{cm^{-2}s^{-1}}$,乘以$A$即可得到计数率。经过检验模型中使用的外壳3层2mm 铝 + 10mm 芳纶 + 5mm 铝)能够抵挡能量在$50\ \mathrm{MeV}$以下的质子和能量在$100\ \mathrm{keV}$以下的电子。 `GCR`的单位为$\mathrm{m^{-2}sr^{-1}s^{-1}}$,乘以$4\pi A$即可得到计数率;俘获辐射的单位为$\mathrm{cm^{-2}s^{-1}}$,乘以$A$即可得到计数率。经过检验模型中使用的外壳3层2mm 铝 + 10mm 芳纶 + 5mm 铝)能够抵挡能量在$50\ \mathrm{MeV}$以下的质子和能量在$100\ \mathrm{keV}$以下的电子。
考虑到`GCR`和俘获辐射计数率相差太大,分为两部分分别进行模拟,同时按比例进行放缩,保证每一类粒子的模拟入射数目均不小于$10^5$。模拟得到剂量率后,乘以缩放系数和任务时长($30\ \mathrm{d}\times86400\ \mathrm{s/d}$),即可得到完整剂量。 考虑到`GCR`和俘获辐射计数率相差太大,分为两部分分别进行模拟,同时按比例进行放缩,保证每一类粒子的模拟入射数目均不小于$10^5$。模拟得到剂量率后,乘以缩放系数和任务时长($30\ \mathrm{d}\times86400\ \mathrm{s/d}$),即可得到完整剂量。
<div align=center> <div align=center>
| Partical | Model | $R^2$ | $E_{min}(\mathrm{MeV})$ | $E_{max}(\mathrm{MeV})$ | Flux($\mathrm{s^{-1}}$) | Run | Zoom Factor | | Partical | Model | $R^2$ | $E_{min}(\mathrm{MeV})$ | $E_{max}(\mathrm{MeV})$ | Flux($\mathrm{s^{-1}}$) | Run | Zoom Factor |
|:--------:|:--------------------------------------------------------------------:|:-------:|:-----------------------:|:-----------------------:|:-----------------------:|:-------:|:-----------:| |:--------:|:--------------------------------------------------------------------:|:-------:|:-----------------------:|:-----------------------:|:-----------------------:|:-------:|:-----------:|
| $e^{-}$ | $j=j_0e^{-\frac{E}{E_0}}$ | 0.98107 | 0.1 | 10 | 9.23242E+11 | 923242 | 999999.8096 | | $e^{-}$ | $j=j_0e^{-\frac{E}{E_0}}$ | 0.98107 | 0.1 | 10 | 9.23242E+11 | 923242 | 999999.8096 |
| `p` | $j=j_0(E-\beta)^{-\alpha}$ | 0.99883 | 50 | 1000 | 42853994.15 | 100000 | 428.5399415 | | `p` | $j=j_0(E-\beta)^{-\alpha}$ | 0.99883 | 50 | 1000 | 42853994.15 | 100000 | 428.5399415 |
| `H` | $\frac{C_1\beta^{\alpha-1}}{pc}\left(\frac{pc}{pc+C_2}\right)^{C_3}$ | 0.98915 | 220 | 100000 | 12854310.92 | 100000 | 128.5431092 | | `H` | $\frac{C_1\beta^{\alpha-1}}{pc}\left(\frac{pc}{pc+C_2}\right)^{C_3}$ | 0.98915 | 220 | 100000 | 12854310.92 | 100000 | 128.5431092 |
| `He` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98936 | 220 | 100000 | 1720188.128 | 100000 | 17.20188128 | | `He` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98936 | 220 | 100000 | 1720188.128 | 100000 | 17.20188128 |
| `Li` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99755 | 220 | 100000 | 12988.97006 | 100000 | 0.129889701 | | `Li` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99755 | 220 | 100000 | 12988.97006 | 100000 | 0.129889701 |
| `Be` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99708 | 220 | 100000 | 6691.176848 | 100000 | 0.066911768 | | `Be` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99708 | 220 | 100000 | 6691.176848 | 100000 | 0.066911768 |
| `B` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99569 | 220 | 100000 | 17105.83698 | 100000 | 0.17105837 | | `B` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99569 | 220 | 100000 | 17105.83698 | 100000 | 0.17105837 |
| `C` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98936 | 220 | 100000 | 52286.55444 | 100000 | 0.522865544 | | `C` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98936 | 220 | 100000 | 52286.55444 | 100000 | 0.522865544 |
| `N` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98892 | 220 | 100000 | 13576.5542 | 100000 | 0.135765542 | | `N` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98892 | 220 | 100000 | 13576.5542 | 100000 | 0.135765542 |
| `O` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98936 | 220 | 100000 | 48846.63508 | 100000 | 0.488466351 | | `O` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98936 | 220 | 100000 | 48846.63508 | 100000 | 0.488466351 |
| `F` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99323 | 220 | 100000 | 1123.492483 | 100000 | 0.011234925 | | `F` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99323 | 220 | 100000 | 1123.492483 | 100000 | 0.011234925 |
| `Ne` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99014 | 220 | 100000 | 8071.585382 | 100000 | 0.080715854 | | `Ne` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99014 | 220 | 100000 | 8071.585382 | 100000 | 0.080715854 |
| `Na` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99263 | 220 | 100000 | 1866.8702 | 100000 | 0.018668702 | | `Na` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99263 | 220 | 100000 | 1866.8702 | 100000 | 0.018668702 |
| `Mg` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98972 | 220 | 100000 | 10936.4597 | 100000 | 0.109364597 | | `Mg` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98972 | 220 | 100000 | 10936.4597 | 100000 | 0.109364597 |
| `Al` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99217 | 220 | 100000 | 1940.381408 | 100000 | 0.019403814 | | `Al` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99217 | 220 | 100000 | 1940.381408 | 100000 | 0.019403814 |
| `Si` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98873 | 220 | 100000 | 8269.257173 | 100000 | 0.082692572 | | `Si` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98873 | 220 | 100000 | 8269.257173 | 100000 | 0.082692572 |
| `P` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99183 | 220 | 100000 | 413.8897994 | 100000 | 0.004138898 | | `P` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99183 | 220 | 100000 | 413.8897994 | 100000 | 0.004138898 |
| `S` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98873 | 220 | 100000 | 1660.990128 | 100000 | 0.016609901 | | `S` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98873 | 220 | 100000 | 1660.990128 | 100000 | 0.016609901 |
| `Cl` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99087 | 220 | 100000 | 372.0271181 | 100000 | 0.003720271 | | `Cl` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99087 | 220 | 100000 | 372.0271181 | 100000 | 0.003720271 |
| `Ar` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99432 | 220 | 100000 | 751.7977189 | 100000 | 0.007517977 | | `Ar` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99432 | 220 | 100000 | 751.7977189 | 100000 | 0.007517977 |
| `K` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98963 | 220 | 100000 | 466.7118907 | 100000 | 0.004667119 | | `K` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98963 | 220 | 100000 | 466.7118907 | 100000 | 0.004667119 |
| `Ca` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98935 | 220 | 100000 | 1161.900661 | 100000 | 0.011619007 | | `Ca` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.98935 | 220 | 100000 | 1161.900661 | 100000 | 0.011619007 |
| `Sc` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99251 | 220 | 100000 | 231.5541271 | 100000 | 0.002315541 | | `Sc` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99251 | 220 | 100000 | 231.5541271 | 100000 | 0.002315541 |
| `Ti` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.9934 | 220 | 100000 | 829.2810844 | 100000 | 0.008292811 | | `Ti` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.9934 | 220 | 100000 | 829.2810844 | 100000 | 0.008292811 |
| `V` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99424 | 220 | 100000 | 404.1724078 | 100000 | 0.004041724 | | `V` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99424 | 220 | 100000 | 404.1724078 | 100000 | 0.004041724 |
| `Cr` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99313 | 220 | 100000 | 784.0902938 | 100000 | 0.007840903 | | `Cr` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99313 | 220 | 100000 | 784.0902938 | 100000 | 0.007840903 |
| `Mn` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99385 | 220 | 100000 | 570.9732265 | 100000 | 0.005709732 | | `Mn` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99385 | 220 | 100000 | 570.9732265 | 100000 | 0.005709732 |
| `Fe` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99351 | 220 | 100000 | 6028.059963 | 100000 | 0.0602806 | | `Fe` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99351 | 220 | 100000 | 6028.059963 | 100000 | 0.0602806 |
| `Co` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99426 | 220 | 100000 | 20.90356212 | 100000 | 0.000209036 | | `Co` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99426 | 220 | 100000 | 20.90356212 | 100000 | 0.000209036 |
| `Ni` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99231 | 220 | 100000 | 292.9961042 | 100000 | 0.002929961 | | `Ni` | $C_1e^{-C_2E}(1-e^{-C_3E+C_4})$ | 0.99231 | 220 | 100000 | 292.9961042 | 100000 | 0.002929961 |
</div> </div>
由于模型较为复杂,且需要发射的粒子种类繁多,因此使用`G4ParticleGun`生成各类粒子,关键是生成各向同性(在球面上均匀分布)的位置、方向和符合能谱的能量分布。 由于模型较为复杂,且需要发射的粒子种类繁多,因此使用`G4ParticleGun`生成各类粒子,关键是生成各向同性(在球面上均匀分布)的位置、方向和符合能谱的能量分布。
1. `Inverse Transform Method``ITM` 1. `Inverse Transform Method``ITM`
对于一个在$[a, b]$的分布,设其概率密度函数(PDF)为$F(x)$,对其积分可获得累积分布函数(CDF),记为$y=C(x)=\int_a^x F(u)\mathrm{d}u$,其反函数为$C^{-1}(y)$。设$y$为$[0, 1)$上均匀分布的随机数,则$x=C^{-1}(y)$满足$F(x)$的分布。 对于一个在$[a, b]$的分布,设其概率密度函数(PDF)为$F(x)$,对其积分可获得累积分布函数(CDF),记为$y=C(x)=\int_a^x F(u)\mathrm{d}u$,其反函数为$C^{-1}(y)$。设$y$为$[0, 1)$上均匀分布的随机数,则$x=C^{-1}(y)$满足$F(x)$的分布。
2. `Acceptance-Rejection Method``ARM` 2. `Acceptance-Rejection Method``ARM`
对于一个在$[a, b]$的分布,设其概率密度函数(PDF)为$F(x)$,首先生成一个均匀分布随机数$X \sim U(x_{min}, x_{max})$,随后独立生成另一个均匀分布随机数$Y \sim U(y_{min}, y_{max})$,如果$Y \le F(X)$,则保留$X$,保留下来的$X$满足$F(x)$的分布。 对于一个在$[a, b]$的分布,设其概率密度函数(PDF)为$F(x)$,首先生成一个均匀分布随机数$X \sim U(x_{min}, x_{max})$,随后独立生成另一个均匀分布随机数$Y \sim U(y_{min}, y_{max})$,如果$Y \le F(X)$,则保留$X$,保留下来的$X$满足$F(x)$的分布。
`ITM`也被称为反演法,关键是需要获取累积分布函数的逆函数,效率较高;`ARM`本质上是一种模拟算法,效率很低,但是适应性更广,特别是对于一些复杂分布函数。 `ITM`也被称为反演法,关键是需要获取累积分布函数的逆函数,效率较高;`ARM`本质上是一种模拟算法,效率很低,但是适应性更广,特别是对于一些复杂分布函数。
1. 位置生成 1. 位置生成
而发射位置要求在球面上均匀分布。由于球面的面积元$\mathrm{d}\Omega=\sin\theta\mathrm{d}\phi\mathrm{d}\theta$是$\theta$的函数,如果位置向量$\vec{r}(\rho, \phi, \theta)$的$\phi$和$\theta$是在$\phi\in[0, 2\pi)$和$\theta\in[0, \pi]$上均匀分布,选取的点将会在两极较为密集(即),因此可以采用`ITM`方法生成$\theta$$C^{-1}(z)=\cos^{-1}(z)$。 而发射位置要求在球面上均匀分布。由于球面的面积元$\mathrm{d}\Omega=\sin\theta\mathrm{d}\phi\mathrm{d}\theta$是$\theta$的函数,如果位置向量$\vec{r}(\rho, \phi, \theta)$的$\phi$和$\theta$是在$\phi\in[0, 2\pi)$和$\theta\in[0, \pi]$上均匀分布,选取的点将会在两极较为密集(即),因此可以采用`ITM`方法生成$\theta$$C^{-1}(z)=\cos^{-1}(z)$。
```c ```c
double u = rand(); double u = rand();
double v = rand(); double v = rand();
double phi = 2 * pi * u; double phi = 2 * pi * u;
double theta = arccos(2 * v - 1); double theta = arccos(2 * v - 1);
double x = rho * sin(theta) * cos(phi); double x = rho * sin(theta) * cos(phi);
double y = rho * sin(theta) * sin(phi); double y = rho * sin(theta) * sin(phi);
double z = rho * cos(theta); double z = rho * cos(theta);
``` ```
2. 发射方向[^6] 2. 发射方向[^6]
在`Geant4`中,假定粒子的位置矢量为$\vec{r}$,则以$\vec{r}$反方向作为$z$轴正方向建立右手坐标系(简称为`P`系),随机生成指向$\vec{d}$,为了保证发射方向是朝向球面内,因此需要限制$\theta$的最大角度为$90^{\circ}$。 在`Geant4`中,假定粒子的位置矢量为$\vec{r}$,则以$\vec{r}$反方向作为$z$轴正方向建立右手坐标系(简称为`P`系),随机生成指向$\vec{d}$,为了保证发射方向是朝向球面内,因此需要限制$\theta$的最大角度为$90^{\circ}$。
```c ```c
double u = rand(); double u = rand();
double v = rand(); double v = rand();
double phi = 2 * pi * u; double phi = 2 * pi * u;
double theta = arccos(2 * v - 1); double theta = arccos(2 * v - 1);
double x = sin(theta) * cos(phi); double x = sin(theta) * cos(phi);
double y = sin(theta) * sin(phi); double y = sin(theta) * sin(phi);
double z = cos(theta); double z = cos(theta);
``` ```
随后我们需要将$\vec{d}$转化到`World`坐标系(简称为`W`系)中,已知两个坐标系有两个公共点,在`W`系中表示为原点$O$和发射点$\vec{r}=(x_0,y_0,z_0)$,在`P`系中则为$(0,0,\rho)$和原点$O^\prime$,则有: 随后我们需要将$\vec{d}$转化到`World`坐标系(简称为`W`系)中,已知两个坐标系有两个公共点,在`W`系中表示为原点$O$和发射点$\vec{r}=(x_0,y_0,z_0)$,在`P`系中则为$(0,0,\rho)$和原点$O^\prime$,则有:
$$ $$
\begin{bmatrix} \begin{bmatrix}
x\\\ y\\\ z x\\\ y\\\ z
\end{bmatrix} = \lambda R \begin{bmatrix} \end{bmatrix} = \lambda R \begin{bmatrix}
u\\\ v\\\ w u\\\ v\\\ w
\end{bmatrix} + \begin{bmatrix} \end{bmatrix} + \begin{bmatrix}
x_0\\\ y_0\\\ z_0 x_0\\\ y_0\\\ z_0
\end{bmatrix} \end{bmatrix}
\cdots(1) \cdots(1)
$$ $$
其中$\lambda$为尺度比例因子设置为1$R$被称为罗德里格矩阵,定义反对称矩阵: 其中$\lambda$为尺度比例因子设置为1$R$被称为罗德里格矩阵,定义反对称矩阵:
$$ $$
S = \begin{bmatrix} S = \begin{bmatrix}
0,& -c,& -b \\\ 0,& -c,& -b \\\
c,& 0,& -a \\\ c,& 0,& -a \\\
b,& a,& 0 b,& a,& 0
\end{bmatrix} \end{bmatrix}
$$ $$
则$R$可表示为$R = (I+S)(I-S)^{-1}$,展开后则有: 则$R$可表示为$R = (I+S)(I-S)^{-1}$,展开后则有:
$$ $$
R = \frac{1}{1+a^2+b^2+c^2}\begin{bmatrix} R = \frac{1}{1+a^2+b^2+c^2}\begin{bmatrix}
1 + a^2 - b^2 - c^2, -2c - 2ab, -2b + 2ac \\\ 1 + a^2 - b^2 - c^2, -2c - 2ab, -2b + 2ac \\\
2c - 2ab, 1 - a^2 + b^2 - c^2, -2a - 2bc \\\ 2c - 2ab, 1 - a^2 + b^2 - c^2, -2a - 2bc \\\
2b + 2ac, 2a - 2bc, 1 - a^2 - b^2 + c^2 2b + 2ac, 2a - 2bc, 1 - a^2 - b^2 + c^2
\end{bmatrix}\cdots(2) \end{bmatrix}\cdots(2)
$$ $$
将两个公共点代入$(1)$,相减则可消去平移项,可得到: 将两个公共点代入$(1)$,相减则可消去平移项,可得到:
$$ $$
\begin{bmatrix} \begin{bmatrix}
x_2-x_1\\\ y_2-y_1\\\ z_2-z_1 x_2-x_1\\\ y_2-y_1\\\ z_2-z_1
\end{bmatrix} = R \begin{bmatrix} \end{bmatrix} = R \begin{bmatrix}
u_2-u_1\\\ v_2-v_1\\\ w_2-w_1 u_2-u_1\\\ v_2-v_1\\\ w_2-w_1
\end{bmatrix} \end{bmatrix}
$$ $$
代入$(2)$则可得到($u_{21}=u_2-u_1$ 代入$(2)$则可得到($u_{21}=u_2-u_1$
$$ $$
\begin{bmatrix} \begin{bmatrix}
0,& w_{21}+z_{21},& v_{21}+y_{21} \\\ 0,& w_{21}+z_{21},& v_{21}+y_{21} \\\
w_{21}+z_{21},& 0,& -u_{21}-x_{21} \\\ w_{21}+z_{21},& 0,& -u_{21}-x_{21} \\\
-v_{21}-y_{21},& -u_{21}-x_{21},& 0 -v_{21}-y_{21},& -u_{21}-x_{21},& 0
\end{bmatrix}\begin{bmatrix} \end{bmatrix}\begin{bmatrix}
a\\\ b\\\ c a\\\ b\\\ c
\end{bmatrix} = \begin{bmatrix} \end{bmatrix} = \begin{bmatrix}
u_{21} - x_{21} \\\ u_{21} - x_{21} \\\
v_{21} - y_{21} \\\ v_{21} - y_{21} \\\
w_{21} - z_{21} w_{21} - z_{21}
\end{bmatrix} \end{bmatrix}
$$ $$
代入本题,则有: 代入本题,则有:
$$ $$
\begin{bmatrix} \begin{bmatrix}
0,& -\rho+z_0,& y_0 \\\ 0,& -\rho+z_0,& y_0 \\\
-\rho+z_0,& 0,& -x_0 \\\ -\rho+z_0,& 0,& -x_0 \\\
-y_0,& -x_0,& 0 -y_0,& -x_0,& 0
\end{bmatrix}\begin{bmatrix} \end{bmatrix}\begin{bmatrix}
a\\\ b\\\ c a\\\ b\\\ c
\end{bmatrix} = \begin{bmatrix} \end{bmatrix} = \begin{bmatrix}
-x_0 \\\ -x_0 \\\
-y_0 \\\ -y_0 \\\
-\rho-z_0 -\rho-z_0
\end{bmatrix} \end{bmatrix}
$$ $$
令$a=1$,则可求得: 令$a=1$,则可求得:
$$ $$
\begin{cases} \begin{cases}
b = \frac{z_0+\rho-y_0}{x_0} \\\ b = \frac{z_0+\rho-y_0}{x_0} \\\
c = \frac{z_0-\rho+y_0}{x_0} c = \frac{z_0-\rho+y_0}{x_0}
\end{cases} \end{cases}
$$ $$
计算得到$R$,继而根据$(1)$计算得到$\vec{d}$在`W`系中的表达式(最终无需平移,即不需要$+\begin{bmatrix}x_0\\\ y_0\\\ z_0\end{bmatrix}$)。 计算得到$R$,继而根据$(1)$计算得到$\vec{d}$在`W`系中的表达式(最终无需平移,即不需要$+\begin{bmatrix}x_0\\\ y_0\\\ z_0\end{bmatrix}$)。
3. 能量 3. 能量
* 俘获电子的函数较为简单,采用`ITM`;(下表中$j_0$已经归一化) * 俘获电子的函数较为简单,采用`ITM`;(下表中$j_0$已经归一化)
<div align=center> <div align=center>
| $F(E)$ | $\int F(E)\mathrm{d}E$ | $C(x)=\int_a^xF(u)\mathrm{d}u$ | $C^{-1}(y)$ | | $F(E)$ | $\int F(E)\mathrm{d}E$ | $C(x)=\int_a^xF(u)\mathrm{d}u$ | $C^{-1}(y)$ |
|:--------------------------:|:------------------------------------------:|:----------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------:| |:--------------------------:|:------------------------------------------:|:----------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------:|
| $j=j_0e^{-E/E_0}$ | $-j_0E_0e^{-E/E_0}$ | $j_0E_0e^{-a/E_0}-j_0E_0e^{-x/E_0}$ | $-E_0\ln(\frac{C-y}{j_0E_0}),\ C=j_0E_0e^{-a/E_0}$ | | $j=j_0e^{-E/E_0}$ | $-j_0E_0e^{-E/E_0}$ | $j_0E_0e^{-a/E_0}-j_0E_0e^{-x/E_0}$ | $-E_0\ln(\frac{C-y}{j_0E_0}),\ C=j_0E_0e^{-a/E_0}$ |
</div> </div>
<div align=center><img src="docs/simu-te.png" style="max-width: 50%;"></div> <div align=center><img src="docs/simu-te.png" style="max-width: 50%;"></div>
* 俘获质子的函数较为简单,采用`ITM`;(下表中$j_0$已经归一化) * 俘获质子的函数较为简单,采用`ITM`;(下表中$j_0$已经归一化)
<div align=center> <div align=center>
| $F(E)$ | $\int F(E)\mathrm{d}E$ | $C(x)=\int_a^xF(u)\mathrm{d}u$ | $C^{-1}(y)$ | | $F(E)$ | $\int F(E)\mathrm{d}E$ | $C(x)=\int_a^xF(u)\mathrm{d}u$ | $C^{-1}(y)$ |
|:--------------------------:|:------------------------------------------:|:----------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------:| |:--------------------------:|:------------------------------------------:|:----------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------:|
| $j=j_0(E-\beta)^{-\alpha}$ | $\frac{j_0(E-\beta)^{1-\alpha}}{1-\alpha}$ | $\frac{j_0}{1-\alpha}\left((x-\beta)^{1-\alpha}-(a-\beta)^{1-\alpha}\right)$ | $\sqrt[1-\alpha]{\frac{(y+C)(1-\alpha)}{j_0}}+\beta,\ C=\frac{j_0(a-\beta)^{1-\alpha}}{1-\alpha}$ | | $j=j_0(E-\beta)^{-\alpha}$ | $\frac{j_0(E-\beta)^{1-\alpha}}{1-\alpha}$ | $\frac{j_0}{1-\alpha}\left((x-\beta)^{1-\alpha}-(a-\beta)^{1-\alpha}\right)$ | $\sqrt[1-\alpha]{\frac{(y+C)(1-\alpha)}{j_0}}+\beta,\ C=\frac{j_0(a-\beta)^{1-\alpha}}{1-\alpha}$ |
</div> </div>
<div align=center><img src="docs/simu-tp.png" style="max-width: 50%;"></div> <div align=center><img src="docs/simu-tp.png" style="max-width: 50%;"></div>
* `GCR`质子的函数较为复杂,使用`ARM`生成`100000`个随机数需要`12`分钟,效率满足要求; * `GCR`质子的函数较为复杂,使用`ARM`生成`100000`个随机数需要`12`分钟,效率满足要求;
<div align=center><img src="docs/simu-gcrp.png" style="max-width: 50%;"></div> <div align=center><img src="docs/simu-gcrp.png" style="max-width: 50%;"></div>
* 其余`GCR`辐射粒子同样使用`ARM`,生成`100000`个随机数需要`4.5`分钟。 * 其余`GCR`辐射粒子同样使用`ARM`,生成`100000`个随机数需要`4.5`分钟。
<div align=center><img src="docs/simu-gcri.png" style="max-width: 50%;"></div> <div align=center><img src="docs/simu-gcri.png" style="max-width: 50%;"></div>
## 体模 ## 体模
使用`Geant4`示例中的`MIRD`人体模型,分为男、女两个性别, 使用`Geant4`示例中的`MIRD`人体模型,分为男、女两个性别,
<div align=center><img src="docs/MIRD.png" style="max-width: 60%;"></div> <div align=center><img src="docs/MIRD.png" style="max-width: 60%;"></div>
## 空间站建模 ## 空间站建模
1. 尺寸与分区[^7] 1. 尺寸与分区[^7]
<div align=center><img src="docs/size.webp" style="max-width: 50%;"></div> <div align=center><img src="docs/size.webp" style="max-width: 50%;"></div>
* 全长16.6 m * 全长16.6 m
* 总重22.5 t * 总重22.5 t
* 体积143.6 $\mathrm{m^3}$ * 体积143.6 $\mathrm{m^3}$
* 分区: * 分区:
* 大柱段 * 大柱段
* 外径4.2 m * 外径4.2 m
* 长度4.32 + 2.40 m (生活控制舱 + 资源舱)(直线过渡) * 长度4.32 + 2.40 m (生活控制舱 + 资源舱)(直线过渡)
* 过渡段0.815 m * 过渡段0.815 m
* 小柱端 * 小柱端
* 外径2.8 m * 外径2.8 m
* 长度5.18 m * 长度5.18 m
* 过渡段0.33 m * 过渡段0.33 m
* 节点舱:以直径 2.8 m 的球体近似 * 节点舱:以直径 2.8 m 的球体近似
2. 材料 2. 材料
* 外壳: 3层 2mm 铝 + 10mm 芳纶 + 5mm 铝 * 外壳: 3层 2mm 铝 + 10mm 芳纶 + 5mm 铝
<div align=center><img src="docs/Shell.png" style="max-width: 40%;"></div> <div align=center><img src="docs/Shell.png" style="max-width: 40%;"></div>
* 5系铝合金[^8] * 5系铝合金[^8]
* 泰普龙[^9] * 泰普龙[^9]
<div align=center><img src="docs/Taparan.png" style="max-width: 30%;"></div> <div align=center><img src="docs/Taparan.png" style="max-width: 30%;"></div>
* 填充:金属为主,使得总重大致相当 * 填充:金属为主,使得总重大致相当
* 内部:空气 * 内部:空气
* 玻璃:有机玻璃(`G4_PLEXIGLASS` * 玻璃:有机玻璃(`G4_PLEXIGLASS`
3. 特别区域 3. 特别区域
睡眠区无填充,仅考虑加厚外壳为 3层 5mm 铝 + 15mm 芳纶 + 10mm 铝 睡眠区无填充,仅考虑加厚外壳为 3层 5mm 铝 + 15mm 芳纶 + 10mm 铝
## 待改进 ## 待改进
* 建模 * 建模
* 体模 * 体模
* 空间站模型 * 空间站模型
* 材料 * 材料
* 大小 * 大小
* 辐射环境 * 辐射环境
* 太阳活动极大时 * 太阳活动极大时
* 太阳活动极小时 * 太阳活动极小时
* 更长的任务尺度 * 更长的任务尺度
* 各向异性的模拟(如俘获辐射带质子各向异性通量) * 各向异性的模拟(如俘获辐射带质子各向异性通量)
* 太阳质子的检验 * 太阳质子的检验
[^1]: [中国空间站轨道参数](http://www.cmse.gov.cn/gfgg/zgkjzgdcs/) [^1]: [中国空间站轨道参数](http://www.cmse.gov.cn/gfgg/zgkjzgdcs/)
[^2]: 程彭超,闵锐.近地空间辐射环境与防护方法概述[J].辐射防护通讯,2017,37(01):14-21. [^2]: 程彭超,闵锐.近地空间辐射环境与防护方法概述[J].辐射防护通讯,2017,37(01):14-21.
[^3]: Bourdarie S, Xapsos M. The near-earth space radiation environment[J]. IEEE transactions on nuclear science, 2008, 55(4): 1810-1832. [^3]: Bourdarie S, Xapsos M. The near-earth space radiation environment[J]. IEEE transactions on nuclear science, 2008, 55(4): 1810-1832.
[^4]: Matthiä D, Berger T, Mrigakshi A I, et al. A ready-to-use galactic cosmic ray model[J]. Advances in Space Research, 2013, 51(3): 329-338. [^4]: Matthiä D, Berger T, Mrigakshi A I, et al. A ready-to-use galactic cosmic ray model[J]. Advances in Space Research, 2013, 51(3): 329-338.
[^5]: Zhao H, Johnston W R, Baker D N, et al. Characterization and evolution of radiation belt electron energy spectra based on the Van Allen Probes measurements[J]. Journal of Geophysical Research: Space Physics, 2019, 124(6): 4217-4232. [^5]: Zhao H, Johnston W R, Baker D N, et al. Characterization and evolution of radiation belt electron energy spectra based on the Van Allen Probes measurements[J]. Journal of Geophysical Research: Space Physics, 2019, 124(6): 4217-4232.
[^6]: [三维坐标系之间转换方法](https://zhuanlan.zhihu.com/p/458827599) [^6]: [三维坐标系之间转换方法](https://zhuanlan.zhihu.com/p/458827599)
[^7]: [【知识点·航天】“天和”核心舱、“天宫”空间站和新一代载人飞船的最新知识点(干货版)](https://zhuanlan.zhihu.com/p/103709953) [^7]: [【知识点·航天】“天和”核心舱、“天宫”空间站和新一代载人飞船的最新知识点(干货版)](https://zhuanlan.zhihu.com/p/103709953)
[^8]: [中铝造为“天和”号核心舱披“铠甲”壮“筋骨”](https://m.thepaper.cn/baijiahao_12484370) [^8]: [中铝造为“天和”号核心舱披“铠甲”壮“筋骨”](https://m.thepaper.cn/baijiahao_12484370)
[^9]: [泰普龙产品相关知识](https://wenku.baidu.com/view/a2ecf93501d8ce2f0066f5335a8102d276a261cd.html) [^9]: [泰普龙产品相关知识](https://wenku.baidu.com/view/a2ecf93501d8ce2f0066f5335a8102d276a261cd.html)

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,2 +1,2 @@
1 48274U 21035A 22131.00000000 .00018566 00000-0 21317-3 0 9998 1 48274U 21035A 22131.00000000 .00018566 00000-0 21317-3 0 9998
2 48274 41.4696 84.9802 0011517 308.1456 44.4159 15.61130380 58963 2 48274 41.4696 84.9802 0011517 308.1456 44.4159 15.61130380 58963

View File

@ -1,30 +1,30 @@
TE, -1, 1, 1333680.43009, 0.0824, 32652.96179377461 TE, -1, 1, 1333680.43009, 0.0824, 32652.96179377461
TP, 1, 1, 559.76377, -1.53424, 2.40873, 1.5156509 TP, 1, 1, 559.76377, -1.53424, 2.40873, 1.5156509
GCR_H, 1, 1, 125.89223, 44.00673, -0.000460574, 112356, 361.781666 GCR_H, 1, 1, 125.89223, 44.00673, -0.000460574, 112356, 361.781666
GCR_He, 2, 4, 0.01815, 0.000297726, 0.00184, 0.49271, 48.4143048 GCR_He, 2, 4, 0.01815, 0.000297726, 0.00184, 0.49271, 48.4143048
GCR_Li, 3, 7, 0.000184794, 0.000389118, 0.0021, 0.49406, 0.3655716 GCR_Li, 3, 7, 0.000184794, 0.000389118, 0.0021, 0.49406, 0.3655716
GCR_Be, 4, 9, 0.0000953693, 0.000386546, 0.002, 0.48222, 0.1883217 GCR_Be, 4, 9, 0.0000953693, 0.000386546, 0.002, 0.48222, 0.1883217
GCR_B, 5, 10, 0.000245835, 0.000383147, 0.00182, 0.45495, 0.4814399 GCR_B, 5, 10, 0.000245835, 0.000383147, 0.00182, 0.45495, 0.4814399
GCR_C, 6, 12, 0.000551454, 0.000297607, 0.00184, 0.49310, 1.4715932 GCR_C, 6, 12, 0.000551454, 0.000297607, 0.00184, 0.49310, 1.4715932
GCR_N, 7, 14, 0.000177397, 0.000347376, 0.00161, 0.43464, 0.382109 GCR_N, 7, 14, 0.000177397, 0.000347376, 0.00161, 0.43464, 0.382109
GCR_O, 8, 16, 0.000515269, 0.000297659, 0.00184, 0.49294, 1.3747775 GCR_O, 8, 16, 0.000515269, 0.000297659, 0.00184, 0.49294, 1.3747775
GCR_F, 9, 19, 0.0000121025, 0.000307953, 0.00208, 0.53260, 0.0316204 GCR_F, 9, 19, 0.0000121025, 0.000307953, 0.00208, 0.53260, 0.0316204
GCR_Ne, 10, 20, 0.0000855093, 0.000299579, 0.00188, 0.50022, 0.2271729 GCR_Ne, 10, 20, 0.0000855093, 0.000299579, 0.00188, 0.50022, 0.2271729
GCR_Na, 11, 23, 0.0000200236, 0.000306074, 0.00204, 0.52582, 0.0525426 GCR_Na, 11, 23, 0.0000200236, 0.000306074, 0.00204, 0.52582, 0.0525426
GCR_Mg, 12, 24, 0.000107752, 0.000283677, 0.00197, 0.52149, 0.3078042 GCR_Mg, 12, 24, 0.000107752, 0.000283677, 0.00197, 0.52149, 0.3078042
GCR_Al, 13, 27, 0.0000207575, 0.000304806, 0.00201, 0.52089, 0.0546116 GCR_Al, 13, 27, 0.0000207575, 0.000304806, 0.00201, 0.52089, 0.0546116
GCR_Si, 14, 28, 0.0000809795, 0.000281074, 0.00191, 0.51232, 0.2327364 GCR_Si, 14, 28, 0.0000809795, 0.000281074, 0.00191, 0.51232, 0.2327364
GCR_P, 15, 31, 0.00000442291, 0.000303868, 0.00198, 0.51717, 0.0116488 GCR_P, 15, 31, 0.00000442291, 0.000303868, 0.00198, 0.51717, 0.0116488
GCR_S, 16, 32, 0.0000162654, 0.000281067, 0.00191, 0.51235, 0.0467482 GCR_S, 16, 32, 0.0000162654, 0.000281067, 0.00191, 0.51235, 0.0467482
GCR_Cl, 17, 36, 0.00000463438, 0.00033962, 0.00178, 0.46921, 0.0104706 GCR_Cl, 17, 36, 0.00000463438, 0.00033962, 0.00178, 0.46921, 0.0104706
GCR_Ar, 18, 40, 0.00000956898, 0.000351681, 0.00199, 0.49986, 0.0211592 GCR_Ar, 18, 40, 0.00000956898, 0.000351681, 0.00199, 0.49986, 0.0211592
GCR_K, 19, 39, 0.00000578307, 0.000336363, 0.00172, 0.45907, 0.0131355 GCR_K, 19, 39, 0.00000578307, 0.000336363, 0.00172, 0.45907, 0.0131355
GCR_Ca, 20, 40, 0.0000109853, 0.000266092, 0.00154, 0.42213, 0.0327014 GCR_Ca, 20, 40, 0.0000109853, 0.000266092, 0.00154, 0.42213, 0.0327014
GCR_Sc, 21, 45, 0.00000291072, 0.000344777, 0.00187, 0.48297, 0.006517 GCR_Sc, 21, 45, 0.00000291072, 0.000344777, 0.00187, 0.48297, 0.006517
GCR_Ti, 22, 48, 0.0000104814, 0.000348052, 0.00193, 0.49105, 0.0233399 GCR_Ti, 22, 48, 0.0000104814, 0.000348052, 0.00193, 0.49105, 0.0233399
GCR_V, 23, 51, 0.0000051388, 0.000351427, 0.00199, 0.49888, 0.0113753 GCR_V, 23, 51, 0.0000051388, 0.000351427, 0.00199, 0.49888, 0.0113753
GCR_Cr, 24, 52, 0.0000098941, 0.000346998, 0.00191, 0.48874, 0.022068 GCR_Cr, 24, 52, 0.0000098941, 0.000346998, 0.00191, 0.48874, 0.022068
GCR_Mn, 25, 55, 0.00000723814, 0.000349723, 0.00196, 0.49543, 0.0160699 GCR_Mn, 25, 55, 0.00000723814, 0.000349723, 0.00196, 0.49543, 0.0160699
GCR_Fe, 26, 56, 0.0000592702, 0.000279954, 0.00175, 0.45382, 0.1696584 GCR_Fe, 26, 56, 0.0000592702, 0.000279954, 0.00175, 0.45382, 0.1696584
GCR_Co, 27, 59, 0.00000020753, 0.000283367, 0.0018, 0.46005, 0.0005883 GCR_Co, 27, 59, 0.00000020753, 0.000283367, 0.0018, 0.46005, 0.0005883
GCR_Ni, 28, 58, 0.00000284117, 0.000275123, 0.00168, 0.44440, 0.0082463 GCR_Ni, 28, 58, 0.00000284117, 0.000275123, 0.00168, 0.44440, 0.0082463

File diff suppressed because it is too large Load Diff

View File

@ -1,4 +1,4 @@
0.1, 0.2, 0.4, 0.6, 0.8, 1, 2, 4, 6, 8, 10, 15, 20, 30, 50, 60, 80, 100, 150, 200, 300, 400, 700, 1200, 2000 0.1, 0.2, 0.4, 0.6, 0.8, 1, 2, 4, 6, 8, 10, 15, 20, 30, 50, 60, 80, 100, 150, 200, 300, 400, 700, 1200, 2000
170.46630985001116, 148.7169777853078, 116.02958215502514, 91.68016573576256, 75.4004563167008, 52.44979368353229, 27.39576993169936, 11.534263356467031, 4.927074386668564, 2.503935512743802, 1.2207035405229754, 0.6406616768835681, 0.32153683341049205, 0.18332837912910016, 0.11496359892828469, 0.08025880550325193, 0.05970056915795244, 0.0384373301355559, 0.022821770094163085, 0.011082462960424989, 0.0047728913059455905, 0.0007325376524683292, 5.947420364867388e-05, 1.918902440238389e-07, 0.0 170.46630985001116, 148.7169777853078, 116.02958215502514, 91.68016573576256, 75.4004563167008, 52.44979368353229, 27.39576993169936, 11.534263356467031, 4.927074386668564, 2.503935512743802, 1.2207035405229754, 0.6406616768835681, 0.32153683341049205, 0.18332837912910016, 0.11496359892828469, 0.08025880550325193, 0.05970056915795244, 0.0384373301355559, 0.022821770094163085, 0.011082462960424989, 0.0047728913059455905, 0.0007325376524683292, 5.947420364867388e-05, 1.918902440238389e-07, 0.0
0.04, 0.07, 0.1, 0.25, 0.5, 0.75, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7, 8.5, 10 0.04, 0.07, 0.1, 0.25, 0.5, 0.75, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7, 8.5, 10
781425.9929592956, 679139.2146049731, 322379.40275874606, 56156.789327450584, 6157.486909985416, 494.7242655747493, 77.04500465644205, 17.196451096282715, 5.771096902928527, 1.655431341146984, 0.5327835060623752, 0.17776818060047872, 0.05960754201838149, 0.02284581379206805, 0.008191147518478015, 0.0034509863771389026, 0.0010065728536974858, 0.00025474598119156806, 4.308092673195076e-06, 0.0, 0.0 781425.9929592956, 679139.2146049731, 322379.40275874606, 56156.789327450584, 6157.486909985416, 494.7242655747493, 77.04500465644205, 17.196451096282715, 5.771096902928527, 1.655431341146984, 0.5327835060623752, 0.17776818060047872, 0.05960754201838149, 0.02284581379206805, 0.008191147518478015, 0.0034509863771389026, 0.0010065728536974858, 0.00025474598119156806, 4.308092673195076e-06, 0.0, 0.0
1 0.1, 0.2, 0.4, 0.6, 0.8, 1, 2, 4, 6, 8, 10, 15, 20, 30, 50, 60, 80, 100, 150, 200, 300, 400, 700, 1200, 2000
2 170.46630985001116, 148.7169777853078, 116.02958215502514, 91.68016573576256, 75.4004563167008, 52.44979368353229, 27.39576993169936, 11.534263356467031, 4.927074386668564, 2.503935512743802, 1.2207035405229754, 0.6406616768835681, 0.32153683341049205, 0.18332837912910016, 0.11496359892828469, 0.08025880550325193, 0.05970056915795244, 0.0384373301355559, 0.022821770094163085, 0.011082462960424989, 0.0047728913059455905, 0.0007325376524683292, 5.947420364867388e-05, 1.918902440238389e-07, 0.0
3 0.04, 0.07, 0.1, 0.25, 0.5, 0.75, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7, 8.5, 10
4 781425.9929592956, 679139.2146049731, 322379.40275874606, 56156.789327450584, 6157.486909985416, 494.7242655747493, 77.04500465644205, 17.196451096282715, 5.771096902928527, 1.655431341146984, 0.5327835060623752, 0.17776818060047872, 0.05960754201838149, 0.02284581379206805, 0.008191147518478015, 0.0034509863771389026, 0.0010065728536974858, 0.00025474598119156806, 4.308092673195076e-06, 0.0, 0.0

View File

Binary file not shown.

Before

Width:  |  Height:  |  Size: 34 KiB

After

Width:  |  Height:  |  Size: 28 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 25 KiB

After

Width:  |  Height:  |  Size: 19 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 27 KiB

After

Width:  |  Height:  |  Size: 21 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 26 KiB

After

Width:  |  Height:  |  Size: 19 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 40 KiB

After

Width:  |  Height:  |  Size: 35 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 27 KiB

After

Width:  |  Height:  |  Size: 20 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 33 KiB

After

Width:  |  Height:  |  Size: 28 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 32 KiB

After

Width:  |  Height:  |  Size: 26 KiB

View File

@ -1,15 +1,15 @@
#ifndef DESCSS_ActionInitialization_h #ifndef DESCSS_ActionInitialization_h
#define DESCSS_ActionInitialization_h #define DESCSS_ActionInitialization_h
#include "G4VUserActionInitialization.hh" #include "G4VUserActionInitialization.hh"
class ActionInitialization : public G4VUserActionInitialization { class ActionInitialization : public G4VUserActionInitialization {
public: public:
ActionInitialization(); ActionInitialization();
~ActionInitialization() override; ~ActionInitialization() override;
void BuildForMaster() const override; void BuildForMaster() const override;
void Build() const; void Build() const;
}; };
#endif #endif

View File

@ -1,46 +1,46 @@
#ifndef DESCSS_DetectorConstruction_h #ifndef DESCSS_DetectorConstruction_h
#define DESCSS_DetectorConstruction_h #define DESCSS_DetectorConstruction_h
#include "G4VUserDetectorConstruction.hh" #include "G4VUserDetectorConstruction.hh"
#include "globals.hh" #include "globals.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4HumanPhantomMaterial; class G4HumanPhantomMaterial;
class G4HumanPhantomMessenger; class G4HumanPhantomMessenger;
class DetectorConstruction : public G4VUserDetectorConstruction { class DetectorConstruction : public G4VUserDetectorConstruction {
public: public:
DetectorConstruction(); DetectorConstruction();
~DetectorConstruction() override; ~DetectorConstruction() override;
G4VPhysicalVolume* Construct() override; G4VPhysicalVolume* Construct() override;
public: public:
void SetBodyPartSensitivity(G4String, G4bool); void SetBodyPartSensitivity(G4String, G4bool);
void SetPhantomSex(G4String); void SetPhantomSex(G4String);
void SetPhantomModel(G4String); void SetPhantomModel(G4String);
void SetParticleType(G4String s) { particleType = s; }; void SetParticleType(G4String s) { particleType = s; };
void ConstructSDandField(); void ConstructSDandField();
G4String GetParticleType() { return particleType; }; G4String GetParticleType() { return particleType; };
std::vector<G4String> GetSensitiveList() const { return sensitiveList; }; std::vector<G4String> GetSensitiveList() const { return sensitiveList; };
private: private:
void ConstructSectionSphere(G4LogicalVolume* fMotherLogical, G4double zBias); void ConstructSectionSphere(G4LogicalVolume* fMotherLogical, G4double zBias);
void ConstructSectionCons(G4String name, G4LogicalVolume* fMotherLogical, G4double zBias, G4double pRmax1, void ConstructSectionCons(G4String name, G4LogicalVolume* fMotherLogical, G4double zBias, G4double pRmax1,
G4double pRmin1, G4double pRmax2, G4double pRmin2, G4double hz); G4double pRmin1, G4double pRmax2, G4double pRmin2, G4double hz);
void ConstructSectionSmall(G4LogicalVolume* fMotherLogical, G4double zBias); void ConstructSectionSmall(G4LogicalVolume* fMotherLogical, G4double zBias);
void ConstructSectionBig(G4LogicalVolume* fMotherLogical, G4double zBias); void ConstructSectionBig(G4LogicalVolume* fMotherLogical, G4double zBias);
void ConstructHumanPhantom(G4VPhysicalVolume* fMotherPhysics); void ConstructHumanPhantom(G4VPhysicalVolume* fMotherPhysics);
private: private:
G4String sex = "Male"; G4String sex = "Male";
G4String model = "MIRD"; G4String model = "MIRD";
G4String particleType = "TE"; G4String particleType = "TE";
std::vector<G4String> sensitiveList; std::vector<G4String> sensitiveList;
std::map<std::string, G4bool> sensitivities; std::map<std::string, G4bool> sensitivities;
G4HumanPhantomMaterial* material; G4HumanPhantomMaterial* material;
G4HumanPhantomMessenger* messenger; G4HumanPhantomMessenger* messenger;
}; };
#endif #endif

View File

@ -1,22 +1,22 @@
#ifndef DESCSS_EventAction_h #ifndef DESCSS_EventAction_h
#define DESCSS_EventAction_h #define DESCSS_EventAction_h
#include "G4UserEventAction.hh" #include "G4UserEventAction.hh"
#include "globals.hh" #include "globals.hh"
class RunAction; class RunAction;
class EventAction : public G4UserEventAction { class EventAction : public G4UserEventAction {
public: public:
EventAction(RunAction* runAction); EventAction(RunAction* runAction);
~EventAction() override; ~EventAction() override;
void BeginOfEventAction(const G4Event*) override; void BeginOfEventAction(const G4Event*) override;
void EndOfEventAction(const G4Event*) override; void EndOfEventAction(const G4Event*) override;
private: private:
RunAction* fRunAction = nullptr; RunAction* fRunAction = nullptr;
std::map<G4String, G4double> fEdep; std::map<G4String, G4double> fEdep;
}; };
#endif #endif

View File

@ -1,66 +1,66 @@
#ifndef DESCSS_BasePhantomBuilder_h #ifndef DESCSS_BasePhantomBuilder_h
#define DESCSS_BasePhantomBuilder_h 1 #define DESCSS_BasePhantomBuilder_h 1
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4BasePhantomBuilder { class G4BasePhantomBuilder {
public: public:
G4BasePhantomBuilder(); G4BasePhantomBuilder();
virtual ~G4BasePhantomBuilder(); virtual ~G4BasePhantomBuilder();
virtual void BuildHead(const G4String&, G4bool, G4bool) { return; }; virtual void BuildHead(const G4String&, G4bool, G4bool) { return; };
virtual void BuildTrunk(const G4String&, G4bool, G4bool) { return; }; virtual void BuildTrunk(const G4String&, G4bool, G4bool) { return; };
virtual void BuildLeftLeg(const G4String&, G4bool, G4bool) { return; }; virtual void BuildLeftLeg(const G4String&, G4bool, G4bool) { return; };
virtual void BuildRightLeg(const G4String&, G4bool, G4bool) { return; }; virtual void BuildRightLeg(const G4String&, G4bool, G4bool) { return; };
virtual void BuildUpperSpine(const G4String&, G4bool, G4bool) { return; } virtual void BuildUpperSpine(const G4String&, G4bool, G4bool) { return; }
virtual void BuildMiddleLowerSpine(const G4String&, G4bool, G4bool) { return; }; virtual void BuildMiddleLowerSpine(const G4String&, G4bool, G4bool) { return; };
virtual void BuildLeftLegBone(const G4String&, G4bool, G4bool) { return; }; virtual void BuildLeftLegBone(const G4String&, G4bool, G4bool) { return; };
virtual void BuildRightLegBone(const G4String&, G4bool, G4bool) { return; }; virtual void BuildRightLegBone(const G4String&, G4bool, G4bool) { return; };
virtual void BuildLeftArmBone(const G4String&, G4bool, G4bool) { return; } virtual void BuildLeftArmBone(const G4String&, G4bool, G4bool) { return; }
virtual void BuildRightArmBone(const G4String&, G4bool, G4bool) { return; } virtual void BuildRightArmBone(const G4String&, G4bool, G4bool) { return; }
virtual void BuildSkull(const G4String&, G4bool, G4bool) { return; }; virtual void BuildSkull(const G4String&, G4bool, G4bool) { return; };
virtual void BuildRibCage(const G4String&, G4bool, G4bool) { return; }; virtual void BuildRibCage(const G4String&, G4bool, G4bool) { return; };
virtual void BuildPelvis(const G4String&, G4bool, G4bool) { return; }; virtual void BuildPelvis(const G4String&, G4bool, G4bool) { return; };
virtual void BuildLeftScapula(const G4String&, G4bool, G4bool) { return; }; virtual void BuildLeftScapula(const G4String&, G4bool, G4bool) { return; };
virtual void BuildRightScapula(const G4String&, G4bool, G4bool) { return; }; virtual void BuildRightScapula(const G4String&, G4bool, G4bool) { return; };
virtual void BuildLeftClavicle(const G4String&, G4bool, G4bool) { return; }; virtual void BuildLeftClavicle(const G4String&, G4bool, G4bool) { return; };
virtual void BuildRightClavicle(const G4String&, G4bool, G4bool) { return; }; virtual void BuildRightClavicle(const G4String&, G4bool, G4bool) { return; };
virtual void BuildBrain(const G4String&, G4bool, G4bool) { return; }; virtual void BuildBrain(const G4String&, G4bool, G4bool) { return; };
virtual void BuildHeart(const G4String&, G4bool, G4bool) { return; }; virtual void BuildHeart(const G4String&, G4bool, G4bool) { return; };
virtual void BuildLeftLung(const G4String&, G4bool, G4bool) { return; }; virtual void BuildLeftLung(const G4String&, G4bool, G4bool) { return; };
virtual void BuildRightLung(const G4String&, G4bool, G4bool) { return; }; virtual void BuildRightLung(const G4String&, G4bool, G4bool) { return; };
virtual void BuildStomach(const G4String&, G4bool, G4bool) { return; }; virtual void BuildStomach(const G4String&, G4bool, G4bool) { return; };
virtual void BuildSmallIntestine(const G4String&, G4bool, G4bool) { return; }; virtual void BuildSmallIntestine(const G4String&, G4bool, G4bool) { return; };
virtual void BuildUpperLargeIntestine(const G4String&, G4bool, G4bool) { return; }; virtual void BuildUpperLargeIntestine(const G4String&, G4bool, G4bool) { return; };
virtual void BuildLowerLargeIntestine(const G4String&, G4bool, G4bool) { return; }; virtual void BuildLowerLargeIntestine(const G4String&, G4bool, G4bool) { return; };
virtual void BuildLeftKidney(const G4String&, G4bool, G4bool) { return; }; virtual void BuildLeftKidney(const G4String&, G4bool, G4bool) { return; };
virtual void BuildRightKidney(const G4String&, G4bool, G4bool) { return; }; virtual void BuildRightKidney(const G4String&, G4bool, G4bool) { return; };
virtual void BuildLeftAdrenal(const G4String&, G4bool, G4bool) { return; }; virtual void BuildLeftAdrenal(const G4String&, G4bool, G4bool) { return; };
virtual void BuildRightAdrenal(const G4String&, G4bool, G4bool) { return; }; virtual void BuildRightAdrenal(const G4String&, G4bool, G4bool) { return; };
virtual void BuildLiver(const G4String&, G4bool, G4bool) { return; }; virtual void BuildLiver(const G4String&, G4bool, G4bool) { return; };
virtual void BuildPancreas(const G4String&, G4bool, G4bool) { return; }; virtual void BuildPancreas(const G4String&, G4bool, G4bool) { return; };
virtual void BuildSpleen(const G4String&, G4bool, G4bool) { return; }; virtual void BuildSpleen(const G4String&, G4bool, G4bool) { return; };
virtual void BuildUrinaryBladder(const G4String&, G4bool, G4bool) { return; }; virtual void BuildUrinaryBladder(const G4String&, G4bool, G4bool) { return; };
virtual void BuildThyroid(const G4String&, G4bool, G4bool) { return; }; virtual void BuildThyroid(const G4String&, G4bool, G4bool) { return; };
virtual void BuildThymus(const G4String&, G4bool, G4bool) { return; }; virtual void BuildThymus(const G4String&, G4bool, G4bool) { return; };
virtual void BuildLeftOvary(const G4String&, G4bool, G4bool) { return; }; virtual void BuildLeftOvary(const G4String&, G4bool, G4bool) { return; };
virtual void BuildRightOvary(const G4String&, G4bool, G4bool) { return; }; virtual void BuildRightOvary(const G4String&, G4bool, G4bool) { return; };
virtual void BuildUterus(const G4String&, G4bool, G4bool) { return; }; virtual void BuildUterus(const G4String&, G4bool, G4bool) { return; };
virtual void BuildLeftBreast(const G4String&, G4bool, G4bool) { return; }; virtual void BuildLeftBreast(const G4String&, G4bool, G4bool) { return; };
virtual void BuildRightBreast(const G4String&, G4bool, G4bool) { return; }; virtual void BuildRightBreast(const G4String&, G4bool, G4bool) { return; };
virtual void BuildVoxelLeftBreast(const G4String&, G4bool, G4bool) { return; }; virtual void BuildVoxelLeftBreast(const G4String&, G4bool, G4bool) { return; };
virtual void BuildVoxelRightBreast(const G4String&, G4bool, G4bool) { return; }; virtual void BuildVoxelRightBreast(const G4String&, G4bool, G4bool) { return; };
virtual void BuildMaleGenitalia(const G4String&, G4bool, G4bool) { return; }; virtual void BuildMaleGenitalia(const G4String&, G4bool, G4bool) { return; };
virtual void BuildLeftTeste(const G4String&, G4bool, G4bool) { return; }; virtual void BuildLeftTeste(const G4String&, G4bool, G4bool) { return; };
virtual void BuildRightTeste(const G4String&, G4bool, G4bool) { return; }; virtual void BuildRightTeste(const G4String&, G4bool, G4bool) { return; };
virtual void SetModel(G4String) { return; }; virtual void SetModel(G4String) { return; };
virtual void SetMotherVolume(G4VPhysicalVolume*) { return; }; virtual void SetMotherVolume(G4VPhysicalVolume*) { return; };
virtual G4VPhysicalVolume* GetPhantom() { return 0; }; virtual G4VPhysicalVolume* GetPhantom() { return 0; };
}; };
#endif #endif

View File

@ -1,17 +1,17 @@
#ifndef DESCSS_FemaleBuilder_h #ifndef DESCSS_FemaleBuilder_h
#define DESCSS_FemaleBuilder_h 1 #define DESCSS_FemaleBuilder_h 1
#include "G4PhantomBuilder.h" #include "G4PhantomBuilder.h"
class G4FemaleBuilder : public G4PhantomBuilder { class G4FemaleBuilder : public G4PhantomBuilder {
public: public:
G4FemaleBuilder(); G4FemaleBuilder();
~G4FemaleBuilder(); ~G4FemaleBuilder();
void BuildLeftBreast(const G4String&, G4bool, G4bool); void BuildLeftBreast(const G4String&, G4bool, G4bool);
void BuildRightBreast(const G4String&, G4bool, G4bool); void BuildRightBreast(const G4String&, G4bool, G4bool);
void BuildLeftOvary(const G4String&, G4bool, G4bool); void BuildLeftOvary(const G4String&, G4bool, G4bool);
void BuildRightOvary(const G4String&, G4bool, G4bool); void BuildRightOvary(const G4String&, G4bool, G4bool);
void BuildUterus(const G4String&, G4bool, G4bool); void BuildUterus(const G4String&, G4bool, G4bool);
}; };
#endif #endif

View File

@ -1,31 +1,31 @@
#ifndef DESCSS_HumanPhantomColour_H #ifndef DESCSS_HumanPhantomColour_H
#define DESCSS_HumanPhantomColour_H 1 #define DESCSS_HumanPhantomColour_H 1
#include "G4Colour.hh" #include "G4Colour.hh"
#include "globals.hh" #include "globals.hh"
class G4Colour; class G4Colour;
class G4HumanPhantomColour { class G4HumanPhantomColour {
public: public:
G4HumanPhantomColour(); G4HumanPhantomColour();
~G4HumanPhantomColour(); ~G4HumanPhantomColour();
public: public:
// void DefineColour(); // void DefineColour();
G4Colour GetColour(const G4String&); // returns the colour G4Colour GetColour(const G4String&); // returns the colour
private: private:
G4Colour white; G4Colour white;
G4Colour pink; G4Colour pink;
G4Colour grey; G4Colour grey;
G4Colour yellow; G4Colour yellow;
G4Colour blue; G4Colour blue;
G4Colour lightBlue; G4Colour lightBlue;
G4Colour green; G4Colour green;
G4Colour brown; G4Colour brown;
G4Colour purple; G4Colour purple;
G4Colour red; G4Colour red;
G4Colour orange; G4Colour orange;
G4Colour black; G4Colour black;
}; };
#endif #endif

View File

@ -1,49 +1,49 @@
#ifndef DESCSS_HumanPhantomHit_h #ifndef DESCSS_HumanPhantomHit_h
#define DESCSS_HumanPhantomHit_h 1 #define DESCSS_HumanPhantomHit_h 1
#include "G4Allocator.hh" #include "G4Allocator.hh"
#include "G4THitsCollection.hh" #include "G4THitsCollection.hh"
#include "G4ThreeVector.hh" #include "G4ThreeVector.hh"
#include "G4VHit.hh" #include "G4VHit.hh"
#include "tls.hh" // FOR MT #include "tls.hh" // FOR MT
class G4HumanPhantomHit : public G4VHit { class G4HumanPhantomHit : public G4VHit {
public: public:
G4HumanPhantomHit(); G4HumanPhantomHit();
~G4HumanPhantomHit(); ~G4HumanPhantomHit();
G4HumanPhantomHit(const G4HumanPhantomHit&); G4HumanPhantomHit(const G4HumanPhantomHit&);
const G4HumanPhantomHit& operator=(const G4HumanPhantomHit&); const G4HumanPhantomHit& operator=(const G4HumanPhantomHit&);
G4bool operator==(const G4HumanPhantomHit&) const; G4bool operator==(const G4HumanPhantomHit&) const;
inline void* operator new(size_t); inline void* operator new(size_t);
inline void operator delete(void*); inline void operator delete(void*);
void Draw(); void Draw();
void Print(); void Print();
public: public:
void SetBodyPartID(G4String bodyPartName) { bodyPartID = bodyPartName; }; void SetBodyPartID(G4String bodyPartName) { bodyPartID = bodyPartName; };
void SetEdep(G4double de) { edep = de; }; void SetEdep(G4double de) { edep = de; };
G4String GetBodyPartID() { return bodyPartID; }; G4String GetBodyPartID() { return bodyPartID; };
G4double GetEdep() { return edep; }; G4double GetEdep() { return edep; };
private: private:
G4String bodyPartID; G4String bodyPartID;
G4double edep; G4double edep;
}; };
typedef G4THitsCollection<G4HumanPhantomHit> G4HumanPhantomHitsCollection; typedef G4THitsCollection<G4HumanPhantomHit> G4HumanPhantomHitsCollection;
extern G4ThreadLocal G4Allocator<G4HumanPhantomHit>* G4HumanPhantomHitAllocator; extern G4ThreadLocal G4Allocator<G4HumanPhantomHit>* G4HumanPhantomHitAllocator;
inline void* G4HumanPhantomHit::operator new(size_t) { inline void* G4HumanPhantomHit::operator new(size_t) {
if (!G4HumanPhantomHitAllocator) G4HumanPhantomHitAllocator = new G4Allocator<G4HumanPhantomHit>; if (!G4HumanPhantomHitAllocator) G4HumanPhantomHitAllocator = new G4Allocator<G4HumanPhantomHit>;
return (void*)G4HumanPhantomHitAllocator->MallocSingle(); return (void*)G4HumanPhantomHitAllocator->MallocSingle();
} }
inline void G4HumanPhantomHit::operator delete(void* aHit) { inline void G4HumanPhantomHit::operator delete(void* aHit) {
G4HumanPhantomHitAllocator->FreeSingle((G4HumanPhantomHit*)aHit); G4HumanPhantomHitAllocator->FreeSingle((G4HumanPhantomHit*)aHit);
} }
#endif #endif

View File

@ -1,26 +1,26 @@
#ifndef DESCSS_HumanPhantomMaterial_H #ifndef DESCSS_HumanPhantomMaterial_H
#define DESCSS_HumanPhantomMaterial_H 1 #define DESCSS_HumanPhantomMaterial_H 1
#include "globals.hh" #include "globals.hh"
class G4Material; class G4Material;
class G4HumanPhantomMaterial { class G4HumanPhantomMaterial {
public: public:
G4HumanPhantomMaterial(); G4HumanPhantomMaterial();
~G4HumanPhantomMaterial(); ~G4HumanPhantomMaterial();
public: public:
void DefineMaterials(); void DefineMaterials();
G4Material* GetMaterial(G4String); // returns the material G4Material* GetMaterial(G4String); // returns the material
private: private:
G4Material* matH2O; G4Material* matH2O;
G4Material* soft; G4Material* soft;
G4Material* skeleton; G4Material* skeleton;
G4Material* lung; G4Material* lung;
G4Material* adipose; G4Material* adipose;
G4Material* glandular; G4Material* glandular;
G4Material* adipose_glandular; G4Material* adipose_glandular;
G4Material* muscle; G4Material* muscle;
}; };
#endif #endif

View File

@ -1,35 +1,35 @@
#ifndef DESCSS_HumanPhantomMessenger_h #ifndef DESCSS_HumanPhantomMessenger_h
#define DESCSS_HumanPhantomMessenger_h 1 #define DESCSS_HumanPhantomMessenger_h 1
class DetectorConstruction; class DetectorConstruction;
class G4UIcommand; class G4UIcommand;
class G4UIdirectory; class G4UIdirectory;
class G4UIcmdWithAString; class G4UIcmdWithAString;
class G4UIcmdWithoutParameter; class G4UIcmdWithoutParameter;
#include "G4UImessenger.hh" #include "G4UImessenger.hh"
#include "globals.hh" #include "globals.hh"
#include <iostream> #include <iostream>
class G4HumanPhantomMessenger : public G4UImessenger { class G4HumanPhantomMessenger : public G4UImessenger {
public: public:
G4HumanPhantomMessenger(DetectorConstruction* myUsrPhtm); G4HumanPhantomMessenger(DetectorConstruction* myUsrPhtm);
~G4HumanPhantomMessenger(); ~G4HumanPhantomMessenger();
void SetNewValue(G4UIcommand* command, G4String newValue); void SetNewValue(G4UIcommand* command, G4String newValue);
private: private:
DetectorConstruction* myUserPhantom; DetectorConstruction* myUserPhantom;
G4UIdirectory* phantomDir; G4UIdirectory* phantomDir;
G4UIdirectory* particleTypeDir; G4UIdirectory* particleTypeDir;
G4UIcmdWithAString* modelCmd; G4UIcmdWithAString* modelCmd;
G4UIcmdWithAString* sexCmd; G4UIcmdWithAString* sexCmd;
G4UIcmdWithoutParameter* endCmd; G4UIcmdWithoutParameter* endCmd;
G4UIcmdWithAString* typeCmd; G4UIcmdWithAString* typeCmd;
}; };
#endif #endif

View File

@ -1,22 +1,22 @@
#ifndef DESCSS_HumanPhantomSD_h #ifndef DESCSS_HumanPhantomSD_h
#define DESCSS_HumanPhantomSD_h 1 #define DESCSS_HumanPhantomSD_h 1
#include "G4HumanPhantomHit.h" #include "G4HumanPhantomHit.h"
#include "G4VSensitiveDetector.hh" #include "G4VSensitiveDetector.hh"
class G4Step; class G4Step;
class G4HumanPhantomSD : public G4VSensitiveDetector { class G4HumanPhantomSD : public G4VSensitiveDetector {
public: public:
G4HumanPhantomSD(const G4String& name, const G4String& hitsCollectionName); G4HumanPhantomSD(const G4String& name, const G4String& hitsCollectionName);
~G4HumanPhantomSD(); ~G4HumanPhantomSD();
void Initialize(G4HCofThisEvent*); void Initialize(G4HCofThisEvent*);
G4bool ProcessHits(G4Step*, G4TouchableHistory*); G4bool ProcessHits(G4Step*, G4TouchableHistory*);
void EndOfEvent(G4HCofThisEvent*); void EndOfEvent(G4HCofThisEvent*);
private: private:
G4HumanPhantomHitsCollection* collection; G4HumanPhantomHitsCollection* collection;
}; };
#endif #endif

View File

@ -1,22 +1,22 @@
#ifndef DESCSS_MIRDBodyFactory_h #ifndef DESCSS_MIRDBodyFactory_h
#define DESCSS_MIRDBodyFactory_h 1 #define DESCSS_MIRDBodyFactory_h 1
#include "G4VBodyFactory.h" #include "G4VBodyFactory.h"
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include <map> #include <map>
class G4VBodyFactory; class G4VBodyFactory;
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4VOrgan; class G4VOrgan;
class G4MIRDBodyFactory : public G4VBodyFactory { class G4MIRDBodyFactory : public G4VBodyFactory {
public: public:
G4MIRDBodyFactory(); G4MIRDBodyFactory();
~G4MIRDBodyFactory(); ~G4MIRDBodyFactory();
G4VPhysicalVolume* CreateOrgan(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* CreateOrgan(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
std::map<std::string, G4VOrgan*> organ; std::map<std::string, G4VOrgan*> organ;
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDBrain_h #ifndef DESCSS_MIRDBrain_h
#define DESCSS_MIRDBrain_h 1 #define DESCSS_MIRDBrain_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDBrain : public G4VOrgan { class G4MIRDBrain : public G4VOrgan {
public: public:
G4MIRDBrain(); G4MIRDBrain();
~G4MIRDBrain(); ~G4MIRDBrain();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDHead_h #ifndef DESCSS_MIRDHead_h
#define DESCSS_MIRDHead_h 1 #define DESCSS_MIRDHead_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class MarsMaterial; class MarsMaterial;
class G4MIRDHead : public G4VOrgan { class G4MIRDHead : public G4VOrgan {
public: public:
G4MIRDHead(); G4MIRDHead();
~G4MIRDHead(); ~G4MIRDHead();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDHeart_h #ifndef DESCSS_MIRDHeart_h
#define DESCSS_MIRDHeart_h 1 #define DESCSS_MIRDHeart_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class MarsMaterial; class MarsMaterial;
class G4MIRDHeart : public G4VOrgan { class G4MIRDHeart : public G4VOrgan {
public: public:
G4MIRDHeart(); G4MIRDHeart();
~G4MIRDHeart(); ~G4MIRDHeart();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDLeftAdrenal_h #ifndef DESCSS_MIRDLeftAdrenal_h
#define DESCSS_MIRDLeftAdrenal_h 1 #define DESCSS_MIRDLeftAdrenal_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDLeftAdrenal : public G4VOrgan { class G4MIRDLeftAdrenal : public G4VOrgan {
public: public:
G4MIRDLeftAdrenal(); G4MIRDLeftAdrenal();
~G4MIRDLeftAdrenal(); ~G4MIRDLeftAdrenal();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,22 +1,22 @@
#ifndef DESCSS_MIRDLeftArmBone_h #ifndef DESCSS_MIRDLeftArmBone_h
#define DESCSS_MIRDLeftArmBone_h 1 #define DESCSS_MIRDLeftArmBone_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDLeftArmBone : public G4VOrgan { class G4MIRDLeftArmBone : public G4VOrgan {
public: public:
G4MIRDLeftArmBone(); G4MIRDLeftArmBone();
~G4MIRDLeftArmBone(); ~G4MIRDLeftArmBone();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
// SAXProcessor sxp; // SAXProcessor sxp;
// ProcessingConfigurator config; // ProcessingConfigurator config;
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDLeftBreast_h #ifndef DESCSS_MIRDLeftBreast_h
#define DESCSS_MIRDLeftBreast_h 1 #define DESCSS_MIRDLeftBreast_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDLeftBreast : public G4VOrgan { class G4MIRDLeftBreast : public G4VOrgan {
public: public:
G4MIRDLeftBreast(); G4MIRDLeftBreast();
~G4MIRDLeftBreast(); ~G4MIRDLeftBreast();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDLeftClavicle_h #ifndef DESCSS_MIRDLeftClavicle_h
#define DESCSS_MIRDLeftClavicle_h 1 #define DESCSS_MIRDLeftClavicle_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDLeftClavicle : public G4VOrgan { class G4MIRDLeftClavicle : public G4VOrgan {
public: public:
G4MIRDLeftClavicle(); G4MIRDLeftClavicle();
~G4MIRDLeftClavicle(); ~G4MIRDLeftClavicle();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,17 +1,17 @@
#ifndef DESCSS_MIRDLeftKidney_h #ifndef DESCSS_MIRDLeftKidney_h
#define DESCSS_MIRDLeftKidney_h 1 #define DESCSS_MIRDLeftKidney_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDLeftKidney : public G4VOrgan { class G4MIRDLeftKidney : public G4VOrgan {
public: public:
G4MIRDLeftKidney(); G4MIRDLeftKidney();
~G4MIRDLeftKidney(); ~G4MIRDLeftKidney();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDLeftLeg_h #ifndef DESCSS_MIRDLeftLeg_h
#define DESCSS_MIRDLeftLeg_h 1 #define DESCSS_MIRDLeftLeg_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDLeftLeg : public G4VOrgan { class G4MIRDLeftLeg : public G4VOrgan {
public: public:
G4MIRDLeftLeg(); G4MIRDLeftLeg();
~G4MIRDLeftLeg(); ~G4MIRDLeftLeg();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDLeftLegBone_h #ifndef DESCSS_MIRDLeftLegBone_h
#define DESCSS_MIRDLeftLegBone_h 1 #define DESCSS_MIRDLeftLegBone_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDLeftLegBone : public G4VOrgan { class G4MIRDLeftLegBone : public G4VOrgan {
public: public:
G4MIRDLeftLegBone(); G4MIRDLeftLegBone();
~G4MIRDLeftLegBone(); ~G4MIRDLeftLegBone();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDLeftLung_h #ifndef DESCSS_MIRDLeftLung_h
#define DESCSS_MIRDLeftLung_h 1 #define DESCSS_MIRDLeftLung_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDLeftLung : public G4VOrgan { class G4MIRDLeftLung : public G4VOrgan {
public: public:
G4MIRDLeftLung(); G4MIRDLeftLung();
~G4MIRDLeftLung(); ~G4MIRDLeftLung();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDLeftOvary_h #ifndef DESCSS_MIRDLeftOvary_h
#define DESCSS_MIRDLeftOvary_h 1 #define DESCSS_MIRDLeftOvary_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4MIRDLeftOvary : public G4VOrgan { class G4MIRDLeftOvary : public G4VOrgan {
public: public:
G4MIRDLeftOvary(); G4MIRDLeftOvary();
~G4MIRDLeftOvary(); ~G4MIRDLeftOvary();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDLeftScapula_h #ifndef DESCSS_MIRDLeftScapula_h
#define DESCSS_MIRDLeftScapula_h 1 #define DESCSS_MIRDLeftScapula_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDLeftScapula : public G4VOrgan { class G4MIRDLeftScapula : public G4VOrgan {
public: public:
G4MIRDLeftScapula(); G4MIRDLeftScapula();
~G4MIRDLeftScapula(); ~G4MIRDLeftScapula();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDLeftTeste_h #ifndef DESCSS_MIRDLeftTeste_h
#define DESCSS_MIRDLeftTeste_h 1 #define DESCSS_MIRDLeftTeste_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4MIRDLeftTeste : public G4VOrgan { class G4MIRDLeftTeste : public G4VOrgan {
public: public:
G4MIRDLeftTeste(); G4MIRDLeftTeste();
~G4MIRDLeftTeste(); ~G4MIRDLeftTeste();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,17 +1,17 @@
#ifndef DESCSS_MIRDLiver_h #ifndef DESCSS_MIRDLiver_h
#define DESCSS_MIRDLiver_h 1 #define DESCSS_MIRDLiver_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4MIRDLiver : public G4VOrgan { class G4MIRDLiver : public G4VOrgan {
public: public:
G4MIRDLiver(); G4MIRDLiver();
~G4MIRDLiver(); ~G4MIRDLiver();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDLowerLargeIntestine_h #ifndef DESCSS_MIRDLowerLargeIntestine_h
#define DESCSS_MIRDLowerLargeIntestine_h 1 #define DESCSS_MIRDLowerLargeIntestine_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDLowerLargeIntestine : public G4VOrgan { class G4MIRDLowerLargeIntestine : public G4VOrgan {
public: public:
G4MIRDLowerLargeIntestine(); G4MIRDLowerLargeIntestine();
~G4MIRDLowerLargeIntestine(); ~G4MIRDLowerLargeIntestine();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDMaleGenitalia_h #ifndef DESCSS_MIRDMaleGenitalia_h
#define DESCSS_MIRDMaleGenitalia_h 1 #define DESCSS_MIRDMaleGenitalia_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4MIRDMaleGenitalia : public G4VOrgan { class G4MIRDMaleGenitalia : public G4VOrgan {
public: public:
G4MIRDMaleGenitalia(); G4MIRDMaleGenitalia();
~G4MIRDMaleGenitalia(); ~G4MIRDMaleGenitalia();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDMiddleLowerSpine_h #ifndef DESCSS_MIRDMiddleLowerSpine_h
#define DESCSS_MIRDMiddleLowerSpine_h 1 #define DESCSS_MIRDMiddleLowerSpine_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDMiddleLowerSpine : public G4VOrgan { class G4MIRDMiddleLowerSpine : public G4VOrgan {
public: public:
G4MIRDMiddleLowerSpine(); G4MIRDMiddleLowerSpine();
~G4MIRDMiddleLowerSpine(); ~G4MIRDMiddleLowerSpine();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDPancreas_h #ifndef DESCSS_MIRDPancreas_h
#define DESCSS_MIRDPancreas_h 1 #define DESCSS_MIRDPancreas_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDPancreas : public G4VOrgan { class G4MIRDPancreas : public G4VOrgan {
public: public:
G4MIRDPancreas(); G4MIRDPancreas();
~G4MIRDPancreas(); ~G4MIRDPancreas();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDPelvis_h #ifndef DESCSS_MIRDPelvis_h
#define DESCSS_MIRDPelvis_h 1 #define DESCSS_MIRDPelvis_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDPelvis : public G4VOrgan { class G4MIRDPelvis : public G4VOrgan {
public: public:
G4MIRDPelvis(); G4MIRDPelvis();
~G4MIRDPelvis(); ~G4MIRDPelvis();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,31 +1,31 @@
#ifndef DESCSS_MIRDRibCage_h #ifndef DESCSS_MIRDRibCage_h
#define DESCSS_MIRDRibCage_h 1 #define DESCSS_MIRDRibCage_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDRibCage : public G4VOrgan { class G4MIRDRibCage : public G4VOrgan {
public: public:
G4MIRDRibCage(); G4MIRDRibCage();
~G4MIRDRibCage(); ~G4MIRDRibCage();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
G4VPhysicalVolume* physRib1; G4VPhysicalVolume* physRib1;
G4VPhysicalVolume* physRib2; G4VPhysicalVolume* physRib2;
G4VPhysicalVolume* physRib3; G4VPhysicalVolume* physRib3;
G4VPhysicalVolume* physRib4; G4VPhysicalVolume* physRib4;
G4VPhysicalVolume* physRib5; G4VPhysicalVolume* physRib5;
G4VPhysicalVolume* physRib6; G4VPhysicalVolume* physRib6;
G4VPhysicalVolume* physRib7; G4VPhysicalVolume* physRib7;
G4VPhysicalVolume* physRib8; G4VPhysicalVolume* physRib8;
G4VPhysicalVolume* physRib9; G4VPhysicalVolume* physRib9;
G4VPhysicalVolume* physRib10; G4VPhysicalVolume* physRib10;
G4VPhysicalVolume* physRib11; G4VPhysicalVolume* physRib11;
G4VPhysicalVolume* physRib12; G4VPhysicalVolume* physRib12;
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDRightAdrenal_h #ifndef DESCSS_MIRDRightAdrenal_h
#define DESCSS_MIRDRightAdrenal_h 1 #define DESCSS_MIRDRightAdrenal_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDRightAdrenal : public G4VOrgan { class G4MIRDRightAdrenal : public G4VOrgan {
public: public:
G4MIRDRightAdrenal(); G4MIRDRightAdrenal();
~G4MIRDRightAdrenal(); ~G4MIRDRightAdrenal();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,21 +1,21 @@
#ifndef DESCSS_MIRDRightArmBone_h #ifndef DESCSS_MIRDRightArmBone_h
#define DESCSS_MIRDRightArmBone_h 1 #define DESCSS_MIRDRightArmBone_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDRightArmBone : public G4VOrgan { class G4MIRDRightArmBone : public G4VOrgan {
public: public:
G4MIRDRightArmBone(); G4MIRDRightArmBone();
~G4MIRDRightArmBone(); ~G4MIRDRightArmBone();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
// SAXProcessor sxp; // SAXProcessor sxp;
// ProcessingConfigurator config; // ProcessingConfigurator config;
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDRightBreast_h #ifndef DESCSS_MIRDRightBreast_h
#define DESCSS_MIRDRightBreast_h 1 #define DESCSS_MIRDRightBreast_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDRightBreast : public G4VOrgan { class G4MIRDRightBreast : public G4VOrgan {
public: public:
G4MIRDRightBreast(); G4MIRDRightBreast();
~G4MIRDRightBreast(); ~G4MIRDRightBreast();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDRightClavicle_h #ifndef DESCSS_MIRDRightClavicle_h
#define DESCSS_MIRDRightClavicle_h 1 #define DESCSS_MIRDRightClavicle_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDRightClavicle : public G4VOrgan { class G4MIRDRightClavicle : public G4VOrgan {
public: public:
G4MIRDRightClavicle(); G4MIRDRightClavicle();
~G4MIRDRightClavicle(); ~G4MIRDRightClavicle();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDRightKidney_h #ifndef DESCSS_MIRDRightKidney_h
#define DESCSS_MIRDRightKidney_h 1 #define DESCSS_MIRDRightKidney_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDRightKidney : public G4VOrgan { class G4MIRDRightKidney : public G4VOrgan {
public: public:
G4MIRDRightKidney(); G4MIRDRightKidney();
~G4MIRDRightKidney(); ~G4MIRDRightKidney();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDRightLeg_h #ifndef DESCSS_MIRDRightLeg_h
#define DESCSS_MIRDRightLeg_h 1 #define DESCSS_MIRDRightLeg_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDRightLeg : public G4VOrgan { class G4MIRDRightLeg : public G4VOrgan {
public: public:
G4MIRDRightLeg(); G4MIRDRightLeg();
~G4MIRDRightLeg(); ~G4MIRDRightLeg();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDRightLegBone_h #ifndef DESCSS_MIRDRightLegBone_h
#define DESCSS_MIRDRightLegBone_h 1 #define DESCSS_MIRDRightLegBone_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDRightLegBone : public G4VOrgan { class G4MIRDRightLegBone : public G4VOrgan {
public: public:
G4MIRDRightLegBone(); G4MIRDRightLegBone();
~G4MIRDRightLegBone(); ~G4MIRDRightLegBone();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDRightLung_h #ifndef DESCSS_MIRDRightLung_h
#define DESCSS_MIRDRightLung_h 1 #define DESCSS_MIRDRightLung_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDRightLung : public G4VOrgan { class G4MIRDRightLung : public G4VOrgan {
public: public:
G4MIRDRightLung(); G4MIRDRightLung();
~G4MIRDRightLung(); ~G4MIRDRightLung();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDRightOvary_h #ifndef DESCSS_MIRDRightOvary_h
#define DESCSS_MIRDRightOvary_h 1 #define DESCSS_MIRDRightOvary_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDRightOvary : public G4VOrgan { class G4MIRDRightOvary : public G4VOrgan {
public: public:
G4MIRDRightOvary(); G4MIRDRightOvary();
~G4MIRDRightOvary(); ~G4MIRDRightOvary();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDRightScapula_h #ifndef DESCSS_MIRDRightScapula_h
#define DESCSS_MIRDRightScapula_h 1 #define DESCSS_MIRDRightScapula_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDRightScapula : public G4VOrgan { class G4MIRDRightScapula : public G4VOrgan {
public: public:
G4MIRDRightScapula(); G4MIRDRightScapula();
~G4MIRDRightScapula(); ~G4MIRDRightScapula();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDRightTeste_h #ifndef DESCSS_MIRDRightTeste_h
#define DESCSS_MIRDRightTeste_h 1 #define DESCSS_MIRDRightTeste_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDRightTeste : public G4VOrgan { class G4MIRDRightTeste : public G4VOrgan {
public: public:
G4MIRDRightTeste(); G4MIRDRightTeste();
~G4MIRDRightTeste(); ~G4MIRDRightTeste();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDSkull_h #ifndef DESCSS_MIRDSkull_h
#define DESCSS_MIRDSkull_h 1 #define DESCSS_MIRDSkull_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDSkull : public G4VOrgan { class G4MIRDSkull : public G4VOrgan {
public: public:
G4MIRDSkull(); G4MIRDSkull();
~G4MIRDSkull(); ~G4MIRDSkull();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDSmallIntestine_h #ifndef DESCSS_MIRDSmallIntestine_h
#define DESCSS_MIRDSmallIntestine_h 1 #define DESCSS_MIRDSmallIntestine_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDSmallIntestine : public G4VOrgan { class G4MIRDSmallIntestine : public G4VOrgan {
public: public:
G4MIRDSmallIntestine(); G4MIRDSmallIntestine();
~G4MIRDSmallIntestine(); ~G4MIRDSmallIntestine();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDSpleen_h #ifndef DESCSS_MIRDSpleen_h
#define DESCSS_MIRDSpleen_h 1 #define DESCSS_MIRDSpleen_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDSpleen : public G4VOrgan { class G4MIRDSpleen : public G4VOrgan {
public: public:
G4MIRDSpleen(); G4MIRDSpleen();
~G4MIRDSpleen(); ~G4MIRDSpleen();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDStomach_h #ifndef DESCSS_MIRDStomach_h
#define DESCSS_MIRDStomach_h 1 #define DESCSS_MIRDStomach_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDStomach : public G4VOrgan { class G4MIRDStomach : public G4VOrgan {
public: public:
G4MIRDStomach(); G4MIRDStomach();
~G4MIRDStomach(); ~G4MIRDStomach();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDThymus_h #ifndef DESCSS_MIRDThymus_h
#define DESCSS_MIRDThymus_h 1 #define DESCSS_MIRDThymus_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDThymus : public G4VOrgan { class G4MIRDThymus : public G4VOrgan {
public: public:
G4MIRDThymus(); G4MIRDThymus();
~G4MIRDThymus(); ~G4MIRDThymus();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDThyroid_h #ifndef DESCSS_MIRDThyroid_h
#define DESCSS_MIRDThyroid_h 1 #define DESCSS_MIRDThyroid_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDThyroid : public G4VOrgan { class G4MIRDThyroid : public G4VOrgan {
public: public:
G4MIRDThyroid(); G4MIRDThyroid();
~G4MIRDThyroid(); ~G4MIRDThyroid();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDTrunk_h #ifndef DESCSS_MIRDTrunk_h
#define DESCSS_MIRDTrunk_h 1 #define DESCSS_MIRDTrunk_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDTrunk : public G4VOrgan { class G4MIRDTrunk : public G4VOrgan {
public: public:
G4MIRDTrunk(); G4MIRDTrunk();
~G4MIRDTrunk(); ~G4MIRDTrunk();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,18 +1,18 @@
#ifndef DESCSS_MIRDUpperLargeIntestine_h #ifndef DESCSS_MIRDUpperLargeIntestine_h
#define DESCSS_MIRDUpperLargeIntestine_h 1 #define DESCSS_MIRDUpperLargeIntestine_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDUpperLargeIntestine : public G4VOrgan { class G4MIRDUpperLargeIntestine : public G4VOrgan {
public: public:
G4MIRDUpperLargeIntestine(); G4MIRDUpperLargeIntestine();
~G4MIRDUpperLargeIntestine(); ~G4MIRDUpperLargeIntestine();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDUpperSpine_h #ifndef DESCSS_MIRDUpperSpine_h
#define DESCSS_MIRDUpperSpine_h 1 #define DESCSS_MIRDUpperSpine_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDUpperSpine : public G4VOrgan { class G4MIRDUpperSpine : public G4VOrgan {
public: public:
G4MIRDUpperSpine(); G4MIRDUpperSpine();
~G4MIRDUpperSpine(); ~G4MIRDUpperSpine();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDUrinaryBladder_h #ifndef DESCSS_MIRDUrinaryBladder_h
#define DESCSS_MIRDUrinaryBladder_h 1 #define DESCSS_MIRDUrinaryBladder_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDUrinaryBladder : public G4VOrgan { class G4MIRDUrinaryBladder : public G4VOrgan {
public: public:
G4MIRDUrinaryBladder(); G4MIRDUrinaryBladder();
~G4MIRDUrinaryBladder(); ~G4MIRDUrinaryBladder();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,19 +1,19 @@
#ifndef DESCSS_MIRDUterus_h #ifndef DESCSS_MIRDUterus_h
#define DESCSS_MIRDUterus_h 1 #define DESCSS_MIRDUterus_h 1
#include "G4VOrgan.h" #include "G4VOrgan.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4MIRDUterus : public G4VOrgan { class G4MIRDUterus : public G4VOrgan {
public: public:
G4MIRDUterus(); G4MIRDUterus();
~G4MIRDUterus(); ~G4MIRDUterus();
G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool); G4VPhysicalVolume* Construct(const G4String&, G4VPhysicalVolume*, const G4String&, G4bool, G4bool);
private: private:
}; };
#endif #endif

View File

@ -1,17 +1,17 @@
#ifndef DESCSS_MaleBuilder_h #ifndef DESCSS_MaleBuilder_h
#define DESCSS_MaleBuilder_h 1 #define DESCSS_MaleBuilder_h 1
#include "G4PhantomBuilder.h" #include "G4PhantomBuilder.h"
class G4PhantomBuilder; class G4PhantomBuilder;
class G4MaleBuilder : public G4PhantomBuilder { class G4MaleBuilder : public G4PhantomBuilder {
public: public:
G4MaleBuilder(); G4MaleBuilder();
~G4MaleBuilder(); ~G4MaleBuilder();
void BuildMaleGenitalia(const G4String& colourName, G4bool solidVis, G4bool sensitivity); void BuildMaleGenitalia(const G4String& colourName, G4bool solidVis, G4bool sensitivity);
void BuildLeftTeste(const G4String& colourName, G4bool solidVis, G4bool sensitivity); void BuildLeftTeste(const G4String& colourName, G4bool solidVis, G4bool sensitivity);
void BuildRightTeste(const G4String& colourName, G4bool solidVis, G4bool sensitivity); void BuildRightTeste(const G4String& colourName, G4bool solidVis, G4bool sensitivity);
// void SetModel(G4String); // void SetModel(G4String);
}; };
#endif #endif

View File

@ -1,77 +1,77 @@
#ifndef DESCSS_PhantomBuilder_h #ifndef DESCSS_PhantomBuilder_h
#define DESCSS_PhantomBuilder_h 1 #define DESCSS_PhantomBuilder_h 1
#include "G4BasePhantomBuilder.h" #include "G4BasePhantomBuilder.h"
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
#include "globals.hh" #include "globals.hh"
class G4BasePhantomBuilder; class G4BasePhantomBuilder;
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4VBodyFactory; class G4VBodyFactory;
class G4PhantomBuilder : public G4BasePhantomBuilder { class G4PhantomBuilder : public G4BasePhantomBuilder {
public: public:
G4PhantomBuilder(); G4PhantomBuilder();
~G4PhantomBuilder(); ~G4PhantomBuilder();
void BuildHead(const G4String&, G4bool, G4bool); void BuildHead(const G4String&, G4bool, G4bool);
void BuildTrunk(const G4String&, G4bool, G4bool); void BuildTrunk(const G4String&, G4bool, G4bool);
void BuildLeftLeg(const G4String&, G4bool, G4bool); void BuildLeftLeg(const G4String&, G4bool, G4bool);
void BuildRightLeg(const G4String&, G4bool, G4bool); void BuildRightLeg(const G4String&, G4bool, G4bool);
void BuildUpperSpine(const G4String&, G4bool, G4bool); void BuildUpperSpine(const G4String&, G4bool, G4bool);
void BuildMiddleLowerSpine(const G4String&, G4bool, G4bool); void BuildMiddleLowerSpine(const G4String&, G4bool, G4bool);
void BuildLeftLegBone(const G4String&, G4bool, G4bool); void BuildLeftLegBone(const G4String&, G4bool, G4bool);
void BuildRightLegBone(const G4String&, G4bool, G4bool); void BuildRightLegBone(const G4String&, G4bool, G4bool);
void BuildLeftArmBone(const G4String&, G4bool, G4bool); void BuildLeftArmBone(const G4String&, G4bool, G4bool);
void BuildRightArmBone(const G4String&, G4bool, G4bool); void BuildRightArmBone(const G4String&, G4bool, G4bool);
void BuildSkull(const G4String&, G4bool, G4bool); void BuildSkull(const G4String&, G4bool, G4bool);
void BuildRibCage(const G4String&, G4bool, G4bool); void BuildRibCage(const G4String&, G4bool, G4bool);
void BuildPelvis(const G4String&, G4bool, G4bool); void BuildPelvis(const G4String&, G4bool, G4bool);
void BuildLeftScapula(const G4String&, G4bool, G4bool); void BuildLeftScapula(const G4String&, G4bool, G4bool);
void BuildRightScapula(const G4String&, G4bool, G4bool); void BuildRightScapula(const G4String&, G4bool, G4bool);
void BuildLeftAdrenal(const G4String&, G4bool, G4bool); void BuildLeftAdrenal(const G4String&, G4bool, G4bool);
void BuildRightAdrenal(const G4String&, G4bool, G4bool); void BuildRightAdrenal(const G4String&, G4bool, G4bool);
void BuildLeftClavicle(const G4String&, G4bool, G4bool); void BuildLeftClavicle(const G4String&, G4bool, G4bool);
void BuildRightClavicle(const G4String&, G4bool, G4bool); void BuildRightClavicle(const G4String&, G4bool, G4bool);
void BuildBrain(const G4String&, G4bool, G4bool); void BuildBrain(const G4String&, G4bool, G4bool);
void BuildHeart(const G4String&, G4bool, G4bool); void BuildHeart(const G4String&, G4bool, G4bool);
void BuildLeftLung(const G4String&, G4bool, G4bool); void BuildLeftLung(const G4String&, G4bool, G4bool);
void BuildRightLung(const G4String&, G4bool, G4bool); void BuildRightLung(const G4String&, G4bool, G4bool);
void BuildStomach(const G4String&, G4bool, G4bool); void BuildStomach(const G4String&, G4bool, G4bool);
void BuildSmallIntestine(const G4String&, G4bool, G4bool); void BuildSmallIntestine(const G4String&, G4bool, G4bool);
void BuildUpperLargeIntestine(const G4String&, G4bool, G4bool); void BuildUpperLargeIntestine(const G4String&, G4bool, G4bool);
void BuildLowerLargeIntestine(const G4String&, G4bool, G4bool); void BuildLowerLargeIntestine(const G4String&, G4bool, G4bool);
void BuildLeftKidney(const G4String&, G4bool, G4bool); void BuildLeftKidney(const G4String&, G4bool, G4bool);
void BuildRightKidney(const G4String&, G4bool, G4bool); void BuildRightKidney(const G4String&, G4bool, G4bool);
void BuildLiver(const G4String&, G4bool, G4bool); void BuildLiver(const G4String&, G4bool, G4bool);
void BuildPancreas(const G4String&, G4bool, G4bool); void BuildPancreas(const G4String&, G4bool, G4bool);
void BuildSpleen(const G4String&, G4bool, G4bool); void BuildSpleen(const G4String&, G4bool, G4bool);
void BuildUrinaryBladder(const G4String&, G4bool, G4bool); void BuildUrinaryBladder(const G4String&, G4bool, G4bool);
void BuildThyroid(const G4String&, G4bool, G4bool); void BuildThyroid(const G4String&, G4bool, G4bool);
void BuildThymus(const G4String&, G4bool, G4bool); void BuildThymus(const G4String&, G4bool, G4bool);
void SetModel(G4String); void SetModel(G4String);
void SetMotherVolume(G4VPhysicalVolume*); void SetMotherVolume(G4VPhysicalVolume*);
G4VPhysicalVolume* GetPhantom(); G4VPhysicalVolume* GetPhantom();
protected: protected:
G4VBodyFactory* body; G4VBodyFactory* body;
G4String model; G4String model;
G4VPhysicalVolume* motherVolume; G4VPhysicalVolume* motherVolume;
G4VPhysicalVolume* headVolume; G4VPhysicalVolume* headVolume;
G4VPhysicalVolume* trunkVolume; G4VPhysicalVolume* trunkVolume;
G4VPhysicalVolume* leftLegVolume; G4VPhysicalVolume* leftLegVolume;
G4VPhysicalVolume* rightLegVolume; G4VPhysicalVolume* rightLegVolume;
G4VPhysicalVolume* maleGenitaliaVolume; G4VPhysicalVolume* maleGenitaliaVolume;
}; };
#endif #endif

View File

@ -1,13 +1,13 @@
#ifndef DESCSS_VBodyFactory_h #ifndef DESCSS_VBodyFactory_h
#define DESCSS_VBodyFactory_h 1 #define DESCSS_VBodyFactory_h 1
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4VBodyFactory { class G4VBodyFactory {
public: public:
G4VBodyFactory(); G4VBodyFactory();
virtual ~G4VBodyFactory(); virtual ~G4VBodyFactory();
virtual G4VPhysicalVolume* CreateOrgan(const G4String& idFile, G4VPhysicalVolume* motherVolume, virtual G4VPhysicalVolume* CreateOrgan(const G4String& idFile, G4VPhysicalVolume* motherVolume,
const G4String& colour, G4bool solidFrame, G4bool sensitivity) = 0; const G4String& colour, G4bool solidFrame, G4bool sensitivity) = 0;
}; };
#endif #endif

View File

@ -1,16 +1,16 @@
#ifndef DESCSS_VOrgan_h #ifndef DESCSS_VOrgan_h
#define DESCSS_VOrgan_h 1 #define DESCSS_VOrgan_h 1
#include "G4VPhysicalVolume.hh" #include "G4VPhysicalVolume.hh"
class G4VPhysicalVolume; class G4VPhysicalVolume;
class G4LogicalVolume; class G4LogicalVolume;
class G4VOrgan { class G4VOrgan {
public: public:
G4VOrgan(); G4VOrgan();
virtual ~G4VOrgan(); virtual ~G4VOrgan();
virtual G4VPhysicalVolume* Construct(const G4String& volumeName, G4VPhysicalVolume* mother, virtual G4VPhysicalVolume* Construct(const G4String& volumeName, G4VPhysicalVolume* mother,
const G4String& colourName, G4bool wireFrame, G4bool sensitivity) = 0; const G4String& colourName, G4bool wireFrame, G4bool sensitivity) = 0;
}; };
#endif #endif

View File

@ -1,8 +1,8 @@
#ifndef DESCSS_Material_h #ifndef DESCSS_Material_h
#define DESCSS_Material_h #define DESCSS_Material_h
#include "G4Material.hh" #include "G4Material.hh"
void DefineMaterials(); void DefineMaterials();
#endif #endif

View File

@ -1,133 +1,133 @@
#ifndef DESCSS_Matrix_h #ifndef DESCSS_Matrix_h
#define DESCSS_Matrix_h #define DESCSS_Matrix_h
template <class T> template <class T>
class matrix { class matrix {
public: public:
matrix(int n, int m); matrix(int n, int m);
matrix(const matrix<T>&); matrix(const matrix<T>&);
~matrix(); ~matrix();
void Input(T* p); void Input(T* p);
void Output(); void Output();
int rows() const { return n; }; int rows() const { return n; };
int cols() const { return m; }; int cols() const { return m; };
T& operator()(int i, int j) const; T& operator()(int i, int j) const;
matrix<T>& operator=(const matrix<T>&); matrix<T>& operator=(const matrix<T>&);
matrix<T> operator+() const; matrix<T> operator+() const;
matrix<T> operator+(const matrix<T>&) const; matrix<T> operator+(const matrix<T>&) const;
matrix<T> operator*(const matrix<T>&) const; matrix<T> operator*(const matrix<T>&) const;
matrix<T> operator+(const T&) const; matrix<T> operator+(const T&) const;
matrix<T> operator*(const T&) const; matrix<T> operator*(const T&) const;
matrix<T> operator/(const T&) const; matrix<T> operator/(const T&) const;
protected: protected:
int n, m; int n, m;
T** element; T** element;
}; };
template <class T> template <class T>
matrix<T>::matrix(int n, int m) { matrix<T>::matrix(int n, int m) {
if (m < 0 || n < 0) std::cout << "Rows and Cols must be >= 0 " << std::endl; if (m < 0 || n < 0) std::cout << "Rows and Cols must be >= 0 " << std::endl;
if ((m == 0 || n == 0) && (m != 0 || n != 0)) if ((m == 0 || n == 0) && (m != 0 || n != 0))
std::cout << "Either both or neither rows and columns should be zero " << std::endl; std::cout << "Either both or neither rows and columns should be zero " << std::endl;
this->m = m, this->n = n; this->m = m, this->n = n;
element = new T*[n]; element = new T*[n];
for (int i = 0; i < n; i++) element[i] = new T[m]; for (int i = 0; i < n; i++) element[i] = new T[m];
} }
template <class T> template <class T>
matrix<T>::matrix(const matrix<T>& A) { matrix<T>::matrix(const matrix<T>& A) {
n = A.n, m = A.m; n = A.n, m = A.m;
element = new T*[n]; element = new T*[n];
for (int i = 0; i < n; i++) element[i] = new T[m]; for (int i = 0; i < n; i++) element[i] = new T[m];
for (int i = 0; i < n; i++) for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) element[i][j] = A.element[i][j]; for (int j = 0; j < m; j++) element[i][j] = A.element[i][j];
} }
template <class T> template <class T>
matrix<T>::~matrix() {} matrix<T>::~matrix() {}
template <class T> template <class T>
matrix<T>& matrix<T>::operator=(const matrix<T>& A) { matrix<T>& matrix<T>::operator=(const matrix<T>& A) {
if (this != &A) { if (this != &A) {
delete[] element; delete[] element;
n = A.n, m = A.m; n = A.n, m = A.m;
element = new T*[n]; element = new T*[n];
for (int i = 0; i < n; i++) element[i] = new T[m]; for (int i = 0; i < n; i++) element[i] = new T[m];
for (int i = 0; i < n; i++) for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) element[i][j] = A.element[i][j]; for (int j = 0; j < m; j++) element[i][j] = A.element[i][j];
} }
return *this; return *this;
} }
template <class T> template <class T>
void matrix<T>::Input(T* p) { void matrix<T>::Input(T* p) {
for (int i = 0; i < n; i++) for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) this->element[i][j] = *(p++); for (int j = 0; j < m; j++) this->element[i][j] = *(p++);
} }
template <class T> template <class T>
void matrix<T>::Output() { void matrix<T>::Output() {
for (int i = 0; i < n; i++) { for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) std::cout << element[i][j] << " "; for (int j = 0; j < m; j++) std::cout << element[i][j] << " ";
std::cout << std::endl; std::cout << std::endl;
} }
} }
template <class T> template <class T>
T& matrix<T>::operator()(int i, int j) const { T& matrix<T>::operator()(int i, int j) const {
if (i < 1 || i > n || j < 1 || j > m) std::cout << "Matrix Index Out Of Bounds " << std::endl; if (i < 1 || i > n || j < 1 || j > m) std::cout << "Matrix Index Out Of Bounds " << std::endl;
return element[i - 1][j - 1]; return element[i - 1][j - 1];
} }
template <class T> template <class T>
matrix<T> matrix<T>::operator+(const matrix<T>& A) const { matrix<T> matrix<T>::operator+(const matrix<T>& A) const {
if (n != A.n || m != A.m) std::cout << "Matrix Size is Out of batch " << std::endl; if (n != A.n || m != A.m) std::cout << "Matrix Size is Out of batch " << std::endl;
matrix<T> w(n, m); matrix<T> w(n, m);
for (int i = 0; i < n; i++) for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) w.element[i][j] = element[i][j] + A.element[i][j]; for (int j = 0; j < m; j++) w.element[i][j] = element[i][j] + A.element[i][j];
return w; return w;
} }
template <class T> template <class T>
matrix<T> matrix<T>::operator+(const T& C) const { matrix<T> matrix<T>::operator+(const T& C) const {
matrix<T> w(n, m); matrix<T> w(n, m);
for (int i = 0; i < n; i++) for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) w.element[i][j] = element[i][j] + C; for (int j = 0; j < m; j++) w.element[i][j] = element[i][j] + C;
return w; return w;
} }
template <class T> template <class T>
matrix<T> matrix<T>::operator*(const matrix<T>& A) const { matrix<T> matrix<T>::operator*(const matrix<T>& A) const {
if (m != A.n) std::cout << "Matrix Style is Out of batch " << std::endl; if (m != A.n) std::cout << "Matrix Style is Out of batch " << std::endl;
matrix<T> w(n, m); matrix<T> w(n, m);
for (int i = 0; i < n; i++) for (int i = 0; i < n; i++)
for (int j = 0; j < A.m; j++) { for (int j = 0; j < A.m; j++) {
w.element[i][j] = 0; w.element[i][j] = 0;
for (int k = 0; k < m; k++) w.element[i][j] += element[i][k] * A.element[k][j]; for (int k = 0; k < m; k++) w.element[i][j] += element[i][k] * A.element[k][j];
} }
return w; return w;
} }
template <class T> template <class T>
matrix<T> matrix<T>::operator*(const T& C) const { matrix<T> matrix<T>::operator*(const T& C) const {
matrix<T> w(n, m); matrix<T> w(n, m);
for (int i = 0; i < n; i++) for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) w.element[i][j] = element[i][j] * C; for (int j = 0; j < m; j++) w.element[i][j] = element[i][j] * C;
return w; return w;
} }
template <class T> template <class T>
matrix<T> matrix<T>::operator/(const T& C) const { matrix<T> matrix<T>::operator/(const T& C) const {
matrix<T> w(n, m); matrix<T> w(n, m);
for (int i = 0; i < n; i++) for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) w.element[i][j] = element[i][j] / C; for (int j = 0; j < m; j++) w.element[i][j] = element[i][j] / C;
return w; return w;
} }
#endif #endif

View File

@ -1,26 +1,26 @@
#ifndef DESCSS_PrimaryGeneratorAction_h #ifndef DESCSS_PrimaryGeneratorAction_h
#define DESCSS_PrimaryGeneratorAction_h #define DESCSS_PrimaryGeneratorAction_h
#include "G4ParticleDefinition.hh" #include "G4ParticleDefinition.hh"
#include "G4ParticleGun.hh" #include "G4ParticleGun.hh"
#include "G4VUserPrimaryGeneratorAction.hh" #include "G4VUserPrimaryGeneratorAction.hh"
#include "globals.hh" #include "globals.hh"
class G4ParticleGun; class G4ParticleGun;
class G4Event; class G4Event;
class PrimaryGeneratorAction : public G4VUserPrimaryGeneratorAction { class PrimaryGeneratorAction : public G4VUserPrimaryGeneratorAction {
public: public:
PrimaryGeneratorAction(); PrimaryGeneratorAction();
~PrimaryGeneratorAction(); ~PrimaryGeneratorAction();
virtual void GeneratePrimaries(G4Event*); virtual void GeneratePrimaries(G4Event*);
void DefineParticle(G4String particleType); void DefineParticle(G4String particleType);
const G4ParticleGun* GetParticleGun() const { return fParticleGun; }; const G4ParticleGun* GetParticleGun() const { return fParticleGun; };
private: private:
G4String particleType = "NULL"; G4String particleType = "NULL";
G4ParticleGun* fParticleGun = nullptr; G4ParticleGun* fParticleGun = nullptr;
}; };
#endif #endif

View File

@ -1,24 +1,24 @@
#ifndef DESCSS_RunAction_h #ifndef DESCSS_RunAction_h
#define DESCSS_RunAction_h #define DESCSS_RunAction_h
#include "G4Accumulable.hh" #include "G4Accumulable.hh"
#include "G4UserRunAction.hh" #include "G4UserRunAction.hh"
#include "globals.hh" #include "globals.hh"
class G4Run; class G4Run;
class RunAction : public G4UserRunAction { class RunAction : public G4UserRunAction {
public: public:
RunAction(); RunAction();
~RunAction() override; ~RunAction() override;
void BeginOfRunAction(const G4Run*) override; void BeginOfRunAction(const G4Run*) override;
void EndOfRunAction(const G4Run*) override; void EndOfRunAction(const G4Run*) override;
void AddEdep(std::map<G4String, G4double> edep); void AddEdep(std::map<G4String, G4double> edep);
private: private:
std::vector<G4String> sensitiveList; std::vector<G4String> sensitiveList;
}; };
#endif #endif

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_Al /type/set GCR_Al
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_Ar /type/set GCR_Ar
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_B /type/set GCR_B
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_Be /type/set GCR_Be
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_C /type/set GCR_C
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_Ca /type/set GCR_Ca
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_Cl /type/set GCR_Cl
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_Co /type/set GCR_Co
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_Cr /type/set GCR_Cr
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_F /type/set GCR_F
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_Fe /type/set GCR_Fe
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_H /type/set GCR_H
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_He /type/set GCR_He
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_K /type/set GCR_K
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_Li /type/set GCR_Li
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

View File

@ -1,15 +1,15 @@
# 多线程设置 # 多线程设置
/run/numberOfThreads 12 /run/numberOfThreads 12
# verbose # verbose
/control/verbose 1 /control/verbose 1
/run/verbose 0 /run/verbose 0
/event/verbose 0 /event/verbose 0
/tracking/verbose 0 /tracking/verbose 0
/vis/verbose errors /vis/verbose errors
/type/set GCR_Mg /type/set GCR_Mg
# 初始化 # 初始化
/run/initialize /run/initialize
/run/beamOn 1000000 /run/beamOn 1000000

Some files were not shown because too many files have changed in this diff Show More