Skip to content
GitLab
Explore
Sign in
Primary navigation
Search or go to…
Project
E
eic_tutorial
Manage
Activity
Members
Labels
Plan
Issues
Issue boards
Milestones
Wiki
Code
Merge requests
Repository
Branches
Commits
Tags
Repository graph
Compare revisions
Snippets
Build
Pipelines
Jobs
Pipeline schedules
Artifacts
Deploy
Releases
Package registry
Container registry
Model registry
Operate
Environments
Terraform modules
Monitor
Incidents
Analyze
Value stream analytics
Contributor analytics
CI/CD analytics
Repository analytics
Model experiments
Help
Help
Support
GitLab documentation
Compare GitLab plans
Community forum
Contribute to GitLab
Provide feedback
Keyboard shortcuts
?
Snippets
Groups
Projects
Show more breadcrumbs
EIC
tutorials
eic_tutorial
Commits
940f6ed0
Commit
940f6ed0
authored
4 years ago
by
Whitney Armstrong
Browse files
Options
Downloads
Patches
Plain Diff
modified: part2/adding_detectors.md
parent
171b747e
No related branches found
No related tags found
No related merge requests found
Changes
1
Hide whitespace changes
Inline
Side-by-side
Showing
1 changed file
src/docs/part2/adding_detectors.md
+172
-240
172 additions, 240 deletions
src/docs/part2/adding_detectors.md
with
172 additions
and
240 deletions
src/docs/part2/adding_detectors.md
+
172
−
240
View file @
940f6ed0
...
...
@@ -16,24 +16,24 @@ title: 'Tutorial Part 2: Modifying and Adding Detectors '
+
[
Running the scripts
](
#running-the-scripts
)
+
[
To Do
](
#to-do
)
Introduction
------------
## Setup
To a newcomer it might not be immediately clear why a
*
generic detector
library
*
based on
`dd4hep`
is a good solution to the 'simulation and
reconstruction geometry problem'. However, with the following examples we
intend to show how generic detector libraries can be used to access the
geometry information in simulation and reconstruction.
Note all these commands assume you are in an
`eic-shell`
singularity session.
We try to emphasize in the following examples that dd4hep (plus a data model)
allows the software components to be only loosely decoupled. This allows for a
'no framework' framework approach where the emphasis is on the underlying
algorithms used (or being designed). Furthermore, using ROOT's TDataframe, the
details of each task are made manifest.
### Clone part2 repo
Furthermore, the 'no framework' framework allows for the each step to be
executed using any tool available, however, the IO and data model should be
fixed.
```
bash
git clone https://eicweb.phy.anl.gov/EIC/tutorials/ip6_tutorial_2.git part2
cd
part2
```
### Compile the detector library
```
bash
mkdir
build
cmake ../.
-DCMAKE_INSTALL_PREFIX
=
../../local
make
-j4
install
```
How to build a detector from scratch
...
...
@@ -48,38 +48,35 @@ make the following assumptions.
### Compiling a new detector
For this tutorial we will build a
simplified Roman Pot
detector.
For this tutorial we will build a
more detailed GEM
detector.
We will discuss the detector built in the source file
`src/MyDetector.cpp`
.
To compile this detector into the GenericDetectors library the detector needs
to be added to the list of sources in the cmake file
`CMakeLists.txt`
.
`src/TrapEndcapTracker_geo.cpp`
.
In the
`CMakeLists.txt`
it adds all cpp files, otherwise we would do
```
bash
dd4hep_add_plugin
(
${
a_lib_name
}
SOURCES
src/
BeamPipe
_geo.cpp
src/
TrapEndcapTracker
_geo.cpp
...
src/SimpleRomanPot_geo.cpp
# add this line
)
```
### Building the geometry
### Building the geometry
(cpp + xml)
The work of
defin
ing the detector is done in a function (here called
`
build
_detector`
) that is registered using the DD4hep plugin macro
The work of
construct
ing the detector is done in a
static
function (here called
`
create
_detector`
) that is registered using the DD4hep plugin macro
`DECLARE_DETELEMENT`
.
```
cpp
static
Ref_t
build
_detector
(
Detector
&
dtor
,
xml_h
e
,
SensitiveDetector
sens
)
static
Ref_t
create
_detector
(
Detector
&
dtor
,
xml_h
e
,
SensitiveDetector
sens
)
{
xml_det_t
x_det
=
e
;
Material
air
=
dtor
.
air
();
...
}
DECLARE_DETELEMENT
(
SimpleRomanPot
,
build_detector
)
DECLARE_DETELEMENT
(
MyGEMTrackerEndcap
,
build_detector
)
```
The argument signature of the
`
build
_detector`
is:
The argument signature of the
`
create
_detector`
is:
-
`Detector& dtor`
: This handle provides the main hook to the detector tree (
`dd4hep::Detector`
).
-
`xml_h e`
: Handle to the XML
`<detector>`
tag associated with the detector in
the "compact" detector description file (more on this later). This provides
...
...
@@ -87,24 +84,31 @@ The argument signature of the `build_detector` is:
-
`SensitiveDetector sens`
: The sensitive detector to be assigned to the
sensitive volumes/elements of the detector.
The DD4hep plugin macro
`DECLARE_DETELEMENT(My
Detector
, build_detector)`
The DD4hep plugin macro
`DECLARE_DETELEMENT(My
GEMTrackerEndcap
, build_detector)`
stamps out the necessary boiler plate code to register a new detector called
`
SimpleRomanPot
`
which is build by calling
`
build
_detector`
.
`
MyGEMTrackerEndcap
`
which is build by calling
`
create
_detector`
.
#### Compact detector description entry element
The
`<detector>`
tag defines a new instance of a detector and requires the
attributes "id", "name", and "type". For example:
attributes "id", "name", and "type". For example
from part 1
:
```
xml
<detector
id=
"1"
name=
"aNeatDetector"
type=
"MyDetector"
vis=
"RedVis"
readout=
"MyDetectorHits"
zoffset=
"1.0*m"
>
</detector>
<detector
id=
"2"
name=
"GEMTracker"
vis=
"RedVis"
type=
"my_GEMTracker"
readout=
"GEMTrackerHits"
>
<layer
id=
"1"
z=
"-100 *cm"
inner_r=
"40*cm"
outer_r=
"120*cm"
phi0_offset=
"0.0*deg"
/>
<layer
id=
"2"
z=
"-80 *cm"
inner_r=
"30*cm"
outer_r=
"90*cm"
phi0_offset=
"0.0*deg"
/>
<layer
id=
"3"
z=
"-60 *cm"
inner_r=
"20*cm"
outer_r=
"70*cm"
phi0_offset=
"0.0*deg"
/>
<layer
id=
"4"
z=
"-40 *cm"
inner_r=
"10*cm"
outer_r=
"20.0*cm"
phi0_offset=
"0.0*deg"
/>
<layer
id=
"5"
z=
" 40 *cm"
inner_r=
"10*cm"
outer_r=
"20.0*cm"
phi0_offset=
"0.0*deg"
/>
<layer
id=
"6"
z=
" 60 *cm"
inner_r=
"25*cm"
outer_r=
"70.0*cm"
phi0_offset=
"0.0*deg"
/>
<layer
id=
"7"
z=
" 80 *cm"
inner_r=
"30*cm"
outer_r=
"90.0*cm"
phi0_offset=
"0.0*deg"
/>
<layer
id=
"8"
z=
"100 *cm"
inner_r=
"40*cm"
outer_r=
"100.0*cm"
phi0_offset=
"0.0*deg"
/>
</detector>
```
`
This defines an instance of the detector named "
aNeatDetecto
r" of type
"
MyDetecto
r" (i.e. the type-name given in the first argument of the DD4hep
`
DECLARE_DETELEMENT
` macro) and with id=
1
. Each `
<detector>
` must have a unique id.
This defines an instance of the detector named "
GEMTracke
r" of type
"
my_GEMTracke
r" (i.e. the type-name given in the first argument of the DD4hep
`
DECLARE_DETELEMENT
` macro) and with id=
2
. Each `
<detector>
` must have a unique id.
The additional attributes (vis, readout, zoffset) are optional.
The detector tag is provided as the second argument in the `
build_detector
`
...
...
@@ -135,6 +139,8 @@ default value. For example:
```cpp
double radius = ( x_det.hasAttr(_Unicode(radius)) ) ? x_det.attr<double>(_Unicode(radius)) : 5.0*dd4hep::cm;
//or
double radius = dd4hep::getAttrOrDefault(x_det, _Unicode(radius), 5.0*dd4hep::cm)
```
This provides a default radius of 5 cm when `
x_det
` does not have a "radius"
...
...
@@ -143,244 +149,170 @@ attribute defined. We will return to this later.
#### Critical parts of build_detector
We will now look at parts of the source file `
src/GenericDetectors/src/SimpleRomanPot_geo.cpp
`.
We will now look at the function in `
src/TrapEndcapTracker_geo.cpp
`.
Note that **this is not a good example to copy**, rather it is a simple example to walk through.
```cpp
static Ref_t
build
_detector(Detector&
dtor
, xml_h e, SensitiveDetector sens)
static Ref_t
create
_detector(Detector&
lcdd
, xml_h e, SensitiveDetector sens)
{
xml_det_t x_det = e;
Material air = dtor.air();
Material carbon = dtor.material("CarbonFiber");
Material silicon = dtor.material("SiliconOxide");
Material aluminum = dtor.material("Aluminum");
Material vacuum = dtor.material("Vacuum");
Material supp_mat = carbon;
Material sens_mat = silicon;
int det_id = x_det.id(); // id=1
string det_name = x_det.nameStr(); // "MyRomanPot"
```
### What materials exist
To browse the list of materials and elements (other than looking in the compact files), go to
[geo viewer](https://eic.phy.anl.gov/geoviewer/index.htm?file=https://eicweb.phy.anl.gov/api/v4/projects/473/jobs/artifacts/master/raw/geo/detector_geo_full.root?job=report)
and scroll through the materials.

Here we are grabbing the materials that are assumed to be already defined. Also
we are getting the detector id and name defined in the `
detector
` tag.
Next we define an [Assembly
volume](http://test-dd4hep.web.cern.ch/test-dd4hep/doxygen/html/classdd4hep_1_1_assembly.html).
Here we also stumble upon the important class
[`
dd4hep::DetElement
`](http://test-dd4hep.web.cern.ch/test-dd4hep/doxygen/html/classdd4hep_1_1_det_element.html#details).
It is a means of providing the detector hierarchy/tree, but doesn't necessarily
have to map exactly to detector geometry. However, it typically will typically
parallel the geometry (and probably should).
```cpp
string module_name = "RomanPot";
Assembly assembly(det_name + "_assembly");
DetElement sdet( det_name, det_id);
sens.setType("tracker");
```
The last line sets the `
SensitiveDetector sens
` argument to be the tracker type
(which is a DD4hep built-in). We will soon assign this to sensitive volumes.
`
sdet
` is associated with the mother detector element by the constructor which
looks up the detector name (here "MyRomanPot").
```cpp
double z_offset = (x_det.hasAttr(_Unicode(zoffset))) ? x_det.attr<double>(_Unicode(zoffset)) : 0.0;
double thickness = (x_det.hasAttr(_Unicode(thickness))) ? x_det.attr<double>(_Unicode(thickness)) : 0.01*dd4hep::cm;
```
Here we grab attributes and provide default values. We continue with default
values that could also be define through attributes, however, we will want to
add child elements of the detector tag (so the attributes does not grow too
long).
```cpp
double rp_chamber_thickness = 5.0*dd4hep::mm;
double rp_chamber_radius = 5.0*dd4hep::cm;
double rp_chamber_length = 50.0*dd4hep::cm;
Tube rp_beam_pipe_tube(rp_chamber_radius, rp_chamber_radius+rp_chamber_thickness, rp_chamber_length/2.0);
Tube rp_beam_vacuum_tube(0.0, rp_chamber_radius+rp_chamber_thickness, rp_chamber_length/2.0);
Tube rp_beam_vacuum_tube2(0.0, rp_chamber_radius, rp_chamber_length/2.0);
double rp_detector_tube_radius = 2.5*dd4hep::cm;
double rp_detector_tube_length = 20.0*dd4hep::cm;
Tube rp_detector_tube(rp_detector_tube_radius, rp_detector_tube_radius+rp_chamber_thickness, rp_detector_tube_length/2.0);
Tube rp_detector_vacuum_tube(0.0, rp_detector_tube_radius+rp_chamber_thickness, rp_detector_tube_length/2.0);
Tube rp_detector_vacuum_tube2(0.0, rp_detector_tube_radius, rp_detector_tube_length/2.0);
ROOT::Math::Rotation3D rot_X( ROOT::Math::RotationX(M_PI/2.0) );
ROOT::Math::Rotation3D rot_Y( ROOT::Math::RotationY(M_PI/2.0) );
UnionSolid rp_chamber_tee1(rp_beam_vacuum_tube, rp_detector_vacuum_tube, rot_X);
UnionSolid rp_chamber_tee12(rp_chamber_tee1, rp_detector_vacuum_tube, rot_Y);
UnionSolid rp_chamber_tee2(rp_beam_vacuum_tube2, rp_detector_vacuum_tube2, rot_X);
UnionSolid rp_chamber_tee22(rp_chamber_tee2, rp_detector_vacuum_tube2, rot_Y);
SubtractionSolid sub1(rp_chamber_tee12,rp_chamber_tee22);
Volume rp_chamber_vol("rp_chamber_walls_vol", sub1, aluminum);
Volume rp_vacuum_vol("rp_chamber_vacuum_vol", rp_chamber_tee22, vacuum);
```
The above code builds the up the two solids associated with 3 tubes
intersecting. One volume is the aluminum vacuum chamber walls and the other is
the vacuum contained within this envelope.
Next we must place these two volumes in the assembly volume (which is just an
empty container-like volume. The PlacedVolume is then associated with a
BitFieldValue in the readout's BitField64 readout string. In this case the
"layer" BitFieldValue. The BitField64 is used to construct unique VolumeIDs and
CellIDs for PlacedVolumes and Segmentations respectively.
typedef vector<PlacedVolume> Placements;
```cpp
PlacedVolume pv;
pv = assembly.placeVolume( rp_chamber_vol );
pv = assembly.placeVolume( rp_vacuum_vol );
pv.addPhysVolID( "layer", 2 );
```
xml_det_t x_det = e;
Material air = lcdd.air();
Material carbon = lcdd.material("CarbonFiber");
Material silicon = lcdd.material("SiliconOxide");
int det_id = x_det.id();
string det_name = x_det.nameStr();
PlacedVolume pv;
Set the PlacedVolume BitFieldValue ID. "2" in this case.
DetElement sdet(det_name, det_id);
Assembly assembly(det_name+"_assembly");
```cpp
double supp_x_half = 1.0*dd4hep::cm;
double supp_y_half = 1.0*dd4hep::cm;
double supp_thickness = 1.0*dd4hep::mm;
double supp_gap_half_width = 1.0*dd4hep::mm;
double sens_thickness = 0.1*dd4hep::mm;
sens.setType("tracker");
string module_name = "GEM";
Box supp_box( supp_x_half, supp_y_half, supp_thickness/2.0 );
Box sens_box( supp_x_half-supp_gap_half_width, supp_y_half-supp_gap_half_width, sens_thickness/2.0 );
double thickness = 0.01*dd4hep::cm;
```
int N_layers = 0;
Next we define vectors which are used to define a "surface" (which will later
generate simulation tracker hits).
for(xml_coll_t lay( x_det, _U(layer) ); lay; ++lay, ++N_layers) {
xml_comp_t x_layer = lay;
double inner_r = x_layer.attr<double>( _Unicode(inner_r) ) ;
double outer_r = x_layer.attr<double>( _Unicode(outer_r) ) ;
double phi0_offset = x_layer.attr<double>( _Unicode(phi0_offset) ) ;
double z = x_layer.attr<double>( _Unicode(z) ) ;
int layer_id = x_layer.id();//attr<double>( _Unicode(z) ) ;
string layer_name = std::string("gem_layer") + std::to_string(layer_id);
Tube gem_layer(inner_r, outer_r, thickness / 2.0);
Volume gem_layer_vol("gem_layer_vol", gem_layer, carbon);
```cpp
// create a measurement plane for the tracking surface attched to the sensitive volume
Vector3D u( 1. , 0. , 0. ) ;
Vector3D v( 0. , 1. , 0. ) ;
Vector3D n( 0. , 0. , 1. ) ;
//Vector3D o( 0. , 0. , 0. ) ;
// compute the inner and outer thicknesses that need to be assigned to the tracking surface
// depending on wether the support is above or below the sensor
// The tracking surface is used in reconstruction. It provides material thickness
// and radation lengths needed for various algorithms, routines, etc.
double inner_thickness = supp_thickness/2.0;
double outer_thickness = supp_thickness/2.0;
double z_shift = 5.0*dd4hep::mm;
double xy_shift = 15.0*dd4hep::mm;
SurfaceType type( SurfaceType::Sensitive ) ;
```
gem_layer_vol.setSensitiveDetector(sens);
We now define a simple rectangular pixel sensor. This will be the first of
four: two will come in along the x axis and two along the y axis.
DetElement layer_DE( sdet, _toString(layer_id,"layer%d"), layer_id );
```cpp
// ------------- x1
Volume support1_vol( "xsenseor_supp", supp_box, supp_mat );
Volume sensor1_vol( "xsenseor_sens", sens_box, sens_mat );
VolPlane surf1( sensor1_vol, type, inner_thickness , outer_thickness, u,v,n);
sensor1_vol.setSensitiveDetector(sens);
```
The code above builds two volumes one which will contain the sensitive volume.
The sensitive volume is assigned to be a sensitive detector.
pv = assembly.placeVolume( gem_layer_vol, Transform3D(RotationZ(phi0_offset),Position(0.0,0.0,z)) );
pv.addPhysVolID( "layer", layer_id );
layer_DE.setPlacement(pv);
```cpp
DetElement layer1_DE( sdet, "layer1_DE", 1 );
pv = rp_vacuum_vol.placeVolume( support1_vol, Position(xy_shift,0, -z_shift) );
pv.addPhysVolID("layer", 1 );
layer1_DE.setPlacement( pv ) ;
```
The above creates a new DetElement, places the support volume in the vacuum,
sets this PlacedVolume to associate with the layer bitfield, and adds the PV to
the DetElement. Note the DetElement is constructed with the parent element
(sdet) being the first argument. In this way it is clear we are building,
(semi-)parallel to the geometry, a detector element hierarchy.
```cpp
DetElement mod1( layer1_DE , "module_1", 1 );
pv = support1_vol.placeVolume(sensor1_vol, Position(0,0,0));
pv.addPhysVolID("module", 1 );
mod1.setPlacement( pv );
```
This creates the module DetElement and places the sensitive volume in the
support volume (already placed). It also assocates the pv with the module
bitfield and then adds the PV to the DetElement.
The above is repeated for the three remaining sensitive elements.
}
Finally we get the top level volume to place the assemble volume. Note we are
using the zoffset. This PV is then associated with the top level "system"
bitfieldvalue.
sdet.setAttributes(lcdd, assembly,x_det.regionStr(),x_det.limitsStr(),x_det.visStr());
```cpp
pv = dtor.pickMotherVolume(sdet).placeVolume(assembly, Position(0,0,z_offset));
pv = lcdd.pickMotherVolume(sdet).placeVolume(assembly);
pv.addPhysVolID("system", det_id); // Set the subdetector system ID.
sdet.setPlacement(pv);
assembly->GetShape()->ComputeBBox() ;
return sdet;
}
```
Here is the XML again:
```xml
<detector id="2" name="GEMTracker" vis="RedVis" type="my_GEMTracker" readout="GEMTrackerHits" >
<layer id="1" z="-100 *cm" inner_r="40*cm" outer_r="120*cm" phi0_offset="0.0*deg" />
<layer id="2" z="-80 *cm" inner_r="30*cm" outer_r="90*cm" phi0_offset="0.0*deg" />
<layer id="3" z="-60 *cm" inner_r="20*cm" outer_r="70*cm" phi0_offset="0.0*deg" />
<layer id="4" z="-40 *cm" inner_r="10*cm" outer_r="20.0*cm" phi0_offset="0.0*deg" />
<layer id="5" z=" 40 *cm" inner_r="10*cm" outer_r="20.0*cm" phi0_offset="0.0*deg" />
<layer id="6" z=" 60 *cm" inner_r="25*cm" outer_r="70.0*cm" phi0_offset="0.0*deg" />
<layer id="7" z=" 80 *cm" inner_r="30*cm" outer_r="90.0*cm" phi0_offset="0.0*deg" />
<layer id="8" z="100 *cm" inner_r="40*cm" outer_r="100.0*cm" phi0_offset="0.0*deg" />
</detector>
````
The Readout and Bit Fields
--------------------------
What problems do you see with this construction?
- rigid
- hard coded
- no defaults
- single material
- lots more...
Simple Reconstruction Overview of scripts
---------------------------------------
### What materials exist?
In the examples here we use ROOT and the LCIO data model.
The following scripts should be executed in order:
To browse the list of materials and elements (other than looking in the compact files), go to
[geo viewer](https://eic.phy.anl.gov/geoviewer/index.htm?file=https://eicweb.phy.anl.gov/api/v4/projects/473/jobs/artifacts/master/raw/geo/detector_geo_full.root?job=report)
and scroll through the materials.

1. `
run_example
` : bash script that runs `
ddsim
` with the Geant4 macro file
`
gps.mac
` and the input geometry defined in `
gem_tracker_disc.xml
`.
2. `
scripts/example_hit_position.cxx
` : ROOT script showing how to use both the
"segmentation" and "surface" geometry to get the hit position information.
3. `
scripts/example_cell_size.cxx
` : ROOT script showing how information about
the geometry beyond the position.
4. `
scripts/example_digi.cxx
` : ROOT script performing a crude digitization of
gem tracker hits.
5. `
scripts/example_hit_recon.cxx
` : ROOT script that shows how to to use
dd4hep to lookup a 'segment' (cell) position based on the unique cellID
attached to the hit object.
6. `
scripts/example_tracking.cxx
` : ROOT script showing how to use the
`
GenFind
` finding library along with `
GenFit
` to produce tracks.
Here we are grabbing the materials that are assumed to be already defined. Also
we are getting the detector id and name defined in the `detector` tag.
### Dependencies
Next we define an [Assembly
volume](http://test-dd4hep.web.cern.ch/test-dd4hep/doxygen/html/classdd4hep_1_1_assembly.html).
Here we also stumble upon the important class
[`dd4hep::DetElement`](http://test-dd4hep.web.cern.ch/test-dd4hep/doxygen/html/classdd4hep_1_1_det_element.html#details).
It is a means of providing the detector hierarchy/tree, but doesn't necessarily
have to map exactly to detector geometry. However, it typically will typically
parallel the geometry (and probably should).
There are some library dependencies:
- DD4hep
- lcgeo
- GenFind
- GenFit
- NPdet
## A more detailed GEM Tracker
Uncomment the include line in `gem_tracker.xml`
### Running the scripts
```xml
<include ref="compact/gem_tracker_endcap.xml"/>
```
And have a look at the detector part of the compact file.
```bash
./run_example
root scripts/example_digi.cxx++
root scripts/example_hit_position.cxx++ # no output
root scripts/example_cell_size.cxx++ # no output
root scripts/example_hit_recon.cxx++
root scripts/example_tracking.cxx++
```xml
<detector
id="GEMTrackerEndcap_ID"
name="GEMTrackerEndcap"
type="MyGEMTrackerEndcap"
readout="GEMTrackerEndcapHits"
vis="BlueVis"
reflect="false">
<module name="GEMModule1" vis="GreenVis">
<trd x1="GEMTrackerEndcapFoilX1/2.0" x2="GEMTrackerEndcapFoilX2/2.0" z="GEMTrackerEndcapFoilY/2"/>
<comment> Going from HV side to readout side</comment>
<module_component thickness="0.127 * mm" material="Mylar"/>
<module_component thickness="50.0*um" material="Kapton" name="entrance_window"/>
<module_component thickness=" 3.0*mm" material="Ar10CO2" name="entrance region" />
<module_component thickness="50.0*um" material="Kapton"/>
<module_component thickness=" 3.0*um" material="Copper"/>
<module_component thickness=" 3.0*mm" material="Ar10CO2" name="drift region"/>
<module_component thickness="30.0*um" material="Kapton" name="gem_foil"/>
<module_component thickness=" 3.0*um" material="Copper" name="gem_foil_Cu"/>
<module_component thickness=" 2.0*mm" material="Ar10CO2" name="transfer region I"/>
<module_component thickness="30.0*um" material="Kapton" name="gem_foil"/>
<module_component thickness=" 3.0*um" material="Copper" name="gem_foil_Cu"/>
<module_component thickness=" 2.0*mm" material="Ar10CO2" name="transfer region II"/>
<module_component thickness="30.0*um" material="Kapton" name="gem_foil"/>
<module_component thickness=" 3.0*um" material="Copper" name="gem_foil_Cu"/>
<module_component thickness=" 2.0*mm" material="Ar10CO2" name="induction region"/>
<module_component thickness="30.0*um" material="Kapton" name="readout" sensitive="true"/>
<module_component thickness=" 3.0*um" material="Copper" name="readout_Cu"/>
<module_component thickness="127.0*um" material="Mylar"/>
<module_component thickness="200.0*um" material="Epoxy" sensitive="true" vis="GreenVis"/>
</module>
<module name="GEMSupportModule1" vis="OrangeVis">
<trd x1="GEMTrackerEndcapFoilX2/2.0" x2="GEMTrackerEndcapFoilX1/2.0" z="GEMTrackerEndcapFrameBotEdge_width"/>
<module_component thickness="GEMTrackerEndcapFrame_thickness" material="Mylar"/>
</module>
<comment>
GEMSupportModule2 is the support in between gem foils.
</comment>
<module name="GEMSupportModule2" vis="OrangeVis">
<trd x1="GEMTrackerEndcapFrameSideEdge_width" x2="GEMTrackerEndcapFrameSideEdge_width" z="GEMTrackerEndcapFoilY/2"/>
<module_component thickness="4.0*mm" material="Mylar"/>
</module>
<layer id="1" >
<ring vis="PurpleVis"
r="GEMTrackerEndcapFoil_rmin+GEMTrackerEndcapFoilY/2.0"
zstart="GEMTrackerEndcap_zmin + 0.5*GEMTrackerEndcapLayer_thickness"
nmodules="12" dz="10 * mm" module="GEMModule1" />
<ring vis="PurpleVis" phi0="15.0*degree"
r="GEMTrackerEndcapFoil_rmin+GEMTrackerEndcapFoilY/2.0"
zstart="GEMTrackerEndcap_zmin + 0.5*GEMTrackerEndcapLayer_thickness"
nmodules="12" dz="0 * mm" module="GEMSupportModule2" />
</layer>
</detector>
`
``
### To Do
Here you see a different strategy: build a module, then build layers constructed from the module.
-
Show how to build a detector
-
Finish track fitting script.
-
Create example for basic PFA usage
This diff is collapsed.
Click to expand it.
Preview
0%
Loading
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Save comment
Cancel
Please
register
or
sign in
to comment