//! for visualization purpose only
double
CEmc_Vis(PHG4Reco* g4Reco, double radius, const int crossings, const int absorberactive = 0)
{
double emc_inner_radius = 95.; // emc inner radius from engineering drawing
double cemcthickness = 12.7;
double emc_outer_radius = emc_inner_radius + cemcthickness; // outer radius
if (radius > emc_inner_radius) {
cout << "inconsistency: preshower radius+thickness: " << radius
<< " larger than emc inner radius: " << emc_inner_radius
<< endl;
gSystem->Exit(-1);
}
//---------------
// Load libraries
//---------------
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
// the radii are only to determined the thickness of the cemc
radius = emc_inner_radius;
int ilayer = Min_cemc_layer;
PHG4SpacalSubsystem *cemc;
cemc = new PHG4SpacalSubsystem("CEMC", ilayer);
cemc ->get_geom().set_radius(emc_inner_radius);
cemc ->get_geom().set_thickness(cemcthickness);
cemc ->get_geom().set_virualize_fiber(true);
cemc ->get_geom().set_construction_verbose(2);
cemc->SetActive();
cemc->SuperDetector("CEMC");
if (absorberactive) cemc->SetAbsorberActive();
cemc->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem( cemc );
if (ilayer > Max_cemc_layer)
{
cout << "layer discrepancy, current layer " << ilayer
<< " max cemc layer: " << Max_cemc_layer << endl;
}
radius += cemcthickness;
radius += no_overlapp;
PHG4CylinderSubsystem *cyl = new PHG4CylinderSubsystem("EMCELECTRONICS", 0);
cyl->SetRadius(radius);
cyl->SetMaterial("G4_TEFLON"); // plastic
cyl->SetThickness(0.5);
if (absorberactive) cyl->SetActive();
g4Reco->registerSubsystem( cyl );
radius += 0.5;
radius += no_overlapp;
return radius;
}
//! A rough version of the inner HCal support ring, from Richie's CAD drawing. - Jin
void HCalInner_SupportRing(PHG4Reco* g4Reco,
const int absorberactive = 0) {
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
const double z_ring1 = (2025 + 2050) / 2. / 10.;
const double z_ring2 = (2150 + 2175) / 2. / 10.;
const double dz = 25. / 10.;
const double innerradius = 116.;
const double maxradius = 178.0 - 0.001; // avoid touching the outer HCal envelop volumne
const double z_rings[] =
{ -z_ring2, -z_ring1, z_ring1, z_ring2, 0, 0, 0, 0 };
PHG4CylinderSubsystem *cyl;
for (int i = 0; i < 4; i++)
{
cyl = new PHG4CylinderSubsystem("HCALIN_SPT_N1", 0);
cyl->SetPosition(0, 0, z_rings[i]);
cyl->SuperDetector("HCALIN_SPT");
cyl->SetRadius(innerradius);
cyl->SetLengthViaRapidityCoverage(false);
cyl->SetLength(dz);
cyl->SetMaterial("G4_Fe"); // use 1 radiation length Al for magnet thickness
cyl->SetThickness(maxradius - innerradius);
if (absorberactive)
cyl->SetActive();
g4Reco->registerSubsystem(cyl);
}
return;
}
//! A rough version of the inner HCal support ring, from Richie's CAD drawing. - Jin
void HCalInner_SupportRing(PHG4Reco* g4Reco,
const int absorberactive = 0) {
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
const double z_ring1 = (2025 + 2050) / 2. / 10.;
const double z_ring2 = (2150 + 2175) / 2. / 10.;
const double dz = 25. / 10.;
const double innerradius_sphenix = 116.;
const double innerradius_ephenix_hadronside = 138.;
const double maxradius = 178.0 - 0.001; // avoid touching the outer HCal envelop volumne
const double z_rings[] =
{ -z_ring2, -z_ring1, z_ring1, z_ring2 };
PHG4CylinderSubsystem *cyl;
for (int i = 0; i < 4; i++)
{
double innerradius = innerradius_sphenix;
if ( z_rings[i] > 0 && inner_hcal_eic == 1)
{
innerradius = innerradius_ephenix_hadronside;
}
cyl = new PHG4CylinderSubsystem("HCALIN_SPT_N1", i);
cyl->set_double_param("place_z",z_rings[i]);
cyl->SuperDetector("HCALIN_SPT");
cyl->set_double_param("radius",innerradius);
cyl->set_int_param("lengthviarapidity",0);
cyl->set_double_param("length",dz);
cyl->set_string_param("material","SS310");
cyl->set_double_param("thickness",maxradius - innerradius);
if (absorberactive)
{
cyl->SetActive();
}
g4Reco->registerSubsystem(cyl);
}
return;
}
double Pipe(PHG4Reco* g4Reco,
double radius,
const int absorberactive = 0,
int verbosity = 0) {
double pipe_radius = 2.16; // 2.16 cm based on spec sheet
double pipe_thickness = 0.0760; // 760 um based on spec sheet
double pipe_length = g4Reco->GetWorldSizeZ() - no_overlapp; // entire volume
if (radius > pipe_radius) {
cout << "inconsistency: radius: " << radius
<< " larger than Pipe inner radius: " << pipe_radius << endl;
gSystem->Exit(-1);
}
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
PHG4CylinderSubsystem *cyl = new PHG4CylinderSubsystem("PIPE", 0);
cyl->SetRadius(pipe_radius);
cyl->SetLengthViaRapidityCoverage(false);
cyl->SetLength(pipe_length);
cyl->SetMaterial("G4_Be");
cyl->SetThickness(pipe_thickness);
cyl->SuperDetector("PIPE");
if (absorberactive) cyl->SetActive();
g4Reco->registerSubsystem( cyl );
radius = pipe_radius + pipe_thickness;
if (verbosity >= 0) {
cout << "=========================== G4_Pipe.C::Pipe() =============================" << endl;
cout << " PIPE Material Description:" << endl;
cout << " inner radius = " << pipe_radius << " cm" << endl;
cout << " thickness = " << pipe_thickness << " cm" << endl;
cout << " outer radius = " << pipe_radius + pipe_thickness << " cm" << endl;
cout << " length = " << pipe_length << " cm" << endl;
cout << "===========================================================================" << endl;
}
radius += no_overlapp;
return radius;
}
//! EMCal setup macro - 1D azimuthal projective SPACAL
double
CEmc_1DProjectiveSpacal(PHG4Reco* g4Reco, double radius, const int crossings, const int absorberactive = 0)
{
double emc_inner_radius = 95.; // emc inner radius from engineering drawing
double cemcthickness = 12.7;
double emc_outer_radius = emc_inner_radius + cemcthickness; // outer radius
if (radius > emc_inner_radius) {
cout << "inconsistency: preshower radius+thickness: " << radius
<< " larger than emc inner radius: " << emc_inner_radius
<< endl;
gSystem->Exit(-1);
}
//---------------
// Load libraries
//---------------
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
// boundary check
if (radius> emc_inner_radius - 1.5 - no_overlapp)
{
cout <<"G4_CEmc_Spacal.C::CEmc() - expect radius < "<<emc_inner_radius - 1.5 - no_overlapp<<" to install SPACAL"<<endl;
exit(1);
}
radius = emc_inner_radius - 1.5 - no_overlapp;
// 1.5cm thick teflon as an approximation for EMCAl light collection + electronics (10% X0 total estimated)
PHG4CylinderSubsystem *cyl = new PHG4CylinderSubsystem("CEMC_ELECTRONICS", 0);
cyl->SuperDetector("CEMC_ELECTRONICS");
cyl->set_double_param("radius",radius);
cyl->set_string_param("material","G4_TEFLON");
cyl->set_double_param("thickness",1.5);
if (absorberactive) cyl->SetActive();
g4Reco->registerSubsystem( cyl );
radius += 1.5;
radius += no_overlapp;
int ilayer = Min_cemc_layer;
PHG4SpacalSubsystem *cemc;
cemc = new PHG4SpacalSubsystem("CEMC", ilayer);
cemc ->get_geom().set_radius(emc_inner_radius);
cemc ->get_geom().set_thickness(cemcthickness);
cemc ->get_geom().set_construction_verbose(1);
cemc->SetActive();
cemc->SuperDetector("CEMC");
if (absorberactive) cemc->SetAbsorberActive();
cemc->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem( cemc );
if (ilayer > Max_cemc_layer)
{
cout << "layer discrepancy, current layer " << ilayer
<< " max cemc layer: " << Max_cemc_layer << endl;
}
radius += cemcthickness;
radius += no_overlapp;
// 0.5cm thick Stainless Steel as an approximation for EMCAl support system
cyl = new PHG4CylinderSubsystem("CEMC_SPT", 0);
cyl->SuperDetector("CEMC_SPT");
cyl->set_double_param("radius",radius);
cyl->set_string_param("material","SS310"); // SS310 Stainless Steel
cyl->set_double_param("thickness",0.5);
if (absorberactive)
cyl->SetActive();
g4Reco->registerSubsystem(cyl);
radius += 0.5;
radius += no_overlapp;
return radius;
}
//! test for 2D projective SPACAL using 1D projective modules. For evaluation only
double
CEmc_Proj(PHG4Reco* g4Reco, double radius, const int crossings, const int absorberactive = 0)
{
double emc_inner_radius = 95.; // emc inner radius from engineering drawing
double cemcthickness = 12.9+1.5;
double emc_outer_radius = emc_inner_radius + cemcthickness; // outer radius
if (radius > emc_inner_radius) {
cout << "inconsistency: preshower radius+thickness: " << radius
<< " larger than emc inner radius: " << emc_inner_radius
<< endl;
gSystem->Exit(-1);
}
//---------------
// Load libraries
//---------------
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
cout <<"Get_Spacal_Tilt() = "<<Get_Spacal_Tilt()<<endl;
// the radii are only to determined the thickness of the cemc
//double emc_inner_radius = radius; // emc inner radius from engineering spreadsheet
// double cemcthickness = 12.9+1.5;
// double emc_outer_radius = emc_inner_radius + cemcthickness; // outer radius
radius = emc_outer_radius;
int ilayer = Min_cemc_layer;
PHG4SpacalSubsystem *cemc;
cemc = new PHG4SpacalSubsystem("CEMC", ilayer);
cemc ->get_geom().set_radius(emc_inner_radius);
cemc ->get_geom().set_thickness(cemcthickness);
cemc ->get_geom().set_construction_verbose(2);
cemc ->get_geom().set_config(PHG4CylinderGeom_Spacalv1::kProjective_PolarTaper);
cemc ->get_geom().set_azimuthal_tilt(Get_Spacal_Tilt());
// cemc ->get_geom().set_azimuthal_tilt(-2.3315/2./95*1.9);
// cemc ->get_geom().set_azimuthal_tilt(6.28/256*2);
// cemc ->get_geom().set_azimuthal_tilt(-6.28/256*4);
// cemc ->get_geom().set_azimuthal_seg_visible(true);
// cemc ->get_geom().set_virualize_fiber(false);
// cemc ->get_geom().set_assembly_spacing(0.001);
cemc ->get_geom().set_polar_taper_ratio(1.128);
// cemc ->get_geom().set_polar_taper_ratio(1.123);
// cemc ->get_geom().set_polar_taper_ratio(1.117);
// cemc ->get_geom().set_absorber_mat("G4_AIR");
// cemc ->get_geom().set_azimuthal_n_sec(256/2);
cemc->SetActive();
cemc->SuperDetector("CEMC");
if (absorberactive) cemc->SetAbsorberActive();
cemc->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem( cemc );
if (ilayer > Max_cemc_layer)
{
cout << "layer discrepancy, current layer " << ilayer
<< " max cemc layer: " << Max_cemc_layer << endl;
}
radius += cemcthickness;
radius += no_overlapp;
PHG4CylinderSubsystem *cyl = new PHG4CylinderSubsystem("EMCELECTRONICS", 0);
cyl->set_double_param("radius",radius);
cyl->set_string_param("material","G4_TEFLON");
cyl->set_double_param("thickness",0.5);
if (absorberactive) cyl->SetActive();
g4Reco->registerSubsystem( cyl );
radius += 0.5;
radius += no_overlapp;
return radius;
}
//! 2D full projective SPACAL
double
CEmc_2DProjectiveSpacal(PHG4Reco *g4Reco, double radius, const int crossings,
const int absorberactive = 0)
{
double emc_inner_radius = 92; // emc inner radius from engineering drawing
double cemcthickness = 24.00000 - no_overlapp;
//max radius is 116 cm;
double emc_outer_radius = emc_inner_radius + cemcthickness; // outer radius
assert(emc_outer_radius < 116);
if (radius > emc_inner_radius)
{
cout << "inconsistency: preshower radius+thickness: " << radius
<< " larger than emc inner radius: " << emc_inner_radius << endl;
gSystem->Exit(-1);
}
//---------------
// Load libraries
//---------------
gSystem->Load("libg4detectors.so");
// the radii are only to determined the thickness of the cemc
radius = emc_inner_radius;
//---------------
// Load libraries
//---------------
// 1.5cm thick teflon as an approximation for EMCAl light collection + electronics (10% X0 total estimated)
PHG4CylinderSubsystem *cyl = new PHG4CylinderSubsystem("CEMC_ELECTRONICS", 0);
cyl->set_double_param("radius", radius);
cyl->set_string_param("material", "G4_TEFLON");
cyl->set_double_param("thickness", 1.5 - no_overlapp);
cyl->SuperDetector("CEMC_ELECTRONICS");
cyl->OverlapCheck(overlapcheck);
if (absorberactive) cyl->SetActive();
g4Reco->registerSubsystem(cyl);
radius += 1.5;
cemcthickness -= 1.5 + no_overlapp;
// 0.5cm thick Stainless Steel as an approximation for EMCAl support system
cyl = new PHG4CylinderSubsystem("CEMC_SPT", 0);
cyl->SuperDetector("CEMC_SPT");
cyl->set_double_param("radius", radius + cemcthickness - 0.5);
cyl->set_string_param("material", "SS310"); // SS310 Stainless Steel
cyl->set_double_param("thickness", 0.5 - no_overlapp);
cyl->OverlapCheck(overlapcheck);
if (absorberactive)
cyl->SetActive();
g4Reco->registerSubsystem(cyl);
cemcthickness -= 0.5 + no_overlapp;
//---------------
// Load libraries
//---------------
int ilayer = 0;
PHG4SpacalSubsystem *cemc;
const bool use_2015_design = false;
if (use_2015_design)
{
cemc = new PHG4SpacalSubsystem("CEMC", ilayer);
cemc->set_int_param("config", PHG4CylinderGeom_Spacalv1::kFullProjective_2DTaper_SameLengthFiberPerTower);
cemc->set_double_param("radius", radius); // overwrite minimal radius
cemc->set_double_param("thickness", cemcthickness); // overwrite thickness
cemc->set_int_param("azimuthal_n_sec", 32);
// cemc->set_int_param("construction_verbose", 2);
cemc->SetActive();
cemc->SuperDetector("CEMC");
if (absorberactive)
cemc->SetAbsorberActive();
cemc->OverlapCheck(overlapcheck);
}
else
{
cemc = new PHG4SpacalSubsystem("CEMC", ilayer);
cemc->set_int_param("virualize_fiber", 0);
cemc->set_int_param("azimuthal_seg_visible", 1);
cemc->set_int_param("construction_verbose", 0);
cemc->Verbosity(0);
cemc->UseCalibFiles(PHG4DetectorSubsystem::xml);
cemc->SetCalibrationFileDir(string(getenv("CALIBRATIONROOT")) + string("/CEMC/Geometry_2017ProjTilted/"));
cemc->set_double_param("radius", radius); // overwrite minimal radius
cemc->set_double_param("thickness", cemcthickness); // overwrite thickness
cemc->SetActive();
cemc->SuperDetector("CEMC");
if (absorberactive)
cemc->SetAbsorberActive();
cemc->OverlapCheck(overlapcheck);
}
g4Reco->registerSubsystem(cemc);
if (ilayer > Max_cemc_layer)
{
cout << "layer discrepancy, current layer " << ilayer
<< " max cemc layer: " << Max_cemc_layer << endl;
}
radius += cemcthickness;
radius += no_overlapp;
return radius;
}
double
CEmc(PHG4Reco* g4Reco, double radius, const int crossings, const int absorberactive = 0)
{
if (radius > 100) {
cout << "inconsistency: radius: " << radius
<< " larger than ALICE CEMC inner radius: 100" << endl;
gSystem->Exit(-1);
}
radius = 100;
//---------------
// Load libraries
//---------------
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
double depth = 18*1.23; // 18 radlen, 1 radlen = 1.23 cm
double scintiwidth = 0.176;
double leadwidth = 0.144;
PHG4CylinderSubsystem *cemc;
for (int ilayer = Min_cemc_layer; ilayer <= Max_cemc_layer; ilayer++)
{
cemc = new PHG4CylinderSubsystem("ABSORBER_CEMC", ilayer);
cemc->SetRadius(radius);
cemc->SetMaterial("G4_Pb");
cemc->SetThickness(leadwidth);
cemc->SuperDetector("ABSORBER_CEMC");
if (absorberactive) cemc->SetActive();
cemc->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem( cemc );
radius += leadwidth;
radius += no_overlapp;
cemc = new PHG4CylinderSubsystem("CEMC", ilayer);
cemc->SetRadius(radius);
cemc->SetMaterial("Scintillator");
cemc->SetThickness(scintiwidth);
cemc->SetActive();
cemc->SuperDetector("CEMC");
cemc->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem( cemc );
radius += scintiwidth;
radius += no_overlapp;
}
PHG4CylinderSubsystem *cyl = new PHG4CylinderSubsystem("EMCELECTRONICS", 0);
cyl->SetRadius(radius);
cyl->SetMaterial("G4_TEFLON"); // plastic
cyl->SetThickness(0.5);
if (absorberactive) cyl->SetActive();
g4Reco->registerSubsystem( cyl );
radius += 0.5;
radius += no_overlapp;
return radius;
}
//! 2D full projective SPACAL
double
CEmc_2DProjectiveSpacal(PHG4Reco* g4Reco, double radius, const int crossings,
const int absorberactive = 0)
{
double emc_inner_radius = 95.; // emc inner radius from engineering drawing
double cemcthickness = 21.00000 - no_overlapp;
double emc_outer_radius = emc_inner_radius + cemcthickness; // outer radius
if (radius > emc_inner_radius)
{
cout << "inconsistency: preshower radius+thickness: " << radius
<< " larger than emc inner radius: " << emc_inner_radius << endl;
gSystem->Exit(-1);
}
//---------------
// Load libraries
//---------------
gSystem->Load("libg4detectors.so");
// the radii are only to determined the thickness of the cemc
radius = emc_inner_radius;
//---------------
// Load libraries
//---------------
// 1.5cm thick teflon as an approximation for EMCAl light collection + electronics (10% X0 total estimated)
PHG4CylinderSubsystem *cyl = new PHG4CylinderSubsystem("CEMC_ELECTRONICS", 0);
cyl->set_double_param("radius",radius);
cyl->set_string_param("material","G4_TEFLON");
cyl->set_double_param("thickness",1.5- no_overlapp);
cyl->SuperDetector("CEMC_ELECTRONICS");
cyl->OverlapCheck(overlapcheck);
if (absorberactive) cyl->SetActive();
g4Reco->registerSubsystem( cyl );
radius += 1.5;
cemcthickness -= 1.5+no_overlapp;
// 0.5cm thick Stainless Steel as an approximation for EMCAl support system
cyl = new PHG4CylinderSubsystem("CEMC_SPT", 0);
cyl->SuperDetector("CEMC_SPT");
cyl->set_double_param("radius",radius +cemcthickness - 0.5 );
cyl->set_string_param("material","SS310"); // SS310 Stainless Steel
cyl->set_double_param("thickness",0.5 - no_overlapp);
cyl->OverlapCheck(overlapcheck);
if (absorberactive)
cyl->SetActive();
g4Reco->registerSubsystem(cyl);
cemcthickness -= 0.5+no_overlapp;
//---------------
// Load libraries
//---------------
int ilayer = Min_cemc_layer;
PHG4SpacalSubsystem *cemc;
cemc = new PHG4SpacalSubsystem("CEMC", ilayer);
cemc->get_geom().set_config(
PHG4CylinderGeom_Spacalv1::kFullProjective_2DTaper_SameLengthFiberPerTower);
// load from hard code map for now. Need to move to calibration file or database.
cemc->get_geom().load_demo_sector_tower_map3();
cemc->get_geom().set_radius(radius);
cemc->get_geom().set_thickness(cemcthickness);
cemc->get_geom().set_construction_verbose(1);
cemc->SetActive();
cemc->SuperDetector("CEMC");
if (absorberactive)
cemc->SetAbsorberActive();
cemc->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem(cemc);
if (ilayer > Max_cemc_layer)
{
cout << "layer discrepancy, current layer " << ilayer
<< " max cemc layer: " << Max_cemc_layer << endl;
}
radius += cemcthickness;
radius += no_overlapp;
return radius;
}
double Svtx(PHG4Reco* g4Reco, double radius,
const int absorberactive = 0,
int verbosity = 0)
{
if (n_maps_layer > 0)
{
bool maps_overlapcheck = false; // set to true if you want to check for overlaps
// MAPS inner barrel layers
//======================================================
double maps_layer_radius[3] = {24.61, 32.59, 39.88}; // mm - numbers from Walt 6 Aug 2018
// D. McGlinchey 6Aug2018 - type no longer is used, included here because I was too lazy to remove it from the code
int stave_type[3] = {0, 0, 0};
int staves_in_layer[3] = {12, 16, 20}; // Number of staves per layer in sPHENIX MVTX
double phi_tilt[3] = {0.300, 0.305, 0.300}; // radians - numbers from Walt 6 Aug 2018
for (int ilayer = 0; ilayer < n_maps_layer; ilayer++)
{
if (verbosity)
cout << "Create Maps layer " << ilayer << " with radius " << maps_layer_radius[ilayer] << " mm, stave type " << stave_type[ilayer]
<< " pixel size 30 x 30 microns "
<< " active pixel thickness 0.0018 microns" << endl;
PHG4MapsSubsystem* lyr = new PHG4MapsSubsystem("MAPS", ilayer, stave_type[ilayer]);
lyr->Verbosity(verbosity);
lyr->set_double_param("layer_nominal_radius", maps_layer_radius[ilayer]); // thickness in cm
lyr->set_int_param("N_staves", staves_in_layer[ilayer]); // uses fixed number of staves regardless of radius, if set. Otherwise, calculates optimum number of staves
// The cell size is used only during pixilization of sensor hits, but it is convemient to set it now because the geometry object needs it
lyr->set_double_param("pixel_x", 0.0030); // pitch in cm
lyr->set_double_param("pixel_z", 0.0030); // length in cm
lyr->set_double_param("pixel_thickness", 0.0018); // thickness in cm
lyr->set_double_param("phitilt", phi_tilt[ilayer]);
lyr->set_int_param("active", 1);
lyr->OverlapCheck(maps_overlapcheck);
//lyr->set_string_param("stave_geometry_file", "/phenix/hhj3/dcm07e/sPHENIX/macros/macros/g4simulations/mvtx_stave_v01.gdml");
lyr->set_string_param("stave_geometry_file", string(getenv("CALIBRATIONROOT")) + string("/Tracking/geometry/mvtx_stave_v01.gdml"));
g4Reco->registerSubsystem(lyr);
radius = maps_layer_radius[ilayer];
}
}
if (n_intt_layer > 0)
{
//-------------------
// INTT ladders
//-------------------
bool intt_overlapcheck = false; // set to true if you want to check for overlaps
// instantiate the Silicon tracker subsystem and register it
// We make one instance of PHG4TrackerSubsystem for all four layers of tracker
// dimensions are in mm, angles are in radians
// PHG4SiliconTrackerSubsystem creates the detetor layer using PHG4SiliconTrackerDetector
// and instantiates the appropriate PHG4SteppingAction
const double intt_radius_max = 140.; // including stagger radius (mm)
// The length of vpair is used to determine the number of layers
std::vector<std::pair<int, int>> vpair; // (sphxlayer, inttlayer)
for (int i = 0; i < n_intt_layer; i++)
{
// We want the sPHENIX layer numbers for the INTT to be from n_maps_layer to n_maps_layer+n_intt_layer - 1
vpair.push_back(std::make_pair(n_maps_layer + i, i)); // sphxlayer=n_maps_layer+i corresponding to inttlayer=i
if (verbosity) cout << "Create strip tracker layer " << vpair[i].second << " as sphenix layer " << vpair[i].first << endl;
}
PHG4SiliconTrackerSubsystem* sitrack = new PHG4SiliconTrackerSubsystem("SILICON_TRACKER", vpair);
sitrack->Verbosity(verbosity);
sitrack->SetActive(1);
sitrack->OverlapCheck(intt_overlapcheck);
g4Reco->registerSubsystem(sitrack);
// Update the laddertype and ladder spacing configuration
for(int i=0;i<n_intt_layer;i++)
{
sitrack->set_int_param(i, "laddertype", laddertype[i]);
sitrack->set_int_param(i, "nladder", nladder[i]);
sitrack->set_double_param(i,"sensor_radius", sensor_radius[i]); // expecting cm
sitrack->set_double_param(i,"offsetphi",offsetphi[i]); // expecting degrees
}
// outer radius marker (translation back to cm)
radius = intt_radius_max * 0.1;
}
// int verbosity = 1;
// time projection chamber layers --------------------------------------------
// switch ONLY for backward compatibility with 40 layer hits files!
if (tpc_layers_40)
{
n_tpc_layer_inner = 8;
tpc_layer_thick_inner = 1.25;
tpc_layer_rphi_count_inner = 1152;
cout << "Using 8 inner_layers for backward comatibility" << endl;
}
PHG4CylinderSubsystem* cyl;
radius = inner_cage_radius;
double cage_length = 211.0; // From TPC group, gives eta = 1.1 at 78 cm
double n_rad_length_cage = 1.13e-02;
double cage_thickness = 28.6 * n_rad_length_cage; // Kapton X_0 = 28.6 cm // mocks up Kapton + carbon fiber structure
// inner field cage
cyl = new PHG4CylinderSubsystem("SVTXSUPPORT", n_maps_layer + n_intt_layer);
cyl->set_double_param("radius", radius);
cyl->set_int_param("lengthviarapidity", 0);
cyl->set_double_param("length", cage_length);
cyl->set_string_param("material", "G4_KAPTON");
cyl->set_double_param("thickness", cage_thickness);
cyl->SuperDetector("SVTXSUPPORT");
cyl->Verbosity(0);
g4Reco->registerSubsystem(cyl);
radius += cage_thickness;
double inner_readout_radius = 30.;
if (inner_readout_radius < radius) inner_readout_radius = radius;
string tpcgas = "sPHENIX_TPC_Gas"; // Ne(90%) CF4(10%) - defined in g4main/PHG4Reco.cc
// Layer of inert TPC gas from 20-30 cm
if (inner_readout_radius - radius > 0)
{
cyl = new PHG4CylinderSubsystem("SVTXSUPPORT", n_maps_layer + n_intt_layer + 1);
cyl->set_double_param("radius", radius);
cyl->set_int_param("lengthviarapidity", 0);
cyl->set_double_param("length", cage_length);
cyl->set_string_param("material", tpcgas.c_str());
cyl->set_double_param("thickness", inner_readout_radius - radius);
cyl->SuperDetector("SVTXSUPPORT");
g4Reco->registerSubsystem(cyl);
}
radius = inner_readout_radius;
double outer_radius = 78.;
// Active layers of the TPC from 30-40 cm (inner layers)
for (int ilayer = n_maps_layer + n_intt_layer; ilayer < (n_maps_layer + n_intt_layer + n_tpc_layer_inner); ++ilayer)
{
if (verbosity)
cout << "Create TPC gas layer " << ilayer << " with inner radius " << radius << " cm "
<< " thickness " << tpc_layer_thick_inner - 0.01 << " length " << cage_length << endl;
cyl = new PHG4CylinderSubsystem("SVTX", ilayer);
cyl->set_double_param("radius", radius);
cyl->set_int_param("lengthviarapidity", 0);
cyl->set_double_param("length", cage_length);
cyl->set_string_param("material", tpcgas.c_str());
cyl->set_double_param("thickness", tpc_layer_thick_inner - 0.01);
cyl->SetActive();
cyl->SuperDetector("SVTX");
g4Reco->registerSubsystem(cyl);
radius += tpc_layer_thick_inner;
}
// Active layers of the TPC from 40-60 cm (mid layers)
for (int ilayer = n_maps_layer + n_intt_layer + n_tpc_layer_inner; ilayer < (n_maps_layer + n_intt_layer + n_tpc_layer_inner + n_tpc_layer_mid); ++ilayer)
{
if (verbosity)
cout << "Create TPC gas layer " << ilayer << " with inner radius " << radius << " cm "
<< " thickness " << tpc_layer_thick_mid - 0.01 << " length " << cage_length << endl;
cyl = new PHG4CylinderSubsystem("SVTX", ilayer);
cyl->set_double_param("radius", radius);
cyl->set_int_param("lengthviarapidity", 0);
cyl->set_double_param("length", cage_length);
cyl->set_string_param("material", tpcgas.c_str());
cyl->set_double_param("thickness", tpc_layer_thick_mid - 0.01);
cyl->SetActive();
cyl->SuperDetector("SVTX");
g4Reco->registerSubsystem(cyl);
radius += tpc_layer_thick_mid;
}
// Active layers of the TPC from 60-80 cm (outer layers)
for (int ilayer = n_maps_layer + n_intt_layer + n_tpc_layer_inner + n_tpc_layer_mid; ilayer < (n_maps_layer + n_intt_layer + n_tpc_layer_inner + n_tpc_layer_mid + n_tpc_layer_outer); ++ilayer)
{
if (verbosity)
cout << "Create TPC gas layer " << ilayer << " with inner radius " << radius << " cm "
<< " thickness " << tpc_layer_thick_outer - 0.01 << " length " << cage_length << endl;
cyl = new PHG4CylinderSubsystem("SVTX", ilayer);
cyl->set_double_param("radius", radius);
cyl->set_int_param("lengthviarapidity", 0);
cyl->set_double_param("length", cage_length);
cyl->set_string_param("material", tpcgas.c_str());
cyl->set_double_param("thickness", tpc_layer_thick_outer - 0.01);
cyl->SetActive();
cyl->SuperDetector("SVTX");
g4Reco->registerSubsystem(cyl);
radius += tpc_layer_thick_outer;
}
// outer field cage
cyl = new PHG4CylinderSubsystem("SVTXSUPPORT", n_maps_layer + n_intt_layer + n_gas_layer);
cyl->set_double_param("radius", radius);
cyl->set_int_param("lengthviarapidity", 0);
cyl->set_double_param("length", cage_length);
cyl->set_string_param("material", "G4_KAPTON");
cyl->set_double_param("thickness", cage_thickness); // Kapton X_0 = 28.6 cm
cyl->SuperDetector("SVTXSUPPORT");
g4Reco->registerSubsystem(cyl);
radius += cage_thickness;
return radius;
}
double Magnet(PHG4Reco* g4Reco,
double radius,
const int crossings = 0,
const int absorberactive = 0,
int verbosity = 0) {
double magnet_inner_cryostat_wall_radius = 142;
double magnet_inner_cryostat_wall_thickness = 1;
double magnet_outer_cryostat_wall_radius = 174.5;
double magnet_outer_cryostat_wall_thickness = 2.5;
double magnet_coil_radius = 150.8;
double magnet_coil_thickness = 9.38;
double magnet_length = 379.;
double coil_length = 361.5;
if (radius > magnet_inner_cryostat_wall_radius) {
cout << "inconsistency: radius: " << radius
<< " larger than Magnet inner radius: " << magnet_inner_cryostat_wall_radius << endl;
gSystem->Exit(-1);
}
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
radius = magnet_inner_cryostat_wall_radius;
PHG4CylinderSubsystem *cyl = new PHG4CylinderSubsystem("MAGNET", 0);
cyl->SetRadius(magnet_inner_cryostat_wall_radius);
cyl->SetLengthViaRapidityCoverage(false);
cyl->SetLength(magnet_length);
cyl->SetMaterial("Al5083"); // use 1 radiation length Al for magnet thickness
cyl->SetThickness(magnet_inner_cryostat_wall_thickness);
cyl->SuperDetector("MAGNET");
if (absorberactive) cyl->SetActive();
g4Reco->registerSubsystem( cyl );
cyl = new PHG4CylinderSubsystem("MAGNET", 1);
cyl->SetRadius(magnet_coil_radius);
cyl->SetLengthViaRapidityCoverage(false);
cyl->SetLength(coil_length);
cyl->SetMaterial("Al5083"); // use 1 radiation length Al for magnet thickness
cyl->SetThickness(magnet_coil_thickness);
cyl->SuperDetector("MAGNET");
if (absorberactive) cyl->SetActive();
g4Reco->registerSubsystem( cyl );
cyl = new PHG4CylinderSubsystem("MAGNET", 2);
cyl->SetRadius(magnet_outer_cryostat_wall_radius);
cyl->SetLengthViaRapidityCoverage(false);
cyl->SetLength(magnet_length);
cyl->SetMaterial("Al5083"); // use 1 radiation length Al for magnet thickness
cyl->SetThickness(magnet_outer_cryostat_wall_thickness);
cyl->SuperDetector("MAGNET");
if (absorberactive) cyl->SetActive();
g4Reco->registerSubsystem( cyl );
radius = magnet_outer_cryostat_wall_radius + magnet_outer_cryostat_wall_thickness; // outside of magnet
if (verbosity > 0) {
cout << "========================= G4_Magnet.C::Magnet() ===========================" << endl;
cout << " MAGNET Material Description:" << endl;
cout << " inner radius = " << magnet_inner_cryostat_wall_radius << " cm" << endl;
cout << " outer radius = " << magnet_outer_cryostat_wall_radius + magnet_outer_cryostat_wall_thickness << " cm" << endl;
cout << " length = " << magnet_length << " cm" << endl;
cout << "===========================================================================" << endl;
}
radius += no_overlapp;
return radius;
}
int G4Setup(const int absorberactive = 0,
const string &field ="1.5",
const EDecayType decayType = TPythia6Decayer::kAll,
const bool do_svtx = true,
const bool do_preshower = false,
const bool do_cemc = true,
const bool do_hcalin = true,
const bool do_magnet = true,
const bool do_hcalout = true,
const bool do_pipe = true,
const bool do_bbc = true,
const bool do_FEMC = false,
const bool do_FHCAL = false,
const float magfield_rescale = 1.0) {
//---------------
// Load libraries
//---------------
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
//---------------
// Fun4All server
//---------------
Fun4AllServer *se = Fun4AllServer::instance();
PHG4Reco* g4Reco = new PHG4Reco();
g4Reco->set_rapidity_coverage(1.1); // according to drawings
if (decayType != TPythia6Decayer::kAll) {
g4Reco->set_force_decay(decayType);
}
double fieldstrength;
istringstream stringline(field);
stringline >> fieldstrength;
if (stringline.fail()) { // conversion to double fails -> we have a string
if (field.find("sPHENIX.root") != string::npos) {
g4Reco->set_field_map(field, 1);
} else {
g4Reco->set_field_map(field, 2);
}
} else {
g4Reco->set_field(fieldstrength); // use const soleniodal field
}
g4Reco->set_field_rescale(magfield_rescale);
double radius = 0.;
//----------------------------------------
// PIPE
if (do_pipe) radius = Pipe(g4Reco, radius, absorberactive);
//----------------------------------------
// SVTX
if (do_svtx) radius = Svtx(g4Reco, radius, absorberactive);
//----------------------------------------
// PRESHOWER
if (do_preshower) radius = PreShower(g4Reco, radius, absorberactive);
//----------------------------------------
// CEMC
//
if (do_cemc) radius = CEmc(g4Reco, radius, 8, absorberactive);
// if (do_cemc) radius = CEmc_Vis(g4Reco, radius, 8, absorberactive);// for visualization substructure of SPACAL, slow to render
//----------------------------------------
// HCALIN
if (do_hcalin) radius = HCalInner(g4Reco, radius, 4, absorberactive);
//----------------------------------------
// MAGNET
if (do_magnet) radius = Magnet(g4Reco, radius, 0, absorberactive);
//----------------------------------------
// HCALOUT
if (do_hcalout) radius = HCalOuter(g4Reco, radius, 4, absorberactive);
//----------------------------------------
// FEMC
if ( do_FEMC )
FEMCSetup(g4Reco, absorberactive);
//----------------------------------------
// FHCAL
if ( do_FHCAL )
FHCALSetup(g4Reco, absorberactive);
// sPHENIX forward flux return(s)
PHG4CylinderSubsystem *flux_return_plus = new PHG4CylinderSubsystem("FWDFLUXRET", 0);
flux_return_plus->SetLength(10.2);
flux_return_plus->SetPosition(0,0,335.9);
flux_return_plus->SetRadius(5.0);
flux_return_plus->SetLengthViaRapidityCoverage(false);
flux_return_plus->SetThickness(263.5-5.0);
flux_return_plus->SetMaterial("G4_Fe");
flux_return_plus->SetActive(false);
flux_return_plus->SuperDetector("FLUXRET_ETA_PLUS");
flux_return_plus->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem(flux_return_plus);
PHG4CylinderSubsystem *flux_return_minus = new PHG4CylinderSubsystem("FWDFLUXRET", 0);
flux_return_minus->SetLength(10.2);
flux_return_minus->SetPosition(0,0,-335.9);
flux_return_minus->SetRadius(5.0);
flux_return_minus->SetLengthViaRapidityCoverage(false);
flux_return_minus->SetThickness(263.5-5.0);
flux_return_minus->SetMaterial("G4_Fe");
flux_return_minus->SetActive(false);
flux_return_minus->SuperDetector("FLUXRET_ETA_MINUS");
flux_return_minus->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem(flux_return_minus);
//----------------------------------------
// BLACKHOLE
// swallow all particles coming out of the backend of sPHENIX
PHG4CylinderSubsystem *blackhole = new PHG4CylinderSubsystem("BH", 1);
blackhole->SetRadius(radius + 10); // add 10 cm
blackhole->SetLengthViaRapidityCoverage(false);
blackhole->SetLength(g4Reco->GetWorldSizeZ() - no_overlapp); // make it cover the world in length
blackhole->BlackHole();
blackhole->SetThickness(0.1); // it needs some thickness
blackhole->SetActive(); // always see what leaks out
blackhole->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem(blackhole);
//----------------------------------------
// FORWARD BLACKHOLEs
// +Z
blackhole = new PHG4CylinderSubsystem("BH_FORWARD_PLUS", 1);
blackhole->SuperDetector("BH_FORWARD_PLUS");
blackhole->SetRadius(0); // add 10 cm
blackhole->SetLengthViaRapidityCoverage(false);
blackhole->SetLength(0.1); // make it cover the world in length
blackhole->SetPosition(0,0, g4Reco->GetWorldSizeZ()/2. - 0.1 - no_overlapp);
blackhole->BlackHole();
blackhole->SetThickness(radius - no_overlapp); // it needs some thickness
blackhole->SetActive(); // always see what leaks out
blackhole->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem(blackhole);
blackhole = new PHG4CylinderSubsystem("BH_FORWARD_NEG", 1);
blackhole->SuperDetector("BH_FORWARD_NEG");
blackhole->SetRadius(0); // add 10 cm
blackhole->SetLengthViaRapidityCoverage(false);
blackhole->SetLength(0.1); // make it cover the world in length
blackhole->SetPosition(0,0, - g4Reco->GetWorldSizeZ()/2. +0.1 + no_overlapp);
blackhole->BlackHole();
blackhole->SetThickness(radius - no_overlapp); // it needs some thickness
blackhole->SetActive(); // always see what leaks out
blackhole->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem(blackhole);
PHG4TruthSubsystem *truth = new PHG4TruthSubsystem();
g4Reco->registerSubsystem(truth);
se->registerSubsystem( g4Reco );
}
double Svtx(PHG4Reco* g4Reco, double radius,
const int absorberactive = 0,
int verbosity = 0) {
float svtx_inner_radius = 2.71;
if (radius > svtx_inner_radius) {
cout << "inconsistency: radius: " << radius
<< " larger than SVTX inner radius: " << svtx_inner_radius << endl;
gSystem->Exit(-1);
}
//---------------
// Load libraries
//---------------
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
PHG4CylinderSubsystem *cyl;
//======================================================================================================
// The thicknesses from Yasuyuki on June 12, 2014 are as follows:
// For Si 1mm = 1.07% X_0
// For Cu 1mm = 6.96% X_0
// The thickness of the tracking layers is:
// Pixels: 1.3% X_0 (0.21% sensor + 1.07% support) sensor = 200 mc Si, support = 154 mc Cu
// Stripixel: 5% X_0 (0.67% sensor + 4.3% support) sensor = 624 mc Si, support = 618 mc Cu
// Outer strips: 2% X_0 (conservative) (0.34% sensor + 1.66% support) sensor = 320 mc Si, support = 238 mc Cu
//=======================================================================================================
double si_thickness[7] = {0.02, 0.02, 0.032, 0.032, 0.032, 0.032, 0.032};
double svxrad[7] = {svtx_inner_radius, 4.63, 9.5, 10.5, 44.5, 45.5, 80.0}; // provides 98 MeV Upsilon resolution
// Thicknesses (in % X_0) of 1.3,1.3,2.7/2,2.7/2,2.0/2,2.0/2,2.0 - YA's most conservative case
double support_thickness[7] = {0.0154, 0.0154, 0.0338/2.0, 0.0338/2.0, 0.0238/2.0, 0.0238/2.0, 0.0238};
double length[7] = {20., 20., -1, -1., - 1., - 1., -1}; // -1 use eta coverage to determine length
// here is our silicon:
double inner_radius = radius;
for (int ilayer = Min_si_layer; ilayer <= Max_si_layer; ilayer++)
{
cyl = new PHG4CylinderSubsystem("SVTX", ilayer);
radius = svxrad[ilayer];
// protect against installing layer with radius < inner radius from argument
if (radius < inner_radius)
{
cout << "current radius " << radius << " smaller than inner radius "
<< inner_radius << endl;
gSystem->Exit(-1);
}
cyl->set_double_param("radius",radius);
if (length[ilayer] > 0)
{
cyl->set_int_param("lengthviarapidity",0);
cyl->set_double_param("length",length[ilayer]);
}
else
{
cyl->set_int_param("lengthviarapidity",1);
}
cyl->set_string_param("material","G4_Si");
cyl->set_double_param("thickness",si_thickness[ilayer]);
cyl->SetActive();
cyl->SuperDetector("SVTX");
g4Reco->registerSubsystem( cyl );
radius += si_thickness[ilayer] + no_overlapp;
cyl = new PHG4CylinderSubsystem("SVTXSUPPORT", ilayer);
cyl->set_double_param("radius",radius);
if (length[ilayer] > 0)
{
cyl->set_int_param("lengthviarapidity",0);
cyl->set_double_param("length",length[ilayer]);
}
else
{
cyl->set_int_param("lengthviarapidity",1);
}
cyl->set_string_param("material","G4_Cu");
cyl->set_double_param("thickness",support_thickness[ilayer]);
if (absorberactive) cyl->SetActive();
cyl->SuperDetector("SVTXSUPPORT");
g4Reco->registerSubsystem( cyl );
}
if (ilayer != (Max_si_layer+1)) // coming out of the loop, layer is layer+1
{
cout << "layer number mismatch for Max_si_layer, Max_si_layer "
<< Max_si_layer << " should be " << ilayer << endl;
gSystem->Exit(-1);
}
radius += support_thickness[Max_si_layer] + no_overlapp;
if (verbosity > 0) {
cout << "============================ G4_Svtx.C::Svtx() ============================" << endl;
cout << " SVTX Material Description:" << endl;
for (int ilayer = Min_si_layer; ilayer <= Max_si_layer; ilayer++) {
cout << " layer " << ilayer
<< " radius " << svxrad[ilayer]
<< " zlength " << length[ilayer]
<< " thickness (Si) " << si_thickness[ilayer]
<< " support thickness (Cu) " << support_thickness[ilayer]
<< endl;
}
cout << "===========================================================================" << endl;
}
return radius;
}
double Svtx(PHG4Reco* g4Reco, double radius,
const int absorberactive = 0,
int verbosity = 0) {
float svtx_inner_radius = 2.335; // based on the ALICE ITS (same beam pipe as ours)
if (radius > svtx_inner_radius) {
cout << "inconsistency: radius: " << radius
<< " larger than SVTX inner radius: " << svtx_inner_radius << endl;
gSystem->Exit(-1);
}
PHG4CylinderSubsystem *cyl;
// silicon layers ------------------------------------------------------------
// inner pixels are a copy of the MAPS ITS inner layers
// outer strips are from YA at the Santa Fe Tracking Workshop 10/27/2015
// see: https://indico.bnl.gov/conferenceDisplay.py?confId=1364
// The updated thicknesses from Yasuyuki are as follows:
// For Si 1mm = 1.07% X_0
// For Cu 1mm = 6.96% X_0
// The thickness of the tracking layers is:
// 0 MAPS: 0.3% X_0 (0.053% sensor + 0.247% support) sensor = 50 mc Si, support = 35 mc Cu
// 1 MAPS: 0.3% X_0 (0.053% sensor + 0.247% support) sensor = 50 mc Si, support = 35 mc Cu
// 2 MAPS: 0.3% X_0 (0.053% sensor + 0.247% support) sensor = 50 mc Si, support = 35 mc Cu
double si_thickness[3] = {0.0050, 0.0050, 0.0050};
double svxrad[3] = {svtx_inner_radius, 3.132, 3.904};
double support_thickness[3] = {0.0035, 0.0035, 0.0035};
double length[3] = {27., 27., 27.};
for (int ilayer=0;ilayer<n_svx_layer;++ilayer) {
cyl = new PHG4CylinderSubsystem("SVTX", ilayer);
radius = svxrad[ilayer];
cyl->SetRadius(radius);
cyl->SetLength( length[ilayer] );
cyl->SetMaterial("G4_Si");
cyl->SetThickness( si_thickness[ilayer] );
cyl->SetActive();
cyl->SuperDetector("SVTX");
g4Reco->registerSubsystem( cyl );
radius += si_thickness[ilayer] + no_overlapp;
cyl = new PHG4CylinderSubsystem("SVTXSUPPORT", ilayer);
cyl->SetRadius(radius);
cyl->SetLength( length[ilayer] );
cyl->SetMaterial("G4_Cu");
cyl->SetThickness( support_thickness[ilayer] );
cyl->SuperDetector("SVTXSUPPORT");
g4Reco->registerSubsystem( cyl );
}
// time projection chamber layers --------------------------------------------
double inner_cage_radius = 30.;
string tpcgas = "G4_Ar";
radius = inner_cage_radius;
double n_rad_length_cage = 1.0e-02;
double cage_length = 400.;
double cage_thickness = 1.43 * n_rad_length_cage;
cyl = new PHG4CylinderSubsystem("SVTXSUPPORT", 3);
cyl->SetRadius(radius);
cyl->SetLength(cage_length);
cyl->SetMaterial("G4_Cu");
cyl->SetThickness( cage_thickness ); // Cu X_0 = 1.43 cm
cyl->SuperDetector("SVTXSUPPORT");
g4Reco->registerSubsystem( cyl );
radius += cage_thickness;
double outer_radius = 80.;
int npoints = Max_si_layer - n_svx_layer;
double delta_radius = ( outer_radius - cage_thickness - radius )/( (double)npoints );
for(int ilayer=n_svx_layer;ilayer<(2+npoints);++ilayer) {
cyl = new PHG4CylinderSubsystem("SVTX", ilayer);
cyl->SetRadius(radius);
cyl->SetLength( cage_length );
cyl->SetMaterial(tpcgas.c_str());
cyl->SetThickness( delta_radius - 0.01 );
cyl->SetActive();
cyl->SuperDetector("SVTX");
g4Reco->registerSubsystem( cyl );
radius += delta_radius;
}
cyl = new PHG4CylinderSubsystem("SVTXSUPPORT", 2+npoints);
cyl->SetRadius(radius);
cyl->SetLength(cage_length);
cyl->SetMaterial("G4_Cu");
cyl->SetThickness( cage_thickness ); // Cu X_0 = 1.43 cm
cyl->SuperDetector("SVTXSUPPORT");
g4Reco->registerSubsystem( cyl );
radius += cage_thickness;
return radius;
}
//! Jin Huang <*****@*****.**> : Fully tuned for ePHENIX LOI setup
void
G4Setup(const int absorberactive = 0, const float field = -1.)
{
//---------------
// Load libraries
//---------------
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
//---------------
// Fun4All server
//---------------
Fun4AllServer *se = Fun4AllServer::instance();
PHG4Reco* g4Reco = new PHG4Reco();
g4Reco->set_rapidity_coverage(1.1); // temperary value assigned by ePHENIX LOI
if (field < 0)
{
const char * map =
"/direct/phenix+WWW/p/draft/jinhuang/sPHENIX/ePHENIX/BABAR_V11_GridOut_ePHENIX.SF7.root";
cout << "G4Setup - Using ePHENIX LOI field map ";
cout << map;
cout << endl;
g4Reco->set_field_map(map, 2);
}
else
{
g4Reco->set_field(field); // use const soleniodal field
}
/////////////////////////////////////////////////
// Beam Pipe
/////////////////////////////////////////////////
PHG4CylinderSubsystem *beamcyl;
beamcyl = new PHG4CylinderSubsystem("BEAMPIPE", 1);
beamcyl->SetRadius(2.0);
beamcyl->SetThickness(0.1);
beamcyl->SetLengthViaRapidityCoverage(false);
beamcyl->SetLength(g4Reco->GetWorldSizeZ() - 10.); //g4Reco->GetWorldSizeZ()); // go through our entire world in z directions
beamcyl->SetMaterial("G4_Be");
// beamcyl->SetPosition(0, 0, 250);
// if (absorberactive) beamcyl->SetActive();
beamcyl->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem(beamcyl);
/////////////////////////////////////////////////
// Central magnet and detectors
/////////////////////////////////////////////////
PHG4CylinderSubsystem *cyl;
double magnet_inner_radius = 140;
double magnet_outer_radius = 173;
double magnet_thickness = magnet_outer_radius - magnet_inner_radius;
double emc_inner_radius = 95.; // emc inner radius from engineering spreadsheet
double hcal_in_inner_radius = magnet_outer_radius + 15.; // inner hcal inner radius from engineering spreadsheet
double hcal_out_inner_radius = hcal_in_inner_radius + 30.; // inner hcal inner radius from engineering spreadsheet
double preshower_inner_radius = 90.;
double tpc_inner_radius = 15.;
double tpc_outer_radius = 80.;
double tpc_thickness = tpc_outer_radius - tpc_inner_radius;
int ilayer = -1; // just to declare this varialbe outside of detector setups
double radius = tpc_inner_radius;
radius = Tpc(g4Reco, radius, tpc_thickness, absorberactive);
//
radius = G4_DIRC(g4Reco);
if (radius > emc_inner_radius - 4.)
{
cout << "inconsistency: " << radius << " larger than emc inner radius: "
<< emc_inner_radius - 4. << endl;
gSystem->Exit(-1);
}
// inside CEmc now...
//radius = emc_inner_radius - 4.;
//cyl = new PHG4CylinderSubsystem("EMCELECTRONICS", 0);
//cyl->SetRadius(radius);
//cyl->SetMaterial("G4_TEFLON"); // plastic
//cyl->SetThickness(0.5);
//if (absorberactive)
// cyl->SetActive();
//cyl->OverlapCheck(overlapcheck);
//g4Reco->registerSubsystem(cyl);
radius = emc_inner_radius;
int ncross = 4;
radius = CEmc(g4Reco, radius, ncross, absorberactive);
double saveradius = radius + no_overlapp;
// double al_radlen = 8.897;
// radius = magnet_inner_radius + magnet_thickness/2. - al_radlen/2.;
// magnet (1 radlen Al = 8.897cm - pdg)
// located half way between inner and outer radius
radius = magnet_inner_radius;
cyl = new PHG4CylinderSubsystem("MAGNET", 0);
cyl->SetRadius(radius);
cyl->SetLengthViaRapidityCoverage(false);
cyl->SetLength(385.0);
cyl->SetMaterial("AL_BABAR_MAG"); // use 1 radiation length Al for magnet thickness
cyl->SetThickness(magnet_thickness);
cyl->OverlapCheck(overlapcheck);
if (absorberactive)
cyl->SetActive();
g4Reco->registerSubsystem(cyl);
// radius = magnet_inner_radius + magnet_thickness; // outside of magnet
//
// radius += 10;
// if (radius > hcal_in_inner_radius)
// {
// cout << "inconsistency: magnet radius+thickness: " << radius
// << " larger than emc inner radius: " << hcal_in_inner_radius << endl;
// gSystem->Exit(-1);
// }
// radius = hcal_in_inner_radius;
// ncross = 3;
// radius = HCal(g4Reco, radius, ncross, absorberactive);
//radius += 60;
cout <<"G4Setup - loading updated HCal setup"<<endl;
ncross = 4;
radius = HCal(g4Reco, saveradius, ncross, absorberactive);
/////////////////////////////////////////////////
// Build hadron going detectors
/////////////////////////////////////////////////
// tracker
G4_FGEM_ePHENIX(g4Reco, N_forward_sector, Min_forward_eta);
// RICH
G4_RICH(g4Reco, N_forward_sector, Min_forward_eta_RICH);
//AeroGel
G4_AeroGel(g4Reco, N_forward_sector, Min_forward_eta);
// ECal
G4_FEmc(g4Reco); // 17cm thick Pb/Sci calorimeter = 20 X0
// HCal
G4_FHCal(g4Reco); // ForwardHcal detector Geant4 module
PHG4ConeSubsystem *bbc = new PHG4ConeSubsystem("BBC", 0);
bbc->SetZlength(2);
bbc->SetPlaceZ(325);
bbc->Set_eta_range(4, 5);
bbc->SetMaterial("G4_Pyrex_Glass");
bbc->SetActive();
bbc->SuperDetector("BBC");
bbc->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem(bbc);
/////////////////////////////////////////////////
// electron going detectors
/////////////////////////////////////////////////
G4_EEmc( g4Reco ); // 18cm thick PbWO4 crystal calorimeter
G4_eGEM_ePHENIX(g4Reco);
PHG4TruthSubsystem *truth = new PHG4TruthSubsystem();
g4Reco->registerSubsystem(truth);
se->registerSubsystem(g4Reco);
}
int G4Setup(const int absorberactive = 0,
const string &field ="1.5",
#if ROOT_VERSION_CODE >= ROOT_VERSION(6,00,0)
const EDecayType decayType = EDecayType::kAll,
#else
const EDecayType decayType = TPythia6Decayer::kAll,
#endif
const bool do_tracking = true,
const bool do_pstof = true,
const bool do_cemc = true,
const bool do_hcalin = true,
const bool do_magnet = true,
const bool do_hcalout = true,
const bool do_pipe = true,
const bool do_plugdoor = false,
// const bool do_plugdoor = true,
const float magfield_rescale = 1.0) {
//---------------
// Load libraries
//---------------
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
//---------------
// Fun4All server
//---------------
Fun4AllServer *se = Fun4AllServer::instance();
// read-in HepMC events to Geant4 if there is any
HepMCNodeReader *hr = new HepMCNodeReader();
se->registerSubsystem(hr);
PHG4Reco* g4Reco = new PHG4Reco();
g4Reco->set_rapidity_coverage(1.1); // according to drawings
// uncomment to set QGSP_BERT_HP physics list for productions
// (default is QGSP_BERT for speed)
// g4Reco->SetPhysicsList("QGSP_BERT_HP");
#if ROOT_VERSION_CODE >= ROOT_VERSION(6,00,0)
if (decayType != EDecayType::kAll)
#else
if (decayType != TPythia6Decayer::kAll)
#endif
{
g4Reco->set_force_decay(decayType);
}
double fieldstrength;
istringstream stringline(field);
stringline >> fieldstrength;
if (stringline.fail()) { // conversion to double fails -> we have a string
if (field.find("sPHENIX.root") != string::npos) {
g4Reco->set_field_map(field, PHFieldConfig::Field3DCartesian);
} else {
g4Reco->set_field_map(field, PHFieldConfig::kField2D);
}
} else {
g4Reco->set_field(fieldstrength); // use const soleniodal field
}
g4Reco->set_field_rescale(magfield_rescale);
double radius = 0.;
//----------------------------------------
// PIPE
if (do_pipe) radius = Pipe(g4Reco, radius, absorberactive);
//----------------------------------------
// TRACKING
if (do_tracking) radius = Tracking(g4Reco, radius, absorberactive);
//----------------------------------------
// PSTOF
if (do_pstof) radius = PSTOF(g4Reco, radius, absorberactive);
//----------------------------------------
// CEMC
//
if (do_cemc) radius = CEmc(g4Reco, radius, 8, absorberactive);
// if (do_cemc) radius = CEmc_Vis(g4Reco, radius, 8, absorberactive);// for visualization substructure of SPACAL, slow to render
//----------------------------------------
// HCALIN
if (do_hcalin) radius = HCalInner(g4Reco, radius, 4, absorberactive);
//----------------------------------------
// MAGNET
if (do_magnet) radius = Magnet(g4Reco, radius, 0, absorberactive);
//----------------------------------------
// HCALOUT
if (do_hcalout) radius = HCalOuter(g4Reco, radius, 4, absorberactive);
//----------------------------------------
// sPHENIX forward flux return door
if (do_plugdoor) PlugDoor(g4Reco, absorberactive);
//----------------------------------------
// BLACKHOLE
// swallow all particles coming out of the backend of sPHENIX
PHG4CylinderSubsystem *blackhole = new PHG4CylinderSubsystem("BH", 1);
blackhole->set_double_param("radius",radius + 10); // add 10 cm
blackhole->set_int_param("lengthviarapidity",0);
blackhole->set_double_param("length",g4Reco->GetWorldSizeZ() - no_overlapp); // make it cover the world in length
blackhole->BlackHole();
blackhole->set_double_param("thickness",0.1); // it needs some thickness
blackhole->SetActive(); // always see what leaks out
blackhole->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem(blackhole);
//----------------------------------------
// FORWARD BLACKHOLEs
// +Z
blackhole = new PHG4CylinderSubsystem("BH_FORWARD_PLUS", 1);
blackhole->SuperDetector("BH_FORWARD_PLUS");
blackhole->set_double_param("radius",0); // add 10 cm
blackhole->set_int_param("lengthviarapidity",0);
blackhole->set_double_param("length",0.1); // make it cover the world in length
blackhole->set_double_param("place_z",g4Reco->GetWorldSizeZ()/2. - 0.1 - no_overlapp);
blackhole->BlackHole();
blackhole->set_double_param("thickness",radius - no_overlapp); // it needs some thickness
blackhole->SetActive(); // always see what leaks out
blackhole->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem(blackhole);
blackhole = new PHG4CylinderSubsystem("BH_FORWARD_NEG", 1);
blackhole->SuperDetector("BH_FORWARD_NEG");
blackhole->set_double_param("radius",0); // add 10 cm
blackhole->set_int_param("lengthviarapidity",0);
blackhole->set_double_param("length",0.1); // make it cover the world in length
blackhole->set_double_param("place_z", - g4Reco->GetWorldSizeZ()/2. +0.1 + no_overlapp);
blackhole->BlackHole();
blackhole->set_double_param("thickness",radius - no_overlapp); // it needs some thickness
blackhole->SetActive(); // always see what leaks out
blackhole->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem(blackhole);
PHG4TruthSubsystem *truth = new PHG4TruthSubsystem();
g4Reco->registerSubsystem(truth);
se->registerSubsystem( g4Reco );
return 0;
}
double Pipe(PHG4Reco* g4Reco,
double radius,
const int absorberactive = 0,
int verbosity = 0) {
double be_pipe_radius = 2.16; // 2.16 cm based on spec sheet
double be_pipe_thickness = 0.0760; // 760 um based on spec sheet
double be_pipe_length = 80.0; // +/- 40 cm
double al_pipe_radius = 2.16; // same as Be pipe
double al_pipe_thickness = 0.1600; // 1.6 mm based on spec
double al_pipe_length = 88.3; // extension beyond +/- 40 cm
if (radius > be_pipe_radius) {
cout << "inconsistency: radius: " << radius
<< " larger than pipe inner radius: " << be_pipe_radius << endl;
gSystem->Exit(-1);
}
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
// mid-rapidity beryillium pipe
PHG4CylinderSubsystem *cyl = new PHG4CylinderSubsystem("BE_PIPE", 0);
cyl->SetRadius(be_pipe_radius);
cyl->SetLengthViaRapidityCoverage(false);
cyl->SetLength(be_pipe_length);
cyl->SetMaterial("G4_Be");
cyl->SetThickness(be_pipe_thickness);
cyl->SuperDetector("PIPE");
if (absorberactive) cyl->SetActive();
g4Reco->registerSubsystem( cyl );
// north aluminum pipe
cyl = new PHG4CylinderSubsystem("N_AL_PIPE", 1);
cyl->SetPosition(0.0,0.0,0.5*be_pipe_length+0.5*al_pipe_length+no_overlapp);
cyl->SetRadius(al_pipe_radius);
cyl->SetLengthViaRapidityCoverage(false);
cyl->SetLength(al_pipe_length);
cyl->SetMaterial("G4_Al");
cyl->SetThickness(al_pipe_thickness);
cyl->SuperDetector("PIPE");
if (absorberactive) cyl->SetActive();
g4Reco->registerSubsystem( cyl );
// south aluminum pipe
cyl = new PHG4CylinderSubsystem("S_AL_PIPE", 2);
cyl->SetPosition(0.0,0.0,-0.5*be_pipe_length-0.5*al_pipe_length-no_overlapp);
cyl->SetRadius(al_pipe_radius);
cyl->SetLengthViaRapidityCoverage(false);
cyl->SetLength(al_pipe_length);
cyl->SetMaterial("G4_Al");
cyl->SetThickness(al_pipe_thickness);
cyl->SuperDetector("PIPE");
if (absorberactive) cyl->SetActive();
g4Reco->registerSubsystem( cyl );
radius = be_pipe_radius + be_pipe_thickness;
if (verbosity > 0) {
cout << "=========================== G4_Pipe.C::Pipe() =============================" << endl;
cout << " PIPE Material Description:" << endl;
cout << " inner radius = " << be_pipe_radius << " cm" << endl;
cout << " thickness = " << be_pipe_thickness << " cm" << endl;
cout << " outer radius = " << be_pipe_radius + be_pipe_thickness << " cm" << endl;
cout << " length = " << be_pipe_length << " cm" << endl;
cout << "===========================================================================" << endl;
}
radius += no_overlapp;
return radius;
}
//! Babar DIRC (Without most of support structure)
//! Ref: I. Adam et al. The DIRC particle identification system for the BaBar experiment.
//! Nucl. Instrum. Meth., A538:281-357, 2005. doi:10.1016/j.nima.2004.08.129.
double
DIRCSetup(PHG4Reco* g4Reco)
{
const double radiator_R = 83.65;
const double length = 470;
const double z_shift = -115;
const double z_start = z_shift + length / 2.;
const double z_end = z_shift - length / 2.;
PHG4SectorSubsystem *dirc;
dirc = new PHG4SectorSubsystem("DIRC");
dirc->get_geometry().set_normal_polar_angle(3.14159265358979323846/2);
dirc->get_geometry().set_normal_start(
83.65 * PHG4Sector::Sector_Geometry::Unit_cm());
dirc->get_geometry().set_min_polar_angle(atan2(radiator_R, z_start));
dirc->get_geometry().set_max_polar_angle(atan2(radiator_R, z_end));
dirc->get_geometry().set_min_polar_edge(PHG4Sector::Sector_Geometry::FlatEdge());
dirc->get_geometry().set_max_polar_edge(PHG4Sector::Sector_Geometry::FlatEdge());
dirc->get_geometry().set_material("Quartz");
dirc->get_geometry().set_N_Sector(12);
dirc->OverlapCheck(overlapcheck);
dirc->get_geometry().AddLayer("Radiator", "Quartz",
1.7 * PHG4Sector::Sector_Geometry::Unit_cm(), true);
g4Reco->registerSubsystem(dirc);
PHG4CylinderSubsystem *cyl;
// The cylinder skins provide most of the strength
// and stiffness of the CST. The thickness of the inner
// and outer skins is 1.27 and 0.76 mm, respectively
// Inner skin:
cyl = new PHG4CylinderSubsystem("DIRC_CST_Inner_Skin", 10);
cyl->set_double_param("radius",81.71);
cyl->set_int_param("lengthviarapidity",0);
cyl->set_double_param("length",length);
cyl->set_string_param("material","G4_Al");
cyl->set_double_param("thickness",0.127);
cyl->set_double_param("place_x",0.);
cyl->set_double_param("place_y",0.);
cyl->set_double_param("place_z",z_shift);
cyl->SetActive(0);
cyl->SuperDetector("DIRC");
cyl->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem(cyl);
// Outer skin:
cyl = new PHG4CylinderSubsystem("DIRC_CST_Outer_Skin", 11);
cyl->set_double_param("radius",89.25 - 0.076);
cyl->set_int_param("lengthviarapidity",0);
cyl->set_double_param("length",length);
cyl->set_string_param("material","G4_Al");
cyl->set_double_param("thickness",0.076);
cyl->set_double_param("place_x",0.);
cyl->set_double_param("place_y",0.);
cyl->set_double_param("place_z",z_shift);
cyl->SetActive(0);
cyl->SuperDetector("DIRC");
cyl->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem(cyl);
// Done
return 89.25;
}
double Svtx(PHG4Reco* g4Reco,
double radius,
const int absorberactive = 0,
int verbosity = 0)
{
float svtx_inner_radius = 2.3;
if (radius > svtx_inner_radius) {
cout << "inconsistency: radius: " << radius
<< " larger than SVTX inner radius: " << svtx_inner_radius << endl;
gSystem->Exit(-1);
}
//---------------
// Load libraries
//---------------
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
PHG4CylinderSubsystem *cyl;
//======================================================================================================
// The thicknesses from Yasuyuki on June 12, 2014 are as follows:
// For Si 1mm = 1.07% X_0
// For Cu 1mm = 6.96% X_0
// The thickness of the tracking layers is:
// Pixels: 1.3% X_0 (0.21% sensor + 1.07% support) sensor = 200 mc Si, support = 154 mc Cu
// Stripixel: 5% X_0 (0.67% sensor + 4.3% support) sensor = 624 mc Si, support = 618 mc Cu
// Outer strips: 2% X_0 (conservative) (0.34% sensor + 1.66% support) sensor = 320 mc Si, support = 238 mc Cu
//=======================================================================================================
//double svxrad[7] = {2.3, 3.2, 3.9, 19.6, 24.5, 34.4, 39.3}; // ALICE ITS upgrade layer radii in cm
double svxrad[7] = {svtx_inner_radius, 3.2, 3.9, 19.6, 24.5, 34.4, 64.0}; // ALICE ITS upgrade with outer layer pushed out
double si_thickness[7] = {0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005}; // ALICE ITS upgrade Si thickness is 50 microns
double length[7] = {27.0, 27.0, 27.0, 88.0, 88.0, 148.0, 148.0}; // ALICE ladder lengths (stave - 2cm)
// ALICE ITS total thickness (% of X_0 of 0.3, 0.3, 0.3, 0.8, 0.8, 0.8, 0.8
// Pixel chip thickness of 50 um (% of X_0 of 0.05 x 1.07 = 0.053%) in all layers
// so inner 3 layers support thickness = 0.3 - 0.053 = 0.25%, outer 4 layers = 0.8 - 0.053 = 0.75%
// Support thickness equivalent for Cu in inner layer = 0.25%/6.96% x 1 mm = 0.036 mm = 0.0036 cm
// Support thickness equivalent for Cu in outer layer = 0.75%/6.96% x 1 mm = 0.108 mm = 0.0108 cm
double support_thickness[7] = {0.0036, 0.0036, 0.0036, 0.0108, 0.0108, 0.0108, 0.0108};
// here is our silicon:
double inner_radius = radius;
for (int ilayer = Min_si_layer; ilayer <= Max_si_layer; ilayer++)
{
cyl = new PHG4CylinderSubsystem("SVTX", ilayer);
radius = svxrad[ilayer];
// protect against installing layer with radius < inner radius from argument
if (radius < inner_radius)
{
cout << "current radius " << radius << " smaller than inner radius "
<< inner_radius << endl;
gSystem->Exit(-1);
}
cyl->set_double_param("radius",radius);
if (length[ilayer] > 0)
{
cyl->set_int_param("lengthviarapidity",0);
cyl->set_double_param("length",length[ilayer]);
}
else
{
cyl->set_int_param("lengthviarapidity",1);
}
cyl->set_string_param("material","G4_Si");
cyl->set_double_param("thickness",si_thickness[ilayer]);
cyl->SetActive();
cyl->SuperDetector("SVTX");
g4Reco->registerSubsystem( cyl );
radius += si_thickness[ilayer] + no_overlapp;
cyl = new PHG4CylinderSubsystem("SVTXSUPPORT", ilayer);
cyl->set_double_param("radius",radius);
if (length[ilayer] > 0)
{
cyl->set_int_param("lengthviarapidity",0);
cyl->set_double_param("length",length[ilayer]);
}
else
{
cyl->set_int_param("lengthviarapidity",1);
}
cyl->set_string_param("material","G4_Cu");
cyl->set_double_param("thickness",support_thickness[ilayer]);
if (absorberactive) cyl->SetActive();
cyl->SuperDetector("SVTXSUPPORT");
g4Reco->registerSubsystem( cyl );
}
if (ilayer != (Max_si_layer+1)) // coming out of the loop, layer is layer+1
{
cout << "layer number mismatch for Max_si_layer, Max_si_layer "
<< Max_si_layer << " should be " << ilayer << endl;
gSystem->Exit(-1);
}
radius += support_thickness[Max_si_layer] + no_overlapp;
if (verbosity > 0) {
cout << "========================== G4_Svtx_ITS.C::Svtx() ==========================" << endl;
cout << " SVTX Material Description: " << endl;
for (int ilayer = Min_si_layer; ilayer <= Max_si_layer; ilayer++) {
cout << " layer " << ilayer
<< " radius " << svxrad[ilayer]
<< " zlength " << length[ilayer]
<< " thickness (Si) " << si_thickness[ilayer]
<< " support thickness (Cu) " << support_thickness[ilayer]
<< endl;
}
cout << "===========================================================================" << endl;
}
return radius;
}
double Svtx(PHG4Reco* g4Reco, double radius,
const int absorberactive = 0,
int verbosity = 0)
{
//---------------
// Load libraries
//---------------
gSystem->Load("libg4detectors.so");
gSystem->Load("libg4testbench.so");
//---------------------------------
// Inner Cylinder layers for pixels
//---------------------------------
PHG4CylinderSubsystem *cyl;
//======================================================================================================
// The thicknesses from Yasuyuki on June 12, 2014 are as follows:
// For Si 1mm = 1.07% X_0
// For Cu 1mm = 6.96% X_0
// The thickness of the tracking layers is:
// Pixels: 1.3% X_0 (0.21% sensor + 1.07% support) sensor = 200 mc Si, support = 154 mc Cu
//=======================================================================================================
double si_thickness[2] = {0.02, 0.02};
double svxrad[2] = {2.71, 4.63};
double support_thickness[2] = {0.0154, 0.0154};
double length[2] = {20., 20.};
// here is our silicon:
double inner_radius = radius;
for (int ilayer = Min_si_layer; ilayer < 2; ilayer++)
{
cyl = new PHG4CylinderSubsystem("SVTX", ilayer);
cyl->Verbosity(verbosity);
radius = svxrad[ilayer];
// protect against installing layer with radius < inner radius from argument
if (radius < inner_radius)
{
cout << "current radius " << radius << " smaller than inner radius "
<< inner_radius << endl;
gSystem->Exit(-1);
}
cyl->set_double_param("radius",radius);
if (length[ilayer] > 0)
{
cyl->set_int_param("lengthviarapidity",0);
cyl->set_double_param("length",length[ilayer]);
}
else
{
cyl->set_int_param("lengthviarapidity",1);
}
cyl->set_string_param("material","G4_Si");
cyl->set_double_param("thickness",si_thickness[ilayer]);
cyl->SetActive();
cyl->SuperDetector("SVTX");
g4Reco->registerSubsystem( cyl );
radius += si_thickness[ilayer] + no_overlapp;
cyl = new PHG4CylinderSubsystem("SVTXSUPPORT", ilayer);
cyl->Verbosity(verbosity);
cyl->set_double_param("radius",radius);
if (length[ilayer] > 0)
{
cyl->set_int_param("lengthviarapidity",0);
cyl->set_double_param("length",length[ilayer]);
}
else
{
cyl->set_int_param("lengthviarapidity",1);
}
cyl->set_string_param("material","G4_Cu");
cyl->set_double_param("thickness",support_thickness[ilayer]);
if (absorberactive) cyl->SetActive();
cyl->SuperDetector("SVTXSUPPORT");
g4Reco->registerSubsystem( cyl );
}
//--------------------------------
// Outer Silicon tracking subsytem
//--------------------------------
bool overlapcheck = false; // set to true if you want to check for overlaps
// instantiate the Silicon tracker subsystem and register it
// We make one instance of PHG4TrackerSubsystem per layer of tracker
// dimensions are in mm, angles are in radians
bool option_double_layer[5] = {false, true, false, true, false};
double layer_radius[5] = {85.0, 85.0, 400.0, 400.0, 800.0};
int N_strips_sensor_phi[5] = {256, 256, 512, 512, 1536};
double radius_stagger[5] = {10.0, 10.0, 10.0, 10.0, 10.0};
int N_staggers[5] = {4, 4, 4, 4, 2};
bool add_lower_roc[5] = {false, false, true, true, true};
double strip_tilt[5] = {0.0156, -0.0156, 0.0156, -0.0156, 0.0}; // radians, usually 1:64 tilt
//double strip_tilt[num_si_layers] = {0.0, 0.0, 0.0, 0.0, 0.0}; // radians, usually 1:64 tilt
for(int ilayer = 2; ilayer <= Max_si_layer; ++ilayer)
{
// PHG4SiliconTrackerSubsystem creates the detetor layer using PHG4SiliconTrackerDetector
// and instantiates the appropriate PHG4SteppingAction
PHG4SiliconTrackerSubsystem *sitrack = new PHG4SiliconTrackerSubsystem("SILICON_TRACKER", ilayer);
sitrack->Verbosity(verbosity);
sitrack->set_nominal_layer_radius(layer_radius[ilayer-2]); // mm
sitrack->set_radius_stagger(radius_stagger[ilayer-2]); // mm
sitrack->set_N_staggers(N_staggers[ilayer-2]);
sitrack->set_N_strips_in_sensor_phi(N_strips_sensor_phi[ilayer-2]);
sitrack->set_strip_tilt(strip_tilt[ilayer-2]); // radians
sitrack->set_option_double_layer(option_double_layer[ilayer-2]);
sitrack->set_add_lower_roc(add_lower_roc[ilayer-2]);
sitrack->SetActive();
sitrack->OverlapCheck(overlapcheck);
g4Reco->registerSubsystem( sitrack);
}
// report roughly our outer radius marker (translation back to cm)
return layer_radius[4]*0.1+radius_stagger[4]*0.1;
}
