Import Geant4 6.2.0 source tree

This commit is contained in:
Gabriele Cosmo
2016-06-09 10:56:29 +02:00
parent 1d812b78b1
commit e083ffb441
1415 changed files with 111223 additions and 21207 deletions
@@ -0,0 +1,174 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISAAnalysisManager class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
#ifdef G4ANALYSIS_USE
#include "LISAAnalysisManager.hh"
#include <strstream>
#include "globals.hh"
LISAAnalysisManager* LISAAnalysisManager::instance = 0;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
LISAAnalysisManager::LISAAnalysisManager() :
af(0),
tf(0),
run_tree(0),
run_tpf(0),
run_tuple(0)
{;}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
LISAAnalysisManager::~LISAAnalysisManager() {
if(af) {
delete tf;
G4cout << " LISAAnalysis -- deleted tree factory" << G4endl;
delete af;
G4cout << " LISAAnalysis -- deleted analysis factory" << G4endl;
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
LISAAnalysisManager* LISAAnalysisManager::getInstance() {
if (!instance) instance = new LISAAnalysisManager();
return instance;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void LISAAnalysisManager::Dispose() {
if(instance) {
delete instance;
instance = 0;
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void LISAAnalysisManager::Init() {
G4cout << G4endl << "******* Analysis with AIDA 3.0 *********" << G4endl;
// create analysis factory
if( (af = AIDA_createAnalysisFactory()) )
G4cout << " LISAAnalysis -- created analysis factory" << G4endl;
// create tree factory
if( (tf = af->createTreeFactory()) )
G4cout << " LISAAnalysis -- created tree factory" << G4endl;
}
//
// RUN ANALYSIS **************************************************************
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void LISAAnalysisManager::bookRun(G4String hbookfile) {
// create RunTree
G4bool fileExists = false;
G4bool readOnly = false;
run_tree = tf->create(hbookfile, "hbook", readOnly, fileExists);
G4cout << " LISAAnalysis -- tree store: " << run_tree->storeName()<<G4endl;
// create TupleFactory
run_tpf = af->createTupleFactory(*run_tree );
G4cout << " LISAAnalysis -- created NTuple factory" << G4endl;
// Run Information
run_tuple = run_tpf->create( "1", "Run Tuple",
"float evt,tm,energy,charge,in,out,seed1,seed2");
assert(run_tuple);
G4cout << " LISAAnalysis -- created Run NTuple" << G4endl;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void LISAAnalysisManager::FinishRun() {
// Committing transaction with the tree
G4cout << " LISAAnalysis -- committing run_tree..." << G4endl;
run_tree->commit();
run_tree->close();
delete run_tpf;
delete run_tree;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void LISAAnalysisManager::analyseRun(G4int evt, G4int tm, G4double energy,
G4int charge, G4int in, G4int out, long seed1, long seed2) {
AIDA::ITuple* ntuple = dynamic_cast<AIDA::ITuple *> ( run_tree->find("1") );
// Fill the ntuple
ntuple->fill( ntuple->findColumn( "evt" ), (float) evt );
ntuple->fill( ntuple->findColumn( "tm" ), (float) tm );
ntuple->fill( ntuple->findColumn( "energy" ), (float) energy );
ntuple->fill( ntuple->findColumn( "charge" ), (float) charge );
ntuple->fill( ntuple->findColumn( "in" ), (float) in );
ntuple->fill( ntuple->findColumn( "out" ), (float) out );
ntuple->fill( ntuple->findColumn( "seed1" ), (float) seed1 );
ntuple->fill( ntuple->findColumn( "seed2" ), (float) seed2 );
// Values of attributes are prepared; store them to the nTuple:
ntuple->addRow();
}
#endif
@@ -0,0 +1,90 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISADetectorConstruction class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
// **************************************************************************
// Colours and VisAttributes
//***************************************************************************
// edge colour attributes
G4VisAttributes* white_vat = new G4VisAttributes(G4Colour(1.0, 1.0, 1.0));
G4VisAttributes* grey_vat = new G4VisAttributes(G4Colour(0.5, 0.5, 0.5));
G4VisAttributes* black_vat = new G4VisAttributes(G4Colour(0.0, 0.0, 0.0));
G4VisAttributes* red_vat = new G4VisAttributes(G4Colour(1.0, 0.0, 0.0));
G4VisAttributes* orange_vat = new G4VisAttributes(G4Colour(1.0, 0.5, 0.0));
G4VisAttributes* yellow_vat = new G4VisAttributes(G4Colour(1.0, 1.0, 0.0));
G4VisAttributes* gold_vat = new G4VisAttributes(G4Colour(.75, .75, 0.0));
G4VisAttributes* green_vat = new G4VisAttributes(G4Colour(0.0, 1.0, 0.0));
G4VisAttributes* lgreen_vat = new G4VisAttributes(G4Colour(0.0, .75, 0.0));
G4VisAttributes* cyan_vat = new G4VisAttributes(G4Colour(0.0, 1.0, 1.0));
G4VisAttributes* lblue_vat = new G4VisAttributes(G4Colour(0.0, 0.0, .75));
G4VisAttributes* blue_vat = new G4VisAttributes(G4Colour(0.0, 0.0, 1.0));
G4VisAttributes* magenta_vat = new G4VisAttributes(G4Colour(1.0, 0.0, 1.0));
// solid colour attributes
G4VisAttributes* sol_white_vat = new G4VisAttributes(G4Colour(1.0,1.0,1.0));
sol_white_vat->SetForceSolid(true);
G4VisAttributes* sol_grey_vat = new G4VisAttributes(G4Colour(0.5,0.5,0.5));
sol_grey_vat->SetForceSolid(true);
G4VisAttributes* sol_dgrey_vat = new G4VisAttributes(G4Colour(.25,.25,.25));
sol_dgrey_vat->SetForceSolid(true);
G4VisAttributes* sol_black_vat = new G4VisAttributes(G4Colour(0.0,0.0,0.0));
sol_black_vat->SetForceSolid(true);
G4VisAttributes* sol_red_vat = new G4VisAttributes(G4Colour(1.0,0.0,0.0));
sol_red_vat->SetForceSolid(true);
G4VisAttributes* sol_green_vat = new G4VisAttributes(G4Colour(0.0,1.0,0.0));
sol_green_vat->SetForceSolid(true);
G4VisAttributes* sol_lgreen_vat = new G4VisAttributes(G4Colour(0.0,.75,0.0));
sol_lgreen_vat->SetForceSolid(true);
G4VisAttributes* sol_lblue_vat = new G4VisAttributes(G4Colour(0.0,0.0,.75));
sol_lblue_vat->SetForceSolid(true);
G4VisAttributes* sol_cyan_vat = new G4VisAttributes(G4Colour(0.0,1.0,1.0));
sol_cyan_vat->SetForceSolid(true);
G4VisAttributes* sol_blue_vat = new G4VisAttributes(G4Colour(0.0,0.0,1.0));
sol_blue_vat->SetForceSolid(true);
G4VisAttributes* sol_gold_vat = new G4VisAttributes(G4Colour(.75,.75,0.0));
sol_gold_vat->SetForceSolid(true);
G4VisAttributes* sol_yellow_vat = new G4VisAttributes(G4Colour(1.0,1.0,0.0));
sol_yellow_vat->SetForceSolid(true);
G4VisAttributes* sol_orange_vat = new G4VisAttributes(G4Colour(1.0,0.5,0.0));
sol_orange_vat->SetForceSolid(true);
//*****************************************************************************
@@ -0,0 +1,229 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISADetectorConstruction class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
#include "LISADetectorConstruction.hh"
#include "LISADetectorMaterials.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
LISADetectorConstruction::LISADetectorConstruction() {;}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
LISADetectorConstruction::~LISADetectorConstruction() {;}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4VPhysicalVolume* LISADetectorConstruction::Construct() {
// material definitions
ConstructMaterials();
// build it
return ConstructDetector();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4VPhysicalVolume* LISADetectorConstruction::ConstructDetector() {
// Edge and solid colour attributes
#include "LISAColours.icc"
//***************************************************************************
// world
//***************************************************************************
G4double wld_len = 3000.*mm;
G4Tubs* truewld_sol =
new G4Tubs("truewld_box", 0., 0.5*wld_len, 0.5*wld_len, 0., 360.*deg);
G4LogicalVolume* truewld_log =
new G4LogicalVolume(truewld_sol, vacuum, "truewld_log");
G4VPhysicalVolume* truewld_phys = new G4PVPlacement(0, G4ThreeVector(),
"truewld_phys", truewld_log, NULL, false, 0);
truewld_log->SetVisAttributes(G4VisAttributes::Invisible);
// allow spacecraft rotation
G4RotationMatrix wld_rot; wld_rot.rotateZ(0.*deg);
G4Tubs* wld_sol =
new G4Tubs("wld_box", 0., 0.49*wld_len, 0.5*wld_len, 0., 360.*deg);
G4LogicalVolume* wld_log =
new G4LogicalVolume(wld_sol, vacuum, "wld_log");
G4VPhysicalVolume* wld_phys = new G4PVPlacement(G4Transform3D(wld_rot,
G4ThreeVector()), "wld_phys", wld_log, truewld_phys, false, 0);
// wld_log->SetVisAttributes(white_vat);
wld_log->SetVisAttributes(G4VisAttributes::Invisible);
// Probe volume
// uncomment code in LISASteppingAction.cc to count hits
// G4Sphere* probe_sol =
// new G4Sphere("probe_sol", 0., 100.*mm, 0., 360.*deg, 0., 180.*deg);
// G4LogicalVolume* probe_log =
// new G4LogicalVolume(probe_sol, vacuum, "probe_log");
// G4VPhysicalVolume* probe_phys =
// new G4PVPlacement(0, G4ThreeVector(0*mm,0*mm,0*mm),
// "probe_phys", probe_log, wld_phys, false, 0);
// probe_log->SetVisAttributes(sol_white_vat);
//**************************************************************************
// Science Module Structure (SMS)
//**************************************************************************
// Primary Structure
// Lower Deck
// Upper Deck
// Thermal Shield
// Solar Array
// Optical Surface Reflectors (OSR)
// Radiator Panels
//**************************************************************************
// position of science module spacecraft in world volume
G4ThreeVector spacecraft_pos(0.*mm,0.*mm,0.*mm);
#include "LISAScienceModuleStructures.icc"
//***************************************************************************
// Interferometer Assembly
//***************************************************************************
// Payload Shield (Y Tube)
// Telescope Light Shields
// Telescope Electronics Mounting
// Telescope Mirrors Mounting
// Telescope Actuator Mechanism
// Optical Bench Mounting
// Optical Bench
//***************************************************************************
// position of payload shields in spacecraft
G4double YTube_xoff = -800.*mm;
// position of interferometer in Y-tubes
G4RotationMatrix tel_rot1; tel_rot1.rotateY(210.*deg);
G4ThreeVector tel_pos1(+319.*mm, 0.*mm, 920.*mm);
G4RotationMatrix tel_rot2; tel_rot2.rotateY(150.*deg);
G4ThreeVector tel_pos2(-319.*mm, 0.*mm, 920.*mm);
// position of optical bench along Y-tube
G4double OpticalBench_off = 0.0*mm;
#include "LISAInterferometerAssembly.icc"
//***************************************************************************
// Sensor Vacuum Housing
// Modified to contain LTP Inertial Sensor and Caging Mechanism
//***************************************************************************
G4RotationMatrix IS_rot; IS_rot.rotateX(90.*deg); IS_rot.rotateY(90.*deg);
#include "LISASensorHousing.icc"
//***************************************************************************
// LTP Caging Mechanism
//***************************************************************************
//#include "LISACagingMechanism.icc"
//***************************************************************************
// Inertial Sensors: YZ-Injection, 46 mm Test Mass
// Design adopted for LTP/SMART-2: Report LTP-RT-CGS-001, issue 2
//***************************************************************************
#include "LISAInertialSensor.icc"
// Sensor Region (cuts 250 eV)
G4Region* ISensor = new G4Region(G4String("sensor"));
cage_o_log->SetRegion(ISensor);
ISensor->AddRootLogicalVolume(cage_o_log);
//***************************************************************************
// Electronics Boxes
//***************************************************************************
#include "LISAElectronicsBoxes.icc"
//***************************************************************************
// Support Systems
//***************************************************************************
// Star Trackers
// FEEP Thrusters
// Communications Antennas
//***************************************************************************
#include "LISASupportSystems.icc"
// ......................................................................
// attach user limits ...................................................
// reduce step size in electrodes
// goldplating_log->SetUserLimits (new G4UserLimits(30.*nanometer));
// return
return truewld_phys;
}
@@ -0,0 +1,462 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISADetectorConstruction class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
//***************************************************************************
// Electronics Boxes
//***************************************************************************
// Lower Deck electronics
G4double EB_zoff = -230.*mm;
G4ThreeVector EPC1_pos(-680*mm, +580*mm, EB_zoff+0.5*110.*mm);
G4ThreeVector EPC2_pos(-680*mm, -580*mm, EB_zoff+0.5*110.*mm);
G4ThreeVector GyroPack_pos(+150*mm, +980*mm, EB_zoff+0.5* 85.*mm);
G4ThreeVector InstConE1_pos(+720*mm, -190*mm, EB_zoff+0.5*180.*mm);
G4ThreeVector InstConE2_pos(+720*mm, +190*mm, EB_zoff+0.5*180.*mm);
G4ThreeVector RFDU_pos( +30*mm,-1000*mm, EB_zoff+0.5* 80.*mm);
G4ThreeVector StarTrack3_pos(+450*mm, -850*mm, EB_zoff+0.5* 54.*mm);
G4ThreeVector StarTrack4_pos(+450*mm, +850*mm, EB_zoff+0.5* 54.*mm);
G4ThreeVector STElec1_pos( +30*mm, -720*mm, EB_zoff+0.5*100.*mm);
G4ThreeVector STElec2_pos(-280*mm, -900*mm, EB_zoff+0.5*100.*mm);
G4ThreeVector STElec3_pos(-280*mm, +900*mm, EB_zoff+0.5*100.*mm);
G4ThreeVector STElec4_pos( +30*mm, +720*mm, EB_zoff+0.5*100.*mm);
G4ThreeVector TWT1_pos(-730*mm, +350*mm, EB_zoff+0.5* 36.*mm);
G4ThreeVector TWT2_pos(-730*mm, -350*mm, EB_zoff+0.5* 36.*mm);
G4ThreeVector UVBox1_pos(+180*mm, 0, EB_zoff+0.5* 70.*mm);
G4ThreeVector UVBox2_pos(+480*mm, 0, EB_zoff+0.5* 70.*mm);
// Upper Deck electronics
EB_zoff = 220.*mm;
G4ThreeVector PCDU_pos(-770*mm, +600*mm, EB_zoff-0.5*300.*mm);
G4ThreeVector CentELCPS_pos(-780*mm, -570*mm, EB_zoff-0.5*115.*mm);
G4ThreeVector CentEL2_pos(-250*mm,-1000*mm, EB_zoff-0.5*284.*mm);
G4ThreeVector FEEPEL1_pos(-250*mm,+1000*mm, EB_zoff-0.5*200.*mm);
G4ThreeVector FEEPEL2_pos(+270*mm,+1020*mm, EB_zoff-0.5*200.*mm);
G4ThreeVector HGADrive1_pos( 20*mm,-1210*mm, EB_zoff-0.5*100.*mm);
G4ThreeVector HGADrive2_pos( 20*mm,+1210*mm, EB_zoff-0.5*100.*mm);
G4ThreeVector InterfelEL1_pos(1030*mm, -180*mm, EB_zoff-0.5*150.*mm);
G4ThreeVector InterfelEL2_pos(1030*mm, +180*mm, EB_zoff-0.5*150.*mm);
G4ThreeVector LaserEL1_pos(+720*mm, -220*mm, EB_zoff-0.5*100.*mm);
G4ThreeVector LaserEL2_pos(+720*mm, +220*mm, EB_zoff-0.5*100.*mm);
G4ThreeVector LaserHead1_pos(1100*mm, -400*mm, EB_zoff-0.5* 5.*mm);
G4ThreeVector LaserHead2_pos(1010*mm, -480*mm, EB_zoff-0.5* 50.*mm);
G4ThreeVector LaserHead3_pos(1100*mm, +400*mm, EB_zoff-0.5* 50.*mm);
G4ThreeVector LaserHead4_pos(1010*mm, +480*mm, EB_zoff-0.5* 50.*mm);
G4ThreeVector StarTrack1_pos(+650*mm,+1050*mm, EB_zoff-0.5* 54.*mm);
G4ThreeVector StarTrack2_pos(+650*mm,-1050*mm, EB_zoff-0.5* 54.*mm);
G4ThreeVector Transpond2_pos(+270*mm,-1050*mm, EB_zoff-0.5*178.*mm);
// rotations
G4RotationMatrix EB_rot1; EB_rot1.rotateZ(+30.*deg);
G4RotationMatrix EB_rot2; EB_rot2.rotateZ(-30.*deg);
G4RotationMatrix EB_rot3; EB_rot3.rotateZ(+60.*deg);
G4RotationMatrix EB_rot4; EB_rot4.rotateZ(-60.*deg);
G4double f;
// Each box is made from solid Al6061 from which a volume
// f times smaller is removed to match assigned mass;
// Lower Deck electronics
G4Box* EPC_box_o = new G4Box("EPC_box_o",
0.5*227.*mm, 0.5*63.*mm, 0.5*110.*mm);
G4LogicalVolume* EPC_log_o = new G4LogicalVolume
(EPC_box_o, Al6061, "EPC_log_o");
G4VPhysicalVolume* EPC_phys_o;
EPC_phys_o = new G4PVPlacement(0, spacecraft_pos + EPC1_pos,
"EPC_phys_o", EPC_log_o, wld_phys, false, 0);
EPC_phys_o = new G4PVPlacement(0, spacecraft_pos + EPC2_pos,
"EPC_phys_o", EPC_log_o, wld_phys, false, 1);
f = pow(1.-1.4/(2.70*227*63*110)*1E6, 1./3.);
// G4cout << "f: " << f << G4endl;
G4Box* EPC_box_i = new G4Box("EPC_box_i",
f*0.5*227.*mm, f*0.5*63.*mm, f*0.5*110.*mm);
G4LogicalVolume* EPC_log_i = new G4LogicalVolume
(EPC_box_i, vacuum, "EPC_log_i");
G4VPhysicalVolume* EPC_phys_i = new G4PVPlacement
(0, 0, "EPC_phys_i", EPC_log_i, EPC_phys_o, false, 0);
//
//
G4Tubs* GyroPack_tub_o = new G4Tubs("GyroPack_tub_o",
0., 0.5*89.*mm, 0.5*85.*mm, 0., 360.*deg);
G4LogicalVolume* GyroPack_log_o = new G4LogicalVolume
(GyroPack_tub_o, Al6061, "GyroPack_log_o");
G4VPhysicalVolume* GyroPack_phys_o = new G4PVPlacement(0, spacecraft_pos
+ GyroPack_pos, "GyroPack_phys_o", GyroPack_log_o, wld_phys, false, 0);
f = pow(1.-1.00/(2.70*M_PI*(0.5*89.)*(0.5*89.)*85.)*1E6, 1./3.);
// G4cout << "f: " << f << G4endl;
G4Tubs* GyroPack_tub_i = new G4Tubs("GyroPack_tub_i",
0., f*0.5*89.*mm, f*0.5*85.*mm, 0., 360.*deg);
G4LogicalVolume* GyroPack_log_i = new G4LogicalVolume
(GyroPack_tub_i, vacuum, "GyroPack_log_i");
G4VPhysicalVolume* GyroPack_phys_i = new G4PVPlacement(0, 0,
"GyroPack_phys_i", GyroPack_log_i, GyroPack_phys_o, false, 0);
//
//
G4Box* InstConE_box_o = new G4Box("InstConE_box_o",
0.5*250.*mm, 0.5*180.*mm, 0.5*180.*mm);
G4LogicalVolume* InstConE_log_o = new G4LogicalVolume
(InstConE_box_o, Al6061, "InstConE_log_o");
G4VPhysicalVolume* InstConE_phys_o;
InstConE_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot1, spacecraft_pos + InstConE1_pos),
"InstConE_phys_o", InstConE_log_o, wld_phys, false, 0);
InstConE_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot2, spacecraft_pos + InstConE2_pos),
"InstConE_phys_o", InstConE_log_o, wld_phys, false, 1);
f = pow(1.-4.5/(2.70*250*180*180)*1E6, 1./3.);
G4Box* InstConE_box_i = new G4Box("InstConE_box_i",
f*0.5*250.*mm, f*0.5*180.*mm, f*0.5*180.*mm);
G4LogicalVolume* InstConE_log_i = new G4LogicalVolume
(InstConE_box_i, vacuum, "InstConE_log_i");
G4VPhysicalVolume* InstConE_phys_i = new G4PVPlacement
(0, 0, "InstConE_phys_i", InstConE_log_i, InstConE_phys_o, false, 0);
//
//
G4Box* RFDU_box_o = new G4Box("RFDU_box_o",
0.5*160.*mm, 0.5*60.*mm, 0.5*80.*mm);
G4LogicalVolume* RFDU_log_o = new G4LogicalVolume
(RFDU_box_o, Al6061, "RFDU_log_o");
G4VPhysicalVolume* RFDU_phys_o = new G4PVPlacement(0, spacecraft_pos
+ RFDU_pos, "RFDU_phys_o", RFDU_log_o, wld_phys, false, 0);
f = pow(1.-1.0/(2.70*160*60*80)*1E6, 1./3.);
G4Box* RFDU_box_i = new G4Box("RFDU_box_i",
f*0.5*160.*mm, f*0.5*60.*mm, f*0.5*80.*mm);
G4LogicalVolume* RFDU_log_i = new G4LogicalVolume
(RFDU_box_i, vacuum, "RFDU_log_i");
G4VPhysicalVolume* RFDU_phys_i = new G4PVPlacement
(0, 0, "RFDU_phys_i", RFDU_log_i, RFDU_phys_o, false, 0);
//
//
G4Box* StarTrack_L_box_o = new G4Box("StarStrack_box_o",
0.5*50.*mm, 0.5*50.*mm, 0.5*54.*mm);
G4LogicalVolume* StarTrack_L_log_o = new G4LogicalVolume
(StarTrack_L_box_o, Al6061, "StarTrack_log_o");
G4VPhysicalVolume* StarTrack_L_phys_o;
StarTrack_L_phys_o = new G4PVPlacement(0, spacecraft_pos + StarTrack3_pos,
"STarTrack3_phys_o", StarTrack_L_log_o, wld_phys, false, 0);
StarTrack_L_phys_o = new G4PVPlacement(0, spacecraft_pos + StarTrack4_pos,
"STarTrack4_phys_o", StarTrack_L_log_o, wld_phys, false, 1);
f = pow(1.-0.30/(2.70*50*50*54)*1E6, 1./3.);
G4Box* StarTrack_L_box_i = new G4Box("StarTrack_L_box_i",
f*0.5*50.*mm, f*0.5*50.*mm, f*0.5*54.*mm);
G4LogicalVolume* StarTrack_L_log_i = new G4LogicalVolume
(StarTrack_L_box_i, vacuum, "StarTrack_L_log_i");
G4VPhysicalVolume* StarTrack_L_phys_i = new G4PVPlacement
(0,0,"StarTrack_L_phys_i",StarTrack_L_log_i,StarTrack_L_phys_o,false,0);
//
//
G4Box* STElec_box_o = new G4Box("STElec_box_o",
0.5*100.*mm, 0.5*100.*mm, 0.5*100.*mm);
G4LogicalVolume* STElec_log_o = new G4LogicalVolume
(STElec_box_o, Al6061, "STElec_log_o");
G4VPhysicalVolume* STElec_phys_o;
STElec_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot1, spacecraft_pos + STElec1_pos),
"STElec_phys_o", STElec_log_o, wld_phys, false, 0);
STElec_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot1, spacecraft_pos + STElec2_pos),
"STElec_phys_o", STElec_log_o, wld_phys, false, 1);
STElec_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot2, spacecraft_pos + STElec3_pos),
"STElec_phys_o", STElec_log_o, wld_phys, false, 2);
STElec_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot2, spacecraft_pos + STElec4_pos),
"STElec_phys_o", STElec_log_o, wld_phys, false, 3);
f = pow(1.-2.0/(2.70*100*100*100)*1E6, 1./3.);
G4Box* STElec_box_i = new G4Box("STElec_box_i",
f*0.5*100.*mm, f*0.5*100.*mm, f*0.5*100.*mm);
G4LogicalVolume* STElec_log_i = new G4LogicalVolume
(STElec_box_i, vacuum, "STElec_log_i");
G4VPhysicalVolume* STElec_phys_i = new G4PVPlacement
(0, 0, "STElec_phys_i", STElec_log_i, STElec_phys_o, false, 0);
//
//
G4Box* TWT_box_o = new G4Box("TWT_box_o",
0.5*321.*mm, 0.5*58.*mm, 0.5*36.*mm);
G4LogicalVolume* TWT_log_o = new G4LogicalVolume
(TWT_box_o, Al6061, "TWT_log_o");
G4VPhysicalVolume* TWT_phys_o;
TWT_phys_o = new G4PVPlacement(0, spacecraft_pos + TWT1_pos,
"TWT_phys_o", TWT_log_o, wld_phys, false, 0);
TWT_phys_o = new G4PVPlacement(0, spacecraft_pos + TWT2_pos,
"TWT_phys_o", TWT_log_o, wld_phys, false, 1);
f = pow(1.-0.75/(2.70*321*58*36)*1E6, 1./3.);
G4Box* TWT_box_i = new G4Box("TWT_box_i",
f*0.5*321.*mm, f*0.5*58.*mm, f*0.5*36.*mm);
G4LogicalVolume* TWT_log_i = new G4LogicalVolume
(TWT_box_i, vacuum, "TWT_log_i");
G4VPhysicalVolume* TWT_phys_i = new G4PVPlacement
(0, 0, "TWT_phys_i", TWT_log_i, TWT_phys_o, false, 0);
//
//
G4Box* UVBox_box_o = new G4Box("UVBox_box_o",
0.5*150.*mm, 0.5*100.*mm, 0.5*70.*mm);
G4LogicalVolume* UVBox_log_o = new G4LogicalVolume
(UVBox_box_o, Al6061, "UVBox_log_o");
G4VPhysicalVolume* UVBox_phys_o;
UVBox_phys_o = new G4PVPlacement(0, spacecraft_pos + UVBox1_pos,
"UVBox_phys_o", UVBox_log_o, wld_phys, false, 0);
UVBox_phys_o = new G4PVPlacement(0, spacecraft_pos + UVBox2_pos,
"UVBox_phys_o", UVBox_log_o, wld_phys, false, 1);
f = pow(1.-0.50/(2.70*150*100*70)*1E6, 1./3.);
G4Box* UVBox_box_i = new G4Box("UVBox_box_i",
f*0.5*150.*mm, f*0.5*100.*mm, f*0.5*70.*mm);
G4LogicalVolume* UVBox_log_i = new G4LogicalVolume
(UVBox_box_i, vacuum, "UVBox_log_i");
G4VPhysicalVolume* UVBox_phys_i = new G4PVPlacement
(0, 0, "UVBox_phys_i", UVBox_log_i, UVBox_phys_o, false, 0);
// Upper Deck electronics
G4Box* PCDU_box_o = new G4Box("PCDU_box_o",
0.5*200.*mm, 0.5*350.*mm, 0.5*300.*mm);
G4LogicalVolume* PCDU_log_o = new G4LogicalVolume
(PCDU_box_o, Al6061, "PCDU_log_o");
G4VPhysicalVolume* PCDU_phys_o = new G4PVPlacement(0, spacecraft_pos
+ PCDU_pos, "PCDU_phys_o", PCDU_log_o, wld_phys, false, 0);
f = pow(1.-15.90/(2.70*200*350*300)*1E6, 1./3.);
G4Box* PCDU_box_i = new G4Box("PCDU_box_i",
f*0.5*200.*mm, f*0.5*350.*mm, f*0.5*300.*mm);
G4LogicalVolume* PCDU_log_i = new G4LogicalVolume
(PCDU_box_i, vacuum, "PCDU_log_i");
G4VPhysicalVolume* PCDU_phys_i = new G4PVPlacement
(0, 0, "PCDU_phys_i", PCDU_log_i, PCDU_phys_o, false, 0);
//
//
G4Box* CentELCPS_box_o = new G4Box("CentELCPS_box_o",
0.5*240.*mm, 0.5*356.*mm, 0.5*140.*mm);
G4LogicalVolume* CentELCPS_log_o = new G4LogicalVolume
(CentELCPS_box_o, Al6061, "CentELCPS_log_o");
G4VPhysicalVolume* CentELCPS_phys_o = new G4PVPlacement(0, spacecraft_pos
+ CentELCPS_pos, "CentELCPS_phys_o", CentELCPS_log_o, wld_phys, false, 0);
f = pow(1.-15.90/(2.70*240*356*140)*1E6, 1./3.);
G4Box* CentELCPS_box_i = new G4Box("CentELCPS_box_i",
f*0.5*240.*mm, f*0.5*356.*mm, f*0.5*140.*mm);
G4LogicalVolume* CentELCPS_log_i = new G4LogicalVolume
(CentELCPS_box_i, vacuum, "CentELCPS_log_i");
G4VPhysicalVolume* CentELCPS_phys_i = new G4PVPlacement
(0, 0, "CentELCPS_phys_i", CentELCPS_log_i, CentELCPS_phys_o, false, 0);
//
//
G4Box* CentEL2_box_o = new G4Box("CentEL2_box_o",
0.5*220.*mm, 0.5*184.*mm, 0.5*284.*mm);
G4LogicalVolume* CentEL2_log_o = new G4LogicalVolume
(CentEL2_box_o, Al6061, "CentEL2_log_o");
G4VPhysicalVolume* CentEL2_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot3, spacecraft_pos + CentEL2_pos),
"CentEL2_phys_o", CentEL2_log_o, wld_phys, false, 0);
f = pow(1.-15.90/(2.70*220*184*284)*1E6, 1./3.);
G4Box* CentEL2_box_i = new G4Box("CentEL2_box_i",
f*0.5*220.*mm, f*0.5*184.*mm, f*0.5*284.*mm);
G4LogicalVolume* CentEL2_log_i = new G4LogicalVolume
(CentEL2_box_i, vacuum, "CentEL2_log_i");
G4VPhysicalVolume* CentEL2_phys_i = new G4PVPlacement
(0, 0, "CentEL2_phys_i", CentEL2_log_i, CentEL2_phys_o, false, 0);
//
//
G4Box* FEEPEL_box_o = new G4Box("FEEPEL_box_o",
0.5*260.*mm, 0.5*170.*mm, 0.5*200.*mm);
G4LogicalVolume* FEEPEL_log_o = new G4LogicalVolume
(FEEPEL_box_o, Al6061, "FEEPEL_log_o");
G4VPhysicalVolume* FEEPEL_phys_o;
FEEPEL_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot4, spacecraft_pos + FEEPEL1_pos),
"FEEPEL_phys_o", FEEPEL_log_o, wld_phys, false, 0);
FEEPEL_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot1, spacecraft_pos + FEEPEL2_pos),
"FEEPEL_phys_o", FEEPEL_log_o, wld_phys, false, 1);
f = pow(1.-6.50/(2.70*260*170*200)*1E6, 1./3.);
G4Box* FEEPEL_box_i = new G4Box("FEEPEL_box_i",
f*0.5*260.*mm, f*0.5*170.*mm, f*0.5*200.*mm);
G4LogicalVolume* FEEPEL_log_i = new G4LogicalVolume
(FEEPEL_box_i, vacuum, "FEEPEL_log_i");
G4VPhysicalVolume* FEEPEL_phys_i = new G4PVPlacement
(0, 0, "FEEPEL_phys_i", FEEPEL_log_i, FEEPEL_phys_o, false, 0);
//
//
G4Box* HGADrive_box_o = new G4Box("HGADrive_box_o",
0.5*100.*mm, 0.5*100.*mm, 0.5*100.*mm);
G4LogicalVolume* HGADrive_log_o = new G4LogicalVolume
(HGADrive_box_o, Al6061, "HGADrive_log_o");
G4VPhysicalVolume* HGADrive_phys_o;
HGADrive_phys_o = new G4PVPlacement(0, spacecraft_pos + HGADrive1_pos,
"HGADrive_phys_o", HGADrive_log_o, wld_phys, false, 0);
HGADrive_phys_o = new G4PVPlacement(0, spacecraft_pos + HGADrive2_pos,
"HGADrive_phys_o", HGADrive_log_o, wld_phys, false, 1);
f = pow(1.-1.00/(2.70*100*100*100)*1E6, 1./3.);
G4Box* HGADrive_box_i = new G4Box("HGADrive_box_i",
f*0.5*100.*mm, f*0.5*100.*mm, f*0.5*100.*mm);
G4LogicalVolume* HGADrive_log_i = new G4LogicalVolume
(HGADrive_box_i, vacuum, "HGADrive_log_i");
G4VPhysicalVolume* HGADrive_phys_i = new G4PVPlacement
(0, 0, "HGADrive_phys_i", HGADrive_log_i, HGADrive_phys_o, false, 0);
//
//
G4Box* InterfelEL_box_o = new G4Box("InterfelEL_box_o",
0.5*200.*mm, 0.5*200.*mm, 0.5*150.*mm);
G4LogicalVolume* InterfelEL_log_o = new G4LogicalVolume
(InterfelEL_box_o, Al6061, "InterfelEL_log_o");
G4VPhysicalVolume* InterfelEL_phys_o;
InterfelEL_phys_o = new G4PVPlacement(0, spacecraft_pos + InterfelEL1_pos,
"InterfelEL_phys_o", InterfelEL_log_o, wld_phys, false, 0);
InterfelEL_phys_o = new G4PVPlacement(0, spacecraft_pos + InterfelEL2_pos,
"InterfelEL_phys_o", InterfelEL_log_o, wld_phys, false, 1);
f = pow(1.-3.50/(2.70*200*200*150)*1E6, 1./3.);
G4Box* InterfelEL_box_i = new G4Box("InterfelEL_box_i",
f*0.5*200.*mm, f*0.5*200.*mm, f*0.5*150.*mm);
G4LogicalVolume* InterfelEL_log_i = new G4LogicalVolume
(InterfelEL_box_i, vacuum, "InterfelEL_log_i");
G4VPhysicalVolume* InterfelEL_phys_i = new G4PVPlacement(0, 0,
"InterfelEL_phys_i", InterfelEL_log_i, InterfelEL_phys_o, false, 0);
//
//
G4Box* LaserEL_box_o = new G4Box("LaserEL_box_o",
0.5*200.*mm, 0.5*200.*mm, 0.5*100.*mm);
G4LogicalVolume* LaserEL_log_o = new G4LogicalVolume
(LaserEL_box_o, Al6061, "LaserEL_log_o");
G4VPhysicalVolume* LaserEL_phys_o;
LaserEL_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot1, spacecraft_pos + LaserEL1_pos),
"LaserEL_phys_o", LaserEL_log_o, wld_phys, false, 0);
LaserEL_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot2, spacecraft_pos + LaserEL2_pos),
"LaserEL_phys_o", LaserEL_log_o, wld_phys, false, 1);
f = pow(1.-3.00/(2.70*200*200*100)*1E6, 1./3.);
G4Box* LaserEL_box_i = new G4Box("LaserEL_box_i",
f*0.5*200.*mm, f*0.5*200.*mm, f*0.5*100.*mm);
G4LogicalVolume* LaserEL_log_i = new G4LogicalVolume
(LaserEL_box_i, vacuum, "LaserEL_log_i");
G4VPhysicalVolume* LaserEL_phys_i = new G4PVPlacement
(0, 0, "LaserEL_phys_i", LaserEL_log_i, LaserEL_phys_o, false, 0);
//
//
G4Box* LaserHead_box_o = new G4Box("LaserHead_box_o",
0.5*100.*mm, 0.5*100.*mm, 0.5*50.*mm);
G4LogicalVolume* LaserHead_log_o = new G4LogicalVolume
(LaserHead_box_o, Al6061, "LaserHead_log_o");
G4VPhysicalVolume* LaserHead_phys_o;
LaserHead_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot3, spacecraft_pos + LaserHead1_pos),
"LaserHead_phys_o", LaserHead_log_o, wld_phys, false, 0);
LaserHead_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot3, spacecraft_pos + LaserHead2_pos),
"LaserHead_phys_o", LaserHead_log_o, wld_phys, false, 1);
LaserHead_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot4, spacecraft_pos + LaserHead3_pos),
"LaserHead_phys_o", LaserHead_log_o, wld_phys, false, 2);
LaserHead_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot4, spacecraft_pos + LaserHead4_pos),
"LaserHead_phys_o", LaserHead_log_o, wld_phys, false, 3);
f = pow(1.-0.70/(2.70*100*100*50)*1E6, 1./3.);
G4Box* LaserHead_box_i = new G4Box("LaserHead_box_i",
f*0.5*100.*mm, f*0.5*100.*mm, f*0.5*50.*mm);
G4LogicalVolume* LaserHead_log_i = new G4LogicalVolume
(LaserHead_box_i, vacuum, "LaserHead_log_i");
G4VPhysicalVolume* LaserHead_phys_i = new G4PVPlacement
(0, 0, "LaserHead_phys_i", LaserHead_log_i, LaserHead_phys_o, false, 0);
//
//
G4Box* StarTrack_U_box_o = new G4Box("StarStrack_box_o",
0.5*50.*mm, 0.5*50.*mm, 0.5*54.*mm);
G4LogicalVolume* StarTrack_U_log_o = new G4LogicalVolume
(StarTrack_U_box_o, Al6061, "StarTrack_log_o");
G4VPhysicalVolume* StarTrack_U_phys_o;
StarTrack_U_phys_o = new G4PVPlacement(0, spacecraft_pos + StarTrack1_pos,
"STarTrack_phys_o", StarTrack_U_log_o, wld_phys, false, 0);
StarTrack_U_phys_o = new G4PVPlacement(0, spacecraft_pos + StarTrack2_pos,
"STarTrack_phys_o", StarTrack_U_log_o, wld_phys, false, 1);
f = pow(1.-0.30/(2.70*50*50*54)*1E6, 1./3.);
G4Box* StarTrack_U_box_i = new G4Box("StarTrack_U_box_i",
f*0.5*50.*mm, f*0.5*50.*mm, f*0.5*54.*mm);
G4LogicalVolume* StarTrack_U_log_i = new G4LogicalVolume
(StarTrack_U_box_i, vacuum, "StarTrack_U_log_i");
G4VPhysicalVolume* StarTrack_U_phys_i = new G4PVPlacement(0, 0,
"StarTrack_U_phys_i", StarTrack_U_log_i, StarTrack_U_phys_o, false, 0);
//
//
G4Box* Transpond2_box_o = new G4Box("Transpond2_box_o",
0.5*220.*mm, 0.5*184.*mm, 0.5*178.*mm);
G4LogicalVolume* Transpond2_log_o = new G4LogicalVolume
(Transpond2_box_o, Al6061, "Transpond2_log_o");
G4VPhysicalVolume* Transpond2_phys_o = new G4PVPlacement(G4Transform3D
(EB_rot2, spacecraft_pos + Transpond2_pos),
"Transpond2_phys_o", Transpond2_log_o, wld_phys, false, 0);
f = pow(1.-3.50/(2.70*220*184*178)*1E6, 1./3.);
G4Box* Transpond2_box_i = new G4Box("Transpond2_box_i",
f*0.5*220.*mm, f*0.5*184.*mm, f*0.5*178.*mm);
G4LogicalVolume* Transpond2_log_i = new G4LogicalVolume
(Transpond2_box_i, vacuum, "Transpond2_log_i");
G4VPhysicalVolume* Transpond2_phys_i = new G4PVPlacement(0, 0,
"Transpond2_phys_i", Transpond2_log_i, Transpond2_phys_o, false, 0);
// vis Attributes
EPC_log_o->SetVisAttributes(sol_blue_vat);
GyroPack_log_o->SetVisAttributes(sol_blue_vat);
InstConE_log_o->SetVisAttributes(sol_blue_vat);
RFDU_log_o->SetVisAttributes(sol_blue_vat);
StarTrack_L_log_o->SetVisAttributes(sol_blue_vat);
STElec_log_o->SetVisAttributes(sol_blue_vat);
TWT_log_o->SetVisAttributes(sol_blue_vat);
UVBox_log_o->SetVisAttributes(sol_blue_vat);
PCDU_log_o->SetVisAttributes(sol_lblue_vat);
CentELCPS_log_o->SetVisAttributes(sol_lblue_vat);
CentEL2_log_o->SetVisAttributes(sol_lblue_vat);
FEEPEL_log_o->SetVisAttributes(sol_lblue_vat);
HGADrive_log_o->SetVisAttributes(sol_lblue_vat);
InterfelEL_log_o->SetVisAttributes(sol_lblue_vat);
LaserEL_log_o->SetVisAttributes(sol_lblue_vat);
LaserHead_log_o->SetVisAttributes(sol_lblue_vat);
StarTrack_U_log_o->SetVisAttributes(sol_lblue_vat);
Transpond2_log_o->SetVisAttributes(sol_lblue_vat);
// **************************************************************************
@@ -0,0 +1,211 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISAEventAction class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
#include "LISAEventAction.hh"
#include "LISAPrimaryGeneratorAction.hh"
#include "LISASteppingAction.hh"
#ifdef G4ANALYSIS_USE
#include "LISAAnalysisManager.hh"
#endif
#include "G4Event.hh"
#include "G4EventManager.hh"
#include "G4TrajectoryContainer.hh"
#include "G4Trajectory.hh"
#include "G4ParticleDefinition.hh"
#include "G4VVisManager.hh"
#include "G4UImanager.hh"
#include "G4Polyline.hh"
#include "G4Colour.hh"
#include "G4VisAttributes.hh"
#include "G4UnitsTable.hh"
#include "G4ios.hh"
#include <fstream>
#include <iomanip>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
LISAEventAction::LISAEventAction(LISAPrimaryGeneratorAction* generatorAction,
LISASteppingAction* steppingAction)
: genAction(generatorAction),stepAction(steppingAction) {
energy_pri = 0;
charge_in[0] = 0;
charge_in[1] = 0;
charge_out[0] = 0;
charge_out[1] = 0;
charge_tot[0] = 0;
charge_tot[1] = 0;
seeds = NULL;
filename = G4String();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
LISAEventAction::~LISAEventAction() {;}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void LISAEventAction::BeginOfEventAction(const G4Event* evt) {
// reset event charges
stepAction->Discharge();
// grab event seeds
seeds = genAction->GetEventSeeds();
// G4cout << " 1st seed: " << *seeds << G4endl;;
// G4cout << " 2nd seed: " << *(seeds+1) << G4endl;
// HepRandom::showEngineStatus();
// grab energy of primary
energy_pri = genAction->GetEnergyPrimary();
event_id = evt->GetEventID();
if(event_id%1000==0 || (event_id%100==0 && event_id<1000))
G4cout << "\n---> Begin of event: " << event_id << G4endl;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void LISAEventAction::EndOfEventAction(const G4Event* evt) {
// Look at TM0 and TM1
for(int tm=0; tm<=1; ++tm) {
charge_in[tm] = stepAction->GetChargeIn(tm);
charge_out[tm] = stepAction->GetChargeOut(tm);
charge_tot[tm] = charge_in[tm] - charge_out[tm];
// save if changed
if(charge_tot[tm]) {
// printout
G4cout << " *** Evt: " << event_id
<< "\tTM: " << tm
<< "\tE: " << energy_pri
<< "\tQnet: " << charge_tot[tm]
<< "\tQin: " << charge_in[tm]
<< "\tQout: " << charge_out[tm]
<< G4endl;
// append to file
std::ofstream chargefile(filename,std::ios::app);
chargefile << event_id << "\t"
<< tm << "\t"
<< energy_pri << "\t"
<< charge_tot[tm] << "\t"
<< charge_in[tm] << "\t"
<< charge_out[tm] << "\t"
<< *seeds << "\t"
<< *(seeds+1) << "\t"
<< G4endl;
// Write event information to HBOOK NTuple if using analysis
#ifdef G4ANALYSIS_USE
LISAAnalysisManager* analysis = LISAAnalysisManager::getInstance();
analysis->analyseRun(event_id,
tm,
energy_pri,
charge_tot[tm],
charge_in[tm],
charge_out[tm],
*seeds,
*(seeds+1));
#endif
} // if(charge_tot[tm])
} // for(int tm=0; tm<=1; ++tm)
// draw trajectories
// colours by particle type
G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
if(pVVisManager) {
G4TrajectoryContainer* trajectoryContainer = evt->GetTrajectoryContainer();
G4int n_trajectories = 0;
if (trajectoryContainer)
n_trajectories = trajectoryContainer->entries();
for (G4int i=0; i<n_trajectories; i++) {
G4Trajectory* trj = 0;
trj = dynamic_cast<G4Trajectory*>((*trajectoryContainer)[i]);
G4String name = trj->GetParticleDefinition()->GetParticleName();
G4Colour colour = G4Colour(1.0, 1.0, 1.0);
G4Polyline pPolyline;
if (trj) {
for (int i=0; i<trj->GetPointEntries(); i++)
pPolyline.push_back( trj->GetPoint(i)->GetPosition() );
if(name=="proton") colour=G4Colour(0.0, 0.0, 1.0);
else if(name=="alpha") colour=G4Colour(0.0, 0.0, 0.5);
else if(name=="He3") colour=G4Colour(1.0, 0.0, 1.0);
else if(name=="pi+") colour=G4Colour(0.5, 0.5, 0.5);
else if(name=="pi-") colour=G4Colour(0.5, 0.5, 0.5);
else if(name=="e+") colour=G4Colour(0.0, 1.0, 1.0);
else if(name=="e-") colour=G4Colour(1.0, 0.0, 0.0);
else if(name=="gamma") colour=G4Colour(0.0, 1.0, 0.0);
else if(name=="neutron") colour=G4Colour(1.0, 1.0, 0.0);
else colour=G4Colour(1.0, 1.0, 1.0);
G4VisAttributes attribs(colour);
pPolyline.SetVisAttributes(attribs);
if(pVVisManager) pVVisManager->Draw(pPolyline);
} else
G4cerr << "EndOfEventAction: Failed to dynamic cast to G4Trajectory!"
<< G4endl;
}
}
}
@@ -0,0 +1,247 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISADetectorConstruction class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
// **************************************************************************
// Inertial Sensors: YZ-Injection, 46 mm Test Mass
// LISA Inertial Sensor Design Report LTP-RT-CGS-001, issue 2
//***************************************************************************
// Molybdenum cage (electrode housing)
G4double cage_o = 75.0*mm;
G4double cage_i_x = 53.8*mm;
G4double cage_i_y = 51.6*mm;
G4double cage_i_z = 52.8*mm;
// Molybdenum disks (top and bottom)
G4double disk_thi = 3.0*mm;
G4double disk_id = 12.0*mm;
G4double disk_od = 60.0*mm;
G4double disk_off = 0.5*cage_o+0.5*disk_thi;
// SHAPAL electrode supports
G4double elecsupp_x_thi = 6.5*mm;
G4double elecsupp_y_thi = 7.6*mm;
G4double elecsupp_yi_thi = 6.5*mm;
G4double elecsupp_z_thi = 7.0*mm;
G4double elecsupp_zi_thi = 6.5*mm;
// gold plating thickness
G4double elec_thi = 0.300*micrometer;
// electrodes (x faces)
G4double elec_x_xoff = 0.5*cage_i_x + 0.5*elecsupp_x_thi + elec_thi;
G4double elec_x_y = 14.5*mm, elec_x_z = 36.0*mm;
G4double elec_x_yoff = 10.*mm;
// electrodes (y faces)
G4double elec_y_yoff = 0.5*cage_i_y + 0.5*elecsupp_y_thi + elec_thi;
G4double elec_y_x = 38.2*mm, elec_y_z = 7.1*mm;
G4double elec_y_zoff = 15.*mm;
// electrodes (y injection)
G4double elec_yi_yoff = 0.5*cage_i_y + 0.5*elecsupp_yi_thi + elec_thi;
G4double elec_yi_x = 38.2*mm, elec_yi_z = 16.0*mm;
// electrodes (z faces)
G4double elec_z_zoff = 0.5*cage_i_z + 0.5*elecsupp_z_thi + elec_thi;
G4double elec_z_x = 6.5*mm, elec_z_y = 37.0*mm;
// electrodes (z injection)
G4double elec_zi_x = 16.0*mm;
G4double elec_zi_y = 12.0*mm;
G4double elec_zi_zoff = 0.5*cage_i_z + 0.5*elecsupp_zi_thi + elec_thi;
G4double elec_zi_yoff = 12.*mm;
// Test Mass
G4double tmass_len = 46.0*mm;
// Molybdenum cage **********************************************************
G4Box* cage_o_sol = new G4Box("cage_o_sol", .5*cage_o, .5*cage_o, .5*cage_o);
G4LogicalVolume* cage_o_log =
new G4LogicalVolume(cage_o_sol, molybdenum, "cage_o_log");
G4VPhysicalVolume* cage_o_phys = new G4PVPlacement(0, G4ThreeVector(),
"cage_o_phys", cage_o_log, SensorHousing_i_phys, false, 0);
cage_o_log->SetVisAttributes(lgreen_vat);
// cage_o_log->SetVisAttributes(G4VisAttributes::Invisible);
// 0.3 um gold plating
G4Box* goldplating_sol = new G4Box("goldplating_sol",
0.5*cage_i_x+elec_thi, 0.5*cage_i_y+elec_thi, 0.5*cage_i_z+elec_thi);
G4LogicalVolume* goldplating_log =
new G4LogicalVolume(goldplating_sol, gold, "goldplating_log");
G4VPhysicalVolume* goldplating_phys = new G4PVPlacement(0, G4ThreeVector(),
"goldplating_phys", goldplating_log, cage_o_phys, false, 0);
goldplating_log->SetVisAttributes(yellow_vat);
// Inside cage
G4Box* cage_i_sol =
new G4Box("cage_i_sol", .5*cage_i_x, .5*cage_i_y, .5*cage_i_z);
G4LogicalVolume* cage_i_log =
new G4LogicalVolume(cage_i_sol, vacuum, "cage_i_log");
G4VPhysicalVolume* cage_i_phys = new G4PVPlacement(0, G4ThreeVector(),
"cage_i_phys", cage_i_log, goldplating_phys, false, 0);
cage_i_log->SetVisAttributes(white_vat);
// Molybdenum disks *********************************************************
G4Tubs* disk_sol = new G4Tubs("disk_sol", 0.5*disk_id, 0.5*disk_od,
0.5*disk_thi, 0., 360.*deg);
G4LogicalVolume* disk_log =
new G4LogicalVolume(disk_sol, molybdenum, "disk_log");
G4VPhysicalVolume* disk_phys;
disk_phys = new G4PVPlacement(0, G4ThreeVector(0,0,+disk_off),
"disk_phys", disk_log, SensorHousing_i_phys, false, 0);
disk_phys = new G4PVPlacement(0, G4ThreeVector(0,0,-disk_off),
"disk_phys", disk_log, SensorHousing_i_phys, false, 1);
disk_log->SetVisAttributes(lgreen_vat);
// disk_log->SetVisAttributes(G4VisAttributes::Invisible);
// electrodes (x faces) *****************************************************
G4Box* elecsupp_x_sol =
new G4Box("elecsupp_x_sol", 0.5*elecsupp_x_thi,0.5*elec_x_y,0.5*elec_x_z);
G4LogicalVolume* elecsupp_x_log =
new G4LogicalVolume(elecsupp_x_sol, SHAPAL, "elecsupp_x_log");
G4VPhysicalVolume* elecsupp_x_phys;
elecsupp_x_phys = new G4PVPlacement(0,
G4ThreeVector(+elec_x_xoff,-elec_x_yoff,0),
"elecsupp_x_phys", elecsupp_x_log, cage_o_phys, false, 0);
elecsupp_x_phys = new G4PVPlacement(0,
G4ThreeVector(+elec_x_xoff,+elec_x_yoff,0),
"elecsupp_x_phys", elecsupp_x_log, cage_o_phys, false, 1);
elecsupp_x_phys = new G4PVPlacement(0,
G4ThreeVector(-elec_x_xoff,-elec_x_yoff,0),
"elecsupp_x_phys", elecsupp_x_log, cage_o_phys, false, 2);
elecsupp_x_phys = new G4PVPlacement(0,
G4ThreeVector(-elec_x_xoff,+elec_x_yoff,0),
"elecsupp_x_phys", elecsupp_x_log, cage_o_phys, false, 3);
// electrodes (y faces) *****************************************************
G4Box* elecsupp_y_sol =
new G4Box("elecsupp_y_sol", 0.5*elec_y_x,0.5*elecsupp_y_thi,0.5*elec_y_z);
G4LogicalVolume* elecsupp_y_log =
new G4LogicalVolume(elecsupp_y_sol, SHAPAL, "elecsupp_y_log");
G4VPhysicalVolume* elecsupp_y_phys;
elecsupp_y_phys = new G4PVPlacement(0,
G4ThreeVector(0,+elec_y_yoff,-elec_y_zoff),
"elecsupp_y_phys", elecsupp_y_log, cage_o_phys, false, 0);
elecsupp_y_phys = new G4PVPlacement(0,
G4ThreeVector(0,+elec_y_yoff,+elec_y_zoff),
"elecsupp_y_phys", elecsupp_y_log, cage_o_phys, false, 1);
elecsupp_y_phys = new G4PVPlacement(0,
G4ThreeVector(0,-elec_y_yoff,-elec_y_zoff),
"elecsupp_y_phys", elecsupp_y_log, cage_o_phys, false, 2);
elecsupp_y_phys = new G4PVPlacement(0,
G4ThreeVector(0,-elec_y_yoff,+elec_y_zoff),
"elecsupp_y_phys", elecsupp_y_log, cage_o_phys, false, 3);
// y injection
G4Box* elecsupp_yi_sol =
new G4Box("elecsupp_yi_sol",.5*elec_yi_x,.5*elecsupp_yi_thi,.5*elec_yi_z);
G4LogicalVolume* elecsupp_yi_log =
new G4LogicalVolume(elecsupp_yi_sol, SHAPAL, "elecsupp_yi_log");
G4VPhysicalVolume* elecsupp_yi_phys;
elecsupp_yi_phys = new G4PVPlacement(0, G4ThreeVector(0,+elec_yi_yoff,0),
"elecsupp_yi_phys", elecsupp_yi_log, cage_o_phys, false, 0);
elecsupp_yi_phys = new G4PVPlacement(0, G4ThreeVector(0,-elec_yi_yoff,0),
"elecsupp_yi_phys", elecsupp_yi_log, cage_o_phys, false, 1);
// electrodes (z faces) *****************************************************
G4Box* elecsupp_z_sol =
new G4Box("elecsupp_z_sol",.5*elec_z_x,.5*elec_z_y,.5*elecsupp_z_thi);
G4LogicalVolume* elecsupp_z_log =
new G4LogicalVolume(elecsupp_z_sol, SHAPAL, "elecsupp_z_log");
G4VPhysicalVolume* elecsupp_z_phys;
elecsupp_z_phys = new G4PVPlacement(0,
G4ThreeVector(-elec_y_zoff,0,+elec_z_zoff),
"elecsupp_y_phys", elecsupp_z_log, cage_o_phys, false, 0);
elecsupp_z_phys = new G4PVPlacement(0,
G4ThreeVector(+elec_y_zoff,0,+elec_z_zoff),
"elecsupp_y_phys", elecsupp_z_log, cage_o_phys, false, 1);
elecsupp_z_phys = new G4PVPlacement(0,
G4ThreeVector(-elec_y_zoff,0,-elec_z_zoff),
"elecsupp_y_phys", elecsupp_z_log, cage_o_phys, false, 2);
elecsupp_z_phys = new G4PVPlacement(0,
G4ThreeVector(+elec_y_zoff,0,-elec_z_zoff),
"elecsupp_y_phys", elecsupp_z_log, cage_o_phys, false, 3);
// z injection
G4Box* elecsupp_zi_sol =
new G4Box("elecsupp_zi_sol",.5*elec_zi_x,.5*elec_zi_y,.5*elecsupp_zi_thi);
G4LogicalVolume* elecsupp_zi_log =
new G4LogicalVolume(elecsupp_zi_sol, SHAPAL, "elecsupp_zi_log");
G4VPhysicalVolume* elecsupp_zi_phys;
elecsupp_zi_phys=new G4PVPlacement(0,
G4ThreeVector(0,-elec_zi_yoff,+elec_zi_zoff),
"elecsupp_zi_phys", elecsupp_zi_log, cage_o_phys, false, 0);
elecsupp_zi_phys=new G4PVPlacement(0,
G4ThreeVector(0,+elec_zi_yoff,+elec_zi_zoff),
"elecsupp_zi_phys", elecsupp_zi_log, cage_o_phys, false, 1);
elecsupp_zi_phys=new G4PVPlacement(0,
G4ThreeVector(0,-elec_zi_yoff,-elec_zi_zoff),
"elecsupp_zi_phys", elecsupp_zi_log, cage_o_phys, false, 2);
elecsupp_zi_phys=new G4PVPlacement(0,
G4ThreeVector(0,+elec_zi_yoff,-elec_zi_zoff),
"elecsupp_zi_phys", elecsupp_zi_log, cage_o_phys, false, 3);
// electrode vis attributes
elecsupp_x_log ->SetVisAttributes(sol_white_vat);
elecsupp_y_log ->SetVisAttributes(sol_white_vat);
elecsupp_z_log ->SetVisAttributes(sol_white_vat);
elecsupp_yi_log->SetVisAttributes(sol_orange_vat);
elecsupp_zi_log->SetVisAttributes(sol_orange_vat);
// Test Masses **************************************************************
G4Box* tmass_sol =
new G4Box("tmass_sol", 0.5*tmass_len, 0.5*tmass_len, 0.5*tmass_len);
G4LogicalVolume* tmass_log =
new G4LogicalVolume(tmass_sol, AuPt, "tmass_log");
G4VPhysicalVolume* tmass_phys = new G4PVPlacement
(0, G4ThreeVector(), "tmass_phys", tmass_log, cage_i_phys, false, 0);
tmass_log->SetVisAttributes(sol_gold_vat);
//*****************************************************************************
@@ -0,0 +1,643 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISADetectorConstruction class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
//***************************************************************************
// Interferometer Assembly
//***************************************************************************
// Payload Shield (Y Tube)
// Telescope Light Shields
// Telescope Electronics Mounting
// Telescope Mirrors Mounting
// Telescope Actuator Mechanism
// Optical Bench Mounting
// Optical Bench
//***************************************************************************
//***************************************************************************
// Payload Shield
//***************************************************************************
// Y-tube
G4double YTube_dia = 400.*mm;
G4double YTube_thi = 5.*mm;
G4double arm1_len = 900.*mm;
G4double arm2_len = 900.*mm;
G4double arm3_len = 900.*mm;
// G4double YTube_xoff = -800.*mm;
G4double tune_x = 800.*mm;
G4double tune_y = 250.*mm;
// outer volumes
G4Tubs* arm1_o_sol =
new G4Tubs("arm1_o_sol", 0., 0.5*YTube_dia, 0.5*arm1_len, 0., 360.*deg);
G4Tubs* arm2_o_sol =
new G4Tubs("arm2_o_sol", 0., 0.5*YTube_dia, 0.5*arm2_len, 0., 360.*deg);
G4Tubs* arm3_o_sol =
new G4Tubs("arm3_o_sol", 0., 0.5*YTube_dia, 0.5*arm3_len, 0., 360.*deg);
G4RotationMatrix ytube_rot1; ytube_rot1.rotateY(30.*deg);
G4UnionSolid* uni1_o_sol = new G4UnionSolid("uni1_o_sol", arm1_o_sol,
arm2_o_sol, G4Transform3D(ytube_rot1, G4ThreeVector(+tune_y,0,tune_x)));
G4RotationMatrix ytube_rot2; ytube_rot2.rotateY(-30.*deg);
G4UnionSolid* uni2_o_sol = new G4UnionSolid("uni2_o_sol", uni1_o_sol,
arm3_o_sol, G4Transform3D(ytube_rot2, G4ThreeVector(-tune_y,0,tune_x)));
G4LogicalVolume* arms_o_log =
new G4LogicalVolume(uni2_o_sol, CFRP, "arms_o_log");
G4RotationMatrix ytube_rot3;
ytube_rot3.rotateX(90.*deg); ytube_rot3.rotateZ(90.*deg);
G4VPhysicalVolume* arms_o_phys = new G4PVPlacement
(G4Transform3D(ytube_rot3, spacecraft_pos + G4ThreeVector(YTube_xoff,0,0)),
"arms_o_phys", arms_o_log, wld_phys, false, 0);
arms_o_log->SetVisAttributes(yellow_vat);
// inner volumes
G4Tubs* arm1_i_sol = new G4Tubs("arm1_i_sol", 0., 0.5*YTube_dia-YTube_thi,
0.5*arm1_len, 0.*deg, 360.*deg);
G4Tubs* arm2_i_sol = new G4Tubs("arm2_i_sol", 0., 0.5*YTube_dia-YTube_thi,
0.5*arm2_len, 0.*deg, 360.*deg);
G4Tubs* arm3_i_sol = new G4Tubs("arm3_i_sol", 0., 0.5*YTube_dia-YTube_thi,
0.5*arm3_len, 0.*deg, 360.*deg);
G4UnionSolid* uni1_i_sol = new G4UnionSolid("uni1_i_sol", arm1_i_sol,
arm2_i_sol, G4Transform3D(ytube_rot1, G4ThreeVector(+tune_y,0,tune_x)));
G4UnionSolid* uni2_i_sol = new G4UnionSolid("uni2_i_sol", uni1_i_sol,
arm3_i_sol, G4Transform3D(ytube_rot2, G4ThreeVector(-tune_y,0,tune_x)));
G4LogicalVolume* arms_i_log =
new G4LogicalVolume(uni2_i_sol, vacuum, "arms_i_log");
G4VPhysicalVolume* arms_i_phys = new G4PVPlacement(0, G4ThreeVector(0,0,0),
"arms_i_phys", arms_i_log, arms_o_phys, false, 0);
arms_i_log->SetVisAttributes(yellow_vat);
// Telescope Light Shields: ~5.5 kg
G4double TelShield_len = 730.*mm;
G4double TelShield_dia = 370.*mm;
G4double TelShield_thi = 5.*mm;
G4double TelShield_yoff = 663.*mm;
G4double TelShield_xoff = 1511.*mm;
G4double TelShieldCutout_len = 2000.*mm;
G4double TelShieldCutout_off = 1000.*mm;
G4Tubs* TelShield_tub = new G4Tubs("TelShield_sol", 0.5*TelShield_dia -
TelShield_thi, 0.5*TelShield_dia, 0.5*TelShield_len, 0., 360.*deg);
G4Box* TelShieldCutout_box = new G4Box("TelShieldCutout_box",
0.5*TelShieldCutout_len, 0.5*TelShieldCutout_len, 0.5*TelShieldCutout_len);
G4RotationMatrix ytube_rot4; ytube_rot4.rotateX(-30.*deg);
G4SubtractionSolid* TelShield_sol = new G4SubtractionSolid("TelShield_sol",
TelShield_tub, TelShieldCutout_box, G4Transform3D(ytube_rot4,
G4ThreeVector(0,0,-0.5*TelShield_len-TelShieldCutout_off)));
G4LogicalVolume* TelShield_log =
new G4LogicalVolume(TelShield_sol, CFRP, "TelShield_log");
G4VPhysicalVolume* TelShield_phys;
G4RotationMatrix telsh_rot1; telsh_rot1.rotateY(-90.*deg);
telsh_rot1.rotateX(90.*deg); telsh_rot1.rotateZ(-30.*deg);
TelShield_phys = new G4PVPlacement(G4Transform3D(telsh_rot1,
spacecraft_pos+G4ThreeVector(YTube_xoff+TelShield_xoff,-TelShield_yoff,0)),
"TelShield_phys", TelShield_log, wld_phys, false, 0);
G4RotationMatrix telsh_rot2; telsh_rot2.rotateY(-90.*deg);
telsh_rot2.rotateX(90.*deg); telsh_rot2.rotateZ(+30.*deg);
TelShield_phys = new G4PVPlacement(G4Transform3D(telsh_rot2,
spacecraft_pos+G4ThreeVector(YTube_xoff+TelShield_xoff,+TelShield_yoff,0)),
"TelShield_phys", TelShield_log, wld_phys, false, 1);
TelShield_log->SetVisAttributes(green_vat);
// Telescope actuator: 1.8 kg
// includes mass of Al arms
G4double TelActuatorCyl_dia = 76.*mm;
G4double TelActuatorCyl_len = 147.*mm;
// Actuator mount: 0.45 kg
G4double TelActuatorMount_hei = 147.*mm;
G4double TelActuatorMount_wid = 120.*mm;
G4double TelActuatorMount_thi = 7.5*mm;
G4ThreeVector TelActuator_pos1(-100.*mm,0.,550.*mm);
G4ThreeVector TelActuator_pos2( 100.*mm,0.,550.*mm);
// Telescope actuator 1: cylinder
G4Tubs* TelActuatorCyl_sol = new G4Tubs("TelActuatorCyl_sol",
0, 0.5*TelActuatorCyl_dia, 0.5*TelActuatorCyl_len, 0., 360.*deg);
G4LogicalVolume* TelActuatorCyl_log =
new G4LogicalVolume(TelActuatorCyl_sol, Al6061, "TelActuatorCyl_log");
G4RotationMatrix act_rot1; act_rot1.rotateY(60.*deg);
G4VPhysicalVolume* TelActuatorCyl_phys;
TelActuatorCyl_phys = new G4PVPlacement(G4Transform3D(act_rot1,
TelActuator_pos1), "TelActuatorCyl_phys", TelActuatorCyl_log,
arms_i_phys, false, 0);
TelActuatorCyl_log->SetVisAttributes(sol_red_vat);
// Telescope actuator 1: mount
G4Box* TelActuatorMount_box = new G4Box("TelActuatorMount_box",
.5*TelActuatorMount_wid, .5*TelActuatorMount_hei, .5*TelActuatorMount_thi);
G4SubtractionSolid* TelActuatorMount_sol = new G4SubtractionSolid
("TelActuatorMount_sol", TelActuatorMount_box, TelActuatorCyl_sol,
0, G4ThreeVector(0,0.5*TelActuatorMount_hei,0));
G4LogicalVolume* TelActuatorMount_log =
new G4LogicalVolume(TelActuatorMount_sol, TiAlloy, "TelActuatorMount_log");
G4VPhysicalVolume* TelActuatorMount_phys;
TelActuatorMount_phys = new G4PVPlacement(G4Transform3D(act_rot1,
TelActuator_pos1 + G4ThreeVector(0,-0.5*TelActuatorMount_hei-2.*mm,0.)),
"TelActuatorMount_phys", TelActuatorMount_log, arms_i_phys, false, 0);
TelActuatorMount_log->SetVisAttributes(sol_yellow_vat);
// Telescope actuator 2
G4RotationMatrix act_rot2; act_rot2.rotateY(-60.*deg);
TelActuatorCyl_phys = new G4PVPlacement(G4Transform3D
(act_rot2, TelActuator_pos2), "TelActuatorCyl_phys",
TelActuatorCyl_log, arms_i_phys, false, 1);
TelActuatorMount_phys = new G4PVPlacement(G4Transform3D(act_rot2,
TelActuator_pos2 + G4ThreeVector(0,-0.5*TelActuatorMount_hei-2.*mm,0.)),
"TelActuatorMount_phys", TelActuatorMount_log, arms_i_phys, false, 1);
//***************************************************************************
// Telescope / GRS Assembly (in dummy wrapper volume)
//***************************************************************************
// Dummy (assembly) box for telescope
G4double TelBox_len = 620.*mm;
G4double TelBox_dia = 370.*mm;
// Dummy (assembly) box for telescope
G4Tubs* TelBox_sol =
new G4Tubs("TelBox_sol", 0., 0.5*TelBox_dia, 0.5*TelBox_len, 0., 360.*deg);
G4LogicalVolume* TelBox_log =
new G4LogicalVolume(TelBox_sol, vacuum, "TelBox_log");
G4VPhysicalVolume* TelBox_phys;
TelBox_phys =
new G4PVPlacement(G4Transform3D(tel_rot1, tel_pos1),
"TelBox1_phys", TelBox_log, arms_i_phys, false, 0);
TelBox_phys =
new G4PVPlacement(G4Transform3D(tel_rot2, tel_pos2),
"TelBox2_phys", TelBox_log, arms_i_phys, false, 1);
// TelBox_log->SetVisAttributes(white_vat);
TelBox_log->SetVisAttributes(G4VisAttributes::Invisible);
// all z-offsets referred to TM centre
// change OpticalBench_off to move telescope components along z-axis
// Optical Bench: 4.41 kg
G4double OpticalBench_len = 350.0*mm;
G4double OpticalBench_wid = 200.0*mm;
G4double OpticalBench_thi = 40.0*mm;
// Sensor Housing as in Solid Model
// G4double OpticalBenchCutout_len = 170.0*mm + 1.*mm;
// G4double OpticalBenchCutout_wid = 120.0*mm + 1.*mm;
// Sensor Housing to fit LTP Sensor
G4double OpticalBenchCutout_dia = 126.0*mm;
G4double OpticalBenchCutout_thi = 100.0*mm;
// G4double OpticalBench_off = 0.0*mm;
// Optical Bench
G4Box* OpticalBench_box = new G4Box("OpticalBench_box",
0.5*OpticalBench_wid, 0.5*OpticalBench_thi, 0.5*OpticalBench_len);
// old design cutout
// G4Box* OpticalBenchCutout_box = new G4Box("OpticalBenchCutout_box",
// 0.5*OpticalBenchCutout_wid, 0.5*OpticalBenchCutout_thi,
// 0.5*OpticalBenchCutout_len);
// LTP design cutout
G4Tubs* OpticalBenchCutout_box = new G4Tubs("OpticalBenchCutout_box",
0., 0.5*OpticalBenchCutout_dia, 0.5*OpticalBenchCutout_thi, 0., 360.*deg);
G4RotationMatrix cutout_rot; cutout_rot.rotateX(90.*deg);
G4SubtractionSolid* OpticalBench_sol = new G4SubtractionSolid
("OpticalBench_sol", OpticalBench_box, OpticalBenchCutout_box,
G4Transform3D(cutout_rot, G4ThreeVector()));
G4LogicalVolume* OpticalBench_log =
new G4LogicalVolume(OpticalBench_sol, ULEglass, "OpticalBench_log");
G4VPhysicalVolume* OpticalBench_phys=
new G4PVPlacement(0, G4ThreeVector(0,0, OpticalBench_off),
"OpticalBench_phys", OpticalBench_log, TelBox_phys, false, 0);
OpticalBench_log->SetVisAttributes(sol_white_vat);
// Support ring: 0.99 kg
G4double SupportRing_od = 359.*mm;
G4double SupportRing_dia_o = 23.*mm;
G4double SupportRing_dia_i = 10.*mm;
// Support yokes: 0.12 kg
// also accounts for pivot mass
G4double SupportYoke_thi = 5.*mm;
G4double SupportYoke_dia = 15.*mm;
G4double SupportYoke_len = 170.*mm;
G4double SupportYoke_xoff = 122.*mm;
G4double SupportYoke_yoff = 50.*mm;
G4double SupportYoke_zoff = 90.*mm;
// Support ring
G4Torus* SupportRing_sol = new G4Torus("SupportRing_sol",
0.5*SupportRing_dia_i,0.5*SupportRing_dia_o,
0.5*(SupportRing_od-SupportRing_dia_o), 0.,360.*deg);
G4LogicalVolume* SupportRing_log =
new G4LogicalVolume(SupportRing_sol, ULEglass, "SupportRing_log");
G4VPhysicalVolume* SupportRing_phys=
new G4PVPlacement(0, G4ThreeVector(0.,0.,OpticalBench_off),
"SupportRing_phys", SupportRing_log, TelBox_phys, false, 0);
SupportRing_log->SetVisAttributes(sol_red_vat);
// Support yokes
G4Tubs* SupportYoke_sol = new G4Tubs("SupportYoke_sol", 0.5*SupportYoke_dia
- SupportYoke_thi, 0.5*SupportYoke_dia, 0.5*SupportYoke_len, 0., 360.*deg);
G4LogicalVolume* SupportYoke_log =
new G4LogicalVolume(SupportYoke_sol, TiAlloy, "SupportYoke_log");
SupportYoke_log->SetVisAttributes(sol_red_vat);
G4VPhysicalVolume* SupportYoke_phys;
// upper
G4RotationMatrix tel_rot3;
tel_rot3.rotateX(+30.*deg); tel_rot3.rotateY(-10.*deg);
SupportYoke_phys = new G4PVPlacement(G4Transform3D(tel_rot3,
G4ThreeVector(+SupportYoke_xoff, +SupportYoke_yoff ,
OpticalBench_off + SupportYoke_zoff)), "SupportYoke_phys",
SupportYoke_log, TelBox_phys, false, 0);
G4RotationMatrix tel_rot4;
tel_rot4.rotateX(+30.*deg); tel_rot4.rotateY(+10.*deg);
SupportYoke_phys = new G4PVPlacement(G4Transform3D(tel_rot4,
G4ThreeVector(-SupportYoke_xoff, +SupportYoke_yoff ,
OpticalBench_off + SupportYoke_zoff)), "SupportYoke_phys",
SupportYoke_log, TelBox_phys, false, 1);
G4RotationMatrix tel_rot5;
tel_rot5.rotateX(-30.*deg); tel_rot5.rotateY(+10.*deg);
SupportYoke_phys = new G4PVPlacement(G4Transform3D(tel_rot5,
G4ThreeVector(+SupportYoke_xoff, +SupportYoke_yoff ,
OpticalBench_off - SupportYoke_zoff)), "SupportYoke_phys",
SupportYoke_log, TelBox_phys, false, 2);
G4RotationMatrix tel_rot6;
tel_rot6.rotateX(-30.*deg); tel_rot6.rotateY(-10.*deg);
SupportYoke_phys = new G4PVPlacement(G4Transform3D(tel_rot6,
G4ThreeVector(-SupportYoke_xoff, +SupportYoke_yoff ,
OpticalBench_off - SupportYoke_zoff)), "SupportYoke_phys",
SupportYoke_log, TelBox_phys, false, 3);
// lower
G4RotationMatrix tel_rot7;
tel_rot7.rotateX(-30.*deg); tel_rot7.rotateY(-10.*deg);
SupportYoke_phys = new G4PVPlacement(G4Transform3D(tel_rot7,
G4ThreeVector(+SupportYoke_xoff, -SupportYoke_yoff ,
OpticalBench_off + SupportYoke_zoff)), "SupportYoke_phys",
SupportYoke_log, TelBox_phys, false, 4);
G4RotationMatrix tel_rot8;
tel_rot8.rotateX(-30.*deg); tel_rot8.rotateY(+10.*deg);
SupportYoke_phys = new G4PVPlacement(G4Transform3D(tel_rot8,
G4ThreeVector(-SupportYoke_xoff, -SupportYoke_yoff ,
OpticalBench_off + SupportYoke_zoff)), "SupportYoke_phys",
SupportYoke_log, TelBox_phys, false, 5);
G4RotationMatrix tel_rot9;
tel_rot9.rotateX(+30.*deg); tel_rot9.rotateY(+10.*deg);
SupportYoke_phys = new G4PVPlacement(G4Transform3D(tel_rot9,
G4ThreeVector(+SupportYoke_xoff, -SupportYoke_yoff ,
OpticalBench_off - SupportYoke_zoff)), "SupportYoke_phys",
SupportYoke_log, TelBox_phys, false, 6);
G4RotationMatrix tel_rot10;
tel_rot10.rotateX(+30.*deg); tel_rot10.rotateY(-10.*deg);
SupportYoke_phys = new G4PVPlacement(G4Transform3D(tel_rot10,
G4ThreeVector(-SupportYoke_xoff, -SupportYoke_yoff ,
OpticalBench_off - SupportYoke_zoff)), "SupportYoke_phys",
SupportYoke_log, TelBox_phys, false, 7);
// Shield tube: 3.66 kg
G4double ShieldTube_len = 500.*mm;
G4double ShieldTube_thi = 4.*mm;
G4double ShieldTube_dia = 360.*mm + 2*ShieldTube_thi;
G4double ShieldTube_off = 60.*mm;
// Shield tube
G4Tubs* ShieldTube_sol = new G4Tubs("ShieldTube_sol",
0.5*ShieldTube_dia-ShieldTube_thi, 0.5*ShieldTube_dia,
0.5*ShieldTube_len, 0., 360.*deg);
G4LogicalVolume* ShieldTube_log =
new G4LogicalVolume(ShieldTube_sol, CFRP, "ShieldTube_log");
G4VPhysicalVolume* ShieldTube_phys = new G4PVPlacement(0,
G4ThreeVector(0,0,OpticalBench_off-ShieldTube_off),
"ShieldTube_phys", ShieldTube_log, TelBox_phys, false, 0);
ShieldTube_log->SetVisAttributes(G4VisAttributes::Invisible);
// Mounting rings: 0.78 kg
G4double TelRing_dia = 360.0*mm;
G4double TelRing_thi = 15.0*mm;
G4double TelRing_len = 30.0*mm;
G4double TelRing_off1 = 0.5*OpticalBench_len - 0.5*TelRing_len + 0.5*mm;
G4double TelRing_off2 = 0.5*OpticalBench_len;
// Mounting rings
G4Tubs* TelRing_sol =
new G4Tubs("TelRing_sol", 0.5*TelRing_dia-TelRing_thi, 0.5*TelRing_dia,
0.5*TelRing_len, 0., 360.*deg);
G4LogicalVolume* TelRing_log =
new G4LogicalVolume(TelRing_sol, CFRP, "TelRing_log");
TelRing_log->SetVisAttributes(sol_white_vat);
G4VPhysicalVolume* TelRing_phys;
TelRing_phys = new G4PVPlacement(0, G4ThreeVector
(0,0,OpticalBench_off - TelRing_off1),
"TelRing_phys", TelRing_log, TelBox_phys, false, 0);
// Electronics mounting ring
TelRing_phys = new G4PVPlacement(0, G4ThreeVector
(0,0,OpticalBench_off + TelRing_off2),
"TelRing_phys", TelRing_log, TelBox_phys, false, 1);
// Shield/Mounting Plate: 1.54 kg
G4double ShieldPlate_dia = 350.*mm;
G4double ShieldPlate_thi = 10.*mm;
G4double ShieldPlate_off = TelRing_off2 +
0.5*(TelRing_len+ShieldPlate_thi) + 20.0*mm;
// Shield/Mounting Plate
G4Tubs* ShieldPlate_sol = new G4Tubs("ShieldPlate_sol",
0., 0.5*ShieldPlate_dia, 0.5*ShieldPlate_thi, 0., 360.*deg);
G4LogicalVolume* ShieldPlate_log =
new G4LogicalVolume(ShieldPlate_sol, CFRP, "ShieldPlate_log");
G4VPhysicalVolume* ShieldPlate_phys = new G4PVPlacement(0,
G4ThreeVector(0,0,OpticalBench_off + ShieldPlate_off),
"ShieldPlate_phys", ShieldPlate_log, TelBox_phys, false, 0);
ShieldPlate_log->SetVisAttributes(sol_white_vat);
// Telescope electronics boxes: 0.36 kg
G4double TelElecBox_wid = 100.0*mm;
G4double TelElecBox_len = 90.0*mm;
G4double TelElecBox_hei = 180.0*mm;
G4double TelElecBoxes_sep = 150.0*mm;
G4double TelElecBoxes_off = ShieldPlate_off +
0.5*(ShieldPlate_thi + TelElecBox_len);
// Telescope electronics boxes
G4Box* TelElecBox_sol = new G4Box("TelElecBox_sol", 0.5*TelElecBox_wid,
0.5*TelElecBox_hei, 0.5*TelElecBox_len);
G4LogicalVolume* TelElecBox_log =
new G4LogicalVolume(TelElecBox_sol, Al6061, "TelElecBox_log");
G4VPhysicalVolume* TelElecBox_phys;
// Interferometer electronics
TelElecBox_phys = new G4PVPlacement(0,
G4ThreeVector(-0.5*TelElecBoxes_sep, 0,OpticalBench_off+TelElecBoxes_off),
"TelElecBox_phys", TelElecBox_log, TelBox_phys, false, 0);
TelElecBox_log->SetVisAttributes(sol_red_vat);
// Accelerator electronics
TelElecBox_phys = new G4PVPlacement(0,
G4ThreeVector(0.5*TelElecBoxes_sep, 0, OpticalBench_off+TelElecBoxes_off),
"TelElecBox_phys", TelElecBox_log, TelBox_phys, false, 1);
// Each box is made from solid Al6061 from which a volume
// s times smaller is removed to match assigned mass;
G4double s = pow(1.-0.36/(2.70*TelElecBox_wid*TelElecBox_hei*TelElecBox_len)
*1E6,1./3.);
G4Box* TelElecBoxIn_sol = new G4Box("TelElecBoxIn_sol", s*0.5*TelElecBox_wid,
s*0.5*TelElecBox_hei, s*0.5*TelElecBox_len);
G4LogicalVolume* TelElecBoxIn_log =
new G4LogicalVolume(TelElecBoxIn_sol, vacuum, "TelElecBoxIn_log");
G4VPhysicalVolume* TelElecBoxIn_phys = new G4PVPlacement
(0, 0, "TelElecBoxIn_i", TelElecBoxIn_log, TelElecBox_phys, false, 0);
// Front thermal shield: 0.15 kg
G4double FrontThermalShield_dia = 350.*mm;
G4double FrontThermalShield_thi = 1.*mm;
G4double FrontThermalShield_hol = 25.*mm;
G4double FrontThermalShield_roff = 30.*mm;
G4double FrontThermalShield_off = TelRing_off1 + 0.5*TelRing_len
+ 0.5*FrontThermalShield_thi + 20.0*mm;
// Front thermal shield
G4Tubs* FrontThermalShield_tub = new G4Tubs("FrontThermalShield_tub",
0., 0.5*FrontThermalShield_dia, 0.5*FrontThermalShield_thi, 0., 360.*deg);
G4Tubs* FrontThermalShieldCutout_tub =
new G4Tubs("FrontThermalShieldCutout_tub",
0., 0.5*FrontThermalShield_hol, 2*FrontThermalShield_thi, 0., 360.*deg);
G4SubtractionSolid* FrontThermalShield_sol =
new G4SubtractionSolid("FrontThermalShield_sol", FrontThermalShield_tub,
FrontThermalShieldCutout_tub, G4Transform3D(G4RotationMatrix(),
G4ThreeVector(0,FrontThermalShield_roff,0)));
G4LogicalVolume* FrontThermalShield_log =
new G4LogicalVolume(FrontThermalShield_sol, CFRP,
"FrontThermalShield_log");
G4VPhysicalVolume* FrontThermalShield_phys = new G4PVPlacement
(0, G4ThreeVector(0, 0, OpticalBench_off-FrontThermalShield_off),
"FrontThermalShield_phys", FrontThermalShield_log, TelBox_phys, false, 0);
FrontThermalShield_log->SetVisAttributes(sol_white_vat);
//***************************************************************************
// Telescope assembly
//***************************************************************************
// Primary mirror mount: ~1.9 kg
G4double TelPriMirMount_rad = 420.*mm;
G4double TelPriMirMount_yoff = 220.*mm;
G4double TelPriMirMount_thi = 13.*mm;
G4double TelPriMirMount_off = FrontThermalShield_off +
0.5*TelPriMirMount_thi + 20.*mm;
G4double TelPriMirMountCutout0_dia = 350.*mm;
G4double TelPriMirMountCutout0_yoff = 220.*mm;
G4double TelPriMirMountCutout1_dia = 60.*mm;
G4double TelPriMirMountCutout1_yoff = 190.*mm;
G4double TelPriMirMountCutout2_dia = 46.*mm;
G4double TelPriMirMountCutout2_yoff = 367.*mm;
// Primary mirror mount
// full thickness assumed; material density is decreased to conserve mass
G4Tubs* TelPriMirMount_tub = new G4Tubs("TelPriMirMount_tub",
0, TelPriMirMount_rad, 0.5*TelPriMirMount_thi, -115.*deg, 50.*deg);
G4Tubs* TelPriMirMountCutout0_tub = new G4Tubs
("TelPriMirMountCutout0_tub", 0.5*TelPriMirMountCutout0_dia,
0.8*TelPriMirMountCutout0_dia, TelPriMirMount_thi, 0., 360.*deg);
G4SubtractionSolid* TelPriMirMount_sol0 = new G4SubtractionSolid
("TelPriMirMount_sol1", TelPriMirMount_tub, TelPriMirMountCutout0_tub,
G4Transform3D(G4RotationMatrix(),
G4ThreeVector(0,-TelPriMirMountCutout0_yoff,0)));
G4Tubs* TelPriMirMountCutout1_tub = new G4Tubs("TelPriMirMountCutout1_tub",
0, 0.5*TelPriMirMountCutout1_dia, TelPriMirMount_thi, 0.*deg, 360.*deg);
G4SubtractionSolid* TelPriMirMount_sol1 = new G4SubtractionSolid
("TelPriMirMount_sol1", TelPriMirMount_sol0, TelPriMirMountCutout1_tub,
G4Transform3D(G4RotationMatrix(),
G4ThreeVector(0, -TelPriMirMountCutout1_yoff,0)));
G4Tubs* TelPriMirMountCutout2_tub = new G4Tubs("TelPriMirMountCutout2_tub",
0, 0.5*TelPriMirMountCutout2_dia, TelPriMirMount_thi, 0.*deg, 360.*deg);
G4SubtractionSolid* TelPriMirMount_sol2 = new G4SubtractionSolid
("TelPriMirMount_sol2", TelPriMirMount_sol1, TelPriMirMountCutout2_tub,
G4Transform3D(G4RotationMatrix(),
G4ThreeVector(0, -TelPriMirMountCutout2_yoff,0)));
G4LogicalVolume* TelPriMirMount_log =
new G4LogicalVolume(TelPriMirMount_sol2, Al6061, "TelPriMirMount_log");
G4VPhysicalVolume* TelPriMirMount_phys = new G4PVPlacement(0,
G4ThreeVector(0, TelPriMirMount_yoff, OpticalBench_off-TelPriMirMount_off),
"TelPriMirMount_phys", TelPriMirMount_log, TelBox_phys, false, 0);
TelPriMirMount_log->SetVisAttributes(sol_blue_vat);
// primary mirror: 2.03 kg
G4double TelPriMir_thi = 9.0*mm;
G4double TelPriMir_rad = 500.0*mm;
G4double TelPriMir_dia = 304.0*mm;
G4double TelPriMir_yoff = 30.0*mm;
G4double TelPriMirHol_dia = 35.0*mm;
G4double TelPriMirHol_thi = 5.0*mm;
G4double TelPriMirHol_len = 45.0*mm;
G4double TelPriMir_off = TelPriMirMount_off +
0.5*TelPriMirMount_thi +2.*mm;
// primary mirror: cylinder
G4Tubs* TelPriMirCyl_sol = new G4Tubs("TelPriMirCyl_sol",
0.5*TelPriMirHol_dia, 0.5*TelPriMirHol_dia+TelPriMirHol_thi,
0.5*TelPriMirHol_len, 0., 360.*deg);
G4LogicalVolume* TelPriMirCyl_log =
new G4LogicalVolume(TelPriMirCyl_sol, SiC, "TelPriMirCyl_log");
G4VPhysicalVolume* TelPriMirCyl_phys= new G4PVPlacement(0, G4ThreeVector
(0,TelPriMir_yoff,OpticalBench_off-TelPriMir_off+0.5*TelPriMirMount_thi),
"TelPriMirCyl_phys", TelPriMirCyl_log, TelBox_phys, false, 0);
TelPriMirCyl_log->SetVisAttributes(sol_green_vat);
// primary mirror: dish
G4Sphere* TelPriMir_sol =
new G4Sphere("TelPriMir_sol", TelPriMir_rad - TelPriMir_thi,
TelPriMir_rad, 0, 360.*deg,
atan(0.5*TelPriMirHol_dia/TelPriMir_rad),
atan(0.5*TelPriMir_dia/TelPriMir_rad) -
atan(0.5*TelPriMirHol_dia/TelPriMir_rad));
G4LogicalVolume* TelPriMir_log =
new G4LogicalVolume(TelPriMir_sol, SiC, "TelPriMir_log");
G4VPhysicalVolume* TelPriMir_phys= new G4PVPlacement(0, G4ThreeVector
(0,TelPriMir_yoff, OpticalBench_off-TelPriMir_off-TelPriMir_rad-17.*mm),
"TelPriMir_phys", TelPriMir_log, TelBox_phys, false, 0);
TelPriMir_log->SetVisAttributes(sol_green_vat);
// *** NOTE ***
// Following items are NOT in TelBox_phys but in TelShield_phys
G4ThreeVector offset(0,0,0.5*TelShield_len);
// Telescope mast: 0.41 kg
G4double TelMast_thi = 2.0*mm;
G4double TelMast_dia = 44.0*mm;
G4double TelMast_len = 500.*mm;
G4double TelMast_off = 0.5*TelMast_len;
// Telescope mast
G4Tubs* TelMast_sol =
new G4Tubs("TelMast_sol", 0.5*TelMast_dia-TelMast_thi, 0.5*TelMast_dia,
0.5*TelMast_len, 0., 360.*deg);
G4LogicalVolume* TelMast_log =
new G4LogicalVolume(TelMast_sol, SiC, "TelMast_log");
G4VPhysicalVolume* TelMast_phys= new G4PVPlacement(0, offset+G4ThreeVector
(0,-0.5*TelPriMir_dia - 0.5*TelMast_dia + TelPriMir_yoff, -TelMast_off),
"TelMastTel_phys", TelMast_log, TelShield_phys, false, 0);
TelMast_log->SetVisAttributes(sol_grey_vat);
// secondary mirror: 0.27 kg
G4double TelSecMir_dia = 40.0*mm;
G4double TelSecMir_len = 70.0*mm;
G4double TelSecMir_off = TelMast_off + 0.5*TelMast_len
- 0.5*TelSecMir_len + 10.*mm;
// secondary mirror
G4Tubs* TelSecMir_sol =
new G4Tubs("TelSecMir_sol", 0., 0.5*TelSecMir_dia,
0.5*TelSecMir_len, 0., 360.*deg);
G4LogicalVolume* TelSecMir_log =
new G4LogicalVolume(TelSecMir_sol, SiC, "TelSecMir_log");
G4VPhysicalVolume* TelSecMir_phys= new G4PVPlacement
(0, offset+G4ThreeVector(0,TelPriMir_yoff, -TelSecMir_off),
"TelSecMir_phys", TelSecMir_log, TelShield_phys, false, 0);
TelSecMir_log->SetVisAttributes(sol_green_vat);
// secondary mirror holder: 0.35 kg
G4double TelSecHol_top = 20.0*mm;
G4double TelSecHol_bot = 60.0*mm;
G4double TelSecHol_thi = 5.0*mm;
G4double TelSecHolCap1_thi = 5.0*mm;
G4double TelSecHolCap1_len = TelSecHol_bot;
G4double TelSecHolCap2_thi = 5.0*mm;
G4double TelSecHolCap2_len = TelSecHol_top;
G4double TelSecHol_len = 0.5*(TelPriMir_dia-TelSecMir_dia)
- TelSecHolCap1_thi - TelSecHolCap2_thi;
// secondary mirror holder
G4Trap* TelSecHol_sol = new G4Trap("TelSecHol_sol",
TelSecHol_thi, TelSecHol_len,
TelSecHol_bot, TelSecHol_top);
G4RotationMatrix tel_rot11; tel_rot11.rotateZ(-90.*deg);
tel_rot11.rotateY(-90.*deg); tel_rot11.rotateX(-90.*deg);
G4LogicalVolume* TelSecHol_log =
new G4LogicalVolume(TelSecHol_sol, SiC, "TelSecHol_log");
G4VPhysicalVolume* TelSecHol_phys= new G4PVPlacement(G4Transform3D
(tel_rot11, offset + G4ThreeVector(0,
TelPriMir_yoff-0.5*TelSecHol_len-0.5*TelSecMir_dia-TelSecHolCap2_thi,
-TelMast_off-0.5*TelMast_len+TelSecHol_top)),
"TelSecHol_phys", TelSecHol_log, TelShield_phys, false, 0);
TelSecHol_log->SetVisAttributes(sol_grey_vat);
// cap1
G4Tubs* TelSecHolCap1_sol =
new G4Tubs("TelSecHolCap1_sol", 0.5*TelMast_dia,
0.5*TelMast_dia+TelSecHolCap1_thi, 0.5*TelSecHolCap1_len, 0., 360.*deg);
G4LogicalVolume* TelSecHolCap1_log =
new G4LogicalVolume(TelSecHolCap1_sol, SiC, "TelSecHolCap1_log");
G4VPhysicalVolume* TelSecHolCap1_phys= new G4PVPlacement(0,
offset + G4ThreeVector(0,-0.5*TelPriMir_dia-0.5*TelMast_dia+TelPriMir_yoff,
-TelMast_off-0.5*TelMast_len+0.5*TelSecHol_bot),
"TelSecHolCap1_phys", TelSecHolCap1_log, TelShield_phys, false, 0);
TelSecHolCap1_log->SetVisAttributes(sol_grey_vat);
// cap2
G4Tubs* TelSecHolCap2_sol =
new G4Tubs("TelSecHolCap2_sol", 0.5*TelSecMir_dia,
0.5*TelSecMir_dia+TelSecHolCap2_thi, 0.5*TelSecHolCap2_len, 0., 360.*deg);
G4LogicalVolume* TelSecHolCap2_log =
new G4LogicalVolume(TelSecHolCap2_sol, SiC, "TelSecHolCap2_log");
G4VPhysicalVolume* TelSecHolCap2_phys= new G4PVPlacement(0,
offset + G4ThreeVector(0,TelPriMir_yoff,
-TelMast_off-0.5*TelMast_len+0.5*TelSecHol_top),
"TelSecHolCap2_phys", TelSecHolCap2_log, TelShield_phys, false, 0);
TelSecHolCap2_log->SetVisAttributes(sol_grey_vat);
// make structure invisible
// arms_o_log->SetVisAttributes(G4VisAttributes::Invisible);
// arms_i_log->SetVisAttributes(G4VisAttributes::Invisible);
// TelShield_log->SetVisAttributes(G4VisAttributes::Invisible);
// make structure solid
// arms_o_log->SetVisAttributes(sol_yellow_vat);
// arms_i_log->SetVisAttributes(yellow_vat);
// TelShield_log->SetVisAttributes(sol_green_vat);
// ****************************************************************************
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,81 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISAPrimaryGeneratorAction class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
#include "LISAPrimaryGeneratorAction.hh"
#include "G4GeneralParticleSource.hh"
#include "G4Event.hh"
#include "Randomize.hh"
LISAPrimaryGeneratorAction::LISAPrimaryGeneratorAction() {
particleGun = new G4GeneralParticleSource();
energy_pri=0;
seeds[0]=-1;
seeds[1]=-1;
}
LISAPrimaryGeneratorAction::~LISAPrimaryGeneratorAction() {
delete particleGun;
}
void LISAPrimaryGeneratorAction::GeneratePrimaries(G4Event* anEvent) {
energy_pri = 0.;
// seeds
seeds[0] = *HepRandom::getTheSeeds();
seeds[1] = *(HepRandom::getTheSeeds()+1);
// G4cout << " 1st seed: " << *seeds << G4endl;;
// G4cout << " 2nd seed: " << *(seeds+1) << G4endl;
// HepRandom::showEngineStatus();
particleGun->GeneratePrimaryVertex(anEvent);
energy_pri = particleGun->GetParticleEnergy();
}
@@ -0,0 +1,167 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISARunAction class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
#include "LISARunAction.hh"
#include "LISARunActionMessenger.hh"
#include "LISAEventAction.hh"
#ifdef G4ANALYSIS_USE
#include "LISAAnalysisManager.hh"
#endif
#include "G4Run.hh"
#include "G4RunManager.hh"
#include "G4UImanager.hh"
#include "G4VVisManager.hh"
#include "G4ios.hh"
#include "globals.hh"
#include <strstream>
#include "Randomize.hh"
#include <time.h>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
LISARunAction::LISARunAction() {
// defaults
autoSeed = false;
// create messenger
runMessenger = new LISARunActionMessenger(this);
#ifdef G4ANALYSIS_USE
// Book histograms and ntuples
LISAAnalysisManager* analysis = LISAAnalysisManager::getInstance();
analysis->Init();
#endif
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
LISARunAction::~LISARunAction() {
#ifdef G4ANALYSIS_USE
// delete analysis
LISAAnalysisManager* analysis = LISAAnalysisManager::getInstance();
analysis->Dispose();
#endif
delete runMessenger;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void LISARunAction::BeginOfRunAction(const G4Run* aRun) {
// run id
G4int run_id = aRun->GetRunID();
G4cout << "### Run " << run_id << " start." << G4endl;
char filename[100];
std::ostrstream os(filename,100);
if(autoSeed) {
// automatic (time-based) random seeds and filenames for each run
G4cout << "*******************" << G4endl;
G4cout << "*** AUTOSEED ON ***" << G4endl;
G4cout << "*******************" << G4endl;
long seeds[2];
time_t systime = time(NULL);
seeds[0] = (long) systime;
seeds[1] = (long) (systime*G4UniformRand());
// G4cout << "seed1: " << seeds[0] << "; seed2: " << seeds[1] << G4endl;
HepRandom::setTheSeeds(seeds);
HepRandom::showEngineStatus();
// form filename (eg run00_7324329387_3284798343.out)
os << "run" << std::setw(2) << std::setfill('0') << run_id
<< "_" << seeds[0] << "_" << seeds[1] << std::ends;
}
else {
// default filename, seeds set by /random/reset
os << "charge" << std::ends;
}
// G4cout << "Filename: " << G4String(filename) << G4endl;
// send filename to eventAction
LISAEventAction* eventAction = (LISAEventAction*)
G4RunManager::GetRunManager()->GetUserEventAction();
eventAction->SetFilename( G4String(filename)+G4String(".out") );
#ifdef G4ANALYSIS_USE
// Book histograms and ntuples
LISAAnalysisManager* analysis = LISAAnalysisManager::getInstance();
analysis->bookRun( G4String(filename)+G4String(".hbook") );
#endif
// if (G4VVisManager::GetConcreteInstance()) {
// G4UImanager* UI = G4UImanager::GetUIpointer();
// UI->ApplyCommand("/vis/scene/notifyHandlers");
// }
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void LISARunAction::EndOfRunAction(const G4Run* aRun) {
#ifdef G4ANALYSIS_USE
LISAAnalysisManager* analysis = LISAAnalysisManager::getInstance();
analysis->FinishRun();
#endif
// if (G4VVisManager::GetConcreteInstance()) {
// G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/update");
// }
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -0,0 +1,78 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISARunActionMessenger class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
#include "LISARunActionMessenger.hh"
#include "LISARunAction.hh"
LISARunActionMessenger::LISARunActionMessenger
(LISARunAction* runAct) : runAction(runAct){
SetAutoSeedCmd = new G4UIcmdWithABool("/run/autoSeed",this);
SetAutoSeedCmd->SetGuidance("Switch on/off time-based random seeds");
SetAutoSeedCmd->SetGuidance(" true: run seeds determined by system time");
SetAutoSeedCmd->SetGuidance("false: use command 'random/resetEngineFrom'");
SetAutoSeedCmd->SetGuidance("Default = false");
SetAutoSeedCmd->SetParameterName("autoSeed", false);
SetAutoSeedCmd->AvailableForStates(G4State_Idle);
}
LISARunActionMessenger::~LISARunActionMessenger() {
delete SetAutoSeedCmd;
}
void LISARunActionMessenger::SetNewValue
(G4UIcommand* command, G4String newValue) {
if(command == SetAutoSeedCmd) {
G4int vl;
const char* t = newValue;
std::istrstream is((char*)t);
is >> vl;
runAction->SetAutoSeed(vl!=0);
}
}
@@ -0,0 +1,500 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISADetectorConstruction class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
//**************************************************************************
// Science Module Structure (SMS)
//**************************************************************************
// Primary Structure
// Lower Deck
// Upper Deck
// Thermal Shield
// Solar Array
// Optical Solar Reflectors (OSR)
// Radiator Panels
//**************************************************************************
// Structure Tubes
G4double StructTube_dia = 100.*mm;
G4double StructTube_thi = 11.*mm;
G4double StructTube_hei = 490.*mm;
G4double StructTube_sep = 1480.*mm;
G4double StructTubeSpacer_dia = 200.*mm;
G4double StructTubeSpacer_thi = 50.*mm;
G4double StructTubeSpacer_hei = 16.*mm;
// Diagonal Panels
G4double DiagPanelSkin_thi = 0.5*mm;
G4double DiagPanelSkin_len = 1420.*mm;
G4double DiagPanelSkin_hei = 490.*mm;
G4double DiagPanelCore_thi = 19.*mm;
G4double DiagPanelCore_len = DiagPanelSkin_len;
G4double DiagPanelCore_hei = DiagPanelSkin_hei;
G4double DiagPanelCutout_dia = 466.*mm;
G4double DiagPanelCutout_off = 50.*mm;
// Radial Panels
G4double RadialPanelSkin_thi = 0.5*mm;
G4double RadialPanelSkin_hei = 490.*mm;
G4double RadialPanelSkin_top = 424.*mm;
G4double RadialPanelSkin_bot = 159.*mm;
G4double RadialPanelCore_thi = 19.*mm;
G4double RadialPanel_roff = 910.*mm;
// Upper and Lower Decks
G4double UpperDeck_dia = 2700.*mm;
G4double UpperDeckCore_thi = 29.0*mm;
G4double LowerDeckCore_thi = 29.0*mm;
G4double UpperDeck_zoff = 0.5*mm;
G4double UpperDeckSkin_thi = 0.5*mm;
G4double LowerDeck_dia = 2174.*mm;
G4double LowerDeckSkin_thi = 0.5*mm;
G4double LowerDeck_zoff = 0.5*mm;
G4double MLIBlanket_dia = LowerDeck_dia;
G4double MLIBlanket_thi = 1.0*mm;
// Thermal Shield
G4double ThermalShieldFacesheet_thi = 0.6*mm;
G4double ThermalShieldCore_thi = 20.*mm;
G4double ThermalShieldFoam_thi = 20.*mm;
G4double ThermalShield_zoff = StructTubeSpacer_hei;
G4double ThermalShield_thi = 3*ThermalShieldFacesheet_thi +
ThermalShieldCore_thi +
ThermalShieldFoam_thi;
// Solar Array and OSR Assy
G4double SolarArray_i = 0.5*1683*mm;
G4double SolarArray_o = 0.5*UpperDeck_dia;
G4double SolarArray_thi = 0.5*mm;
G4double OSRAssy_o = SolarArray_i;
G4double OSRAssy_thi = 0.5*mm;
// Radiator Panels
G4double RadPanel_top = UpperDeck_dia+12.*mm;
G4double RadPanel_bot = LowerDeck_dia+12.*mm;
G4double RadPanel_len = 510.*mm;
G4double RadPanel_thi = 1.25*mm;
G4double RadPanel_zoff = 20*mm;
G4double RadPanelCutout_roff = 0.5*(RadPanel_top+RadPanel_bot)/2.;
G4double RadPanelCutout1_dia = 466.*mm;
G4double RadPanelCutout1_len = 200.*mm;
G4double RadPanelCutout2_hei = 500.*mm;
G4double RadPanelCutout2_wid = 400.*mm;
G4double RadPanelCutout2_len = 400.*mm;
G4double RadPanelCutout2_zoff = 330.*mm;
// Structure Tubes **********************************************************
// Struct Tube: 2.16 kg
// (ID adjusted to make up for mass of missing top part of tube)
G4Tubs* StructTube_sol = new G4Tubs("StructTube_sol",
0.5*StructTube_dia-StructTube_thi, 0.5*StructTube_dia,
0.5*StructTube_hei, 0., 360.*deg);
G4LogicalVolume* StructTube_log = new G4LogicalVolume
(StructTube_sol, Al6061, "StructTube_log");
G4VPhysicalVolume* StructTube_phys;
StructTube_phys = new G4PVPlacement(0, spacecraft_pos +
G4ThreeVector(+0.5*StructTube_sep/cos(30.*deg),0,0),
"StructTube_phys", StructTube_log, wld_phys, false, 0);
StructTube_phys = new G4PVPlacement(0, spacecraft_pos +
G4ThreeVector(-0.5*StructTube_sep*tan(30.*deg),+0.5*StructTube_sep,0),
"StructTube_phys", StructTube_log, wld_phys, false, 1);
StructTube_phys = new G4PVPlacement(0, spacecraft_pos +
G4ThreeVector(-0.5*StructTube_sep*tan(30.*deg),-0.5*StructTube_sep,0),
"StructTube_phys", StructTube_log, wld_phys, false, 2);
StructTube_log->SetVisAttributes(sol_white_vat);
// Struct Tube Spacer: 1.0 kg
// (ID adjusted to include mass of missing TopCap)
G4Tubs* StructTubeSpacer_sol = new G4Tubs("StructTubeSpacer_sol",
0.5*StructTubeSpacer_dia-StructTubeSpacer_thi,
0.5*StructTubeSpacer_dia, 0.5*StructTubeSpacer_hei, 0., 360.*deg);
G4LogicalVolume* StructTubeSpacer_log = new G4LogicalVolume
(StructTubeSpacer_sol, Al6061, "StructTubeSpacer_log");
G4VPhysicalVolume* StructTubeSpacer_phys;
StructTubeSpacer_phys = new G4PVPlacement
(0, spacecraft_pos + G4ThreeVector(+0.5*StructTube_sep/cos(30.*deg),0,
+0.5*StructTube_hei+UpperDeckCore_thi+2*UpperDeckSkin_thi
+0.5*StructTubeSpacer_hei+UpperDeck_zoff),
"StructTubeSpacer_phys", StructTubeSpacer_log, wld_phys, false, 0);
StructTubeSpacer_phys = new G4PVPlacement
(0, spacecraft_pos + G4ThreeVector(-0.5*StructTube_sep*tan(30.*deg),
+0.5*StructTube_sep, +0.5*StructTube_hei+UpperDeckCore_thi
+2*UpperDeckSkin_thi+0.5*StructTubeSpacer_hei+UpperDeck_zoff),
"StructTubeSpacer_phys", StructTubeSpacer_log, wld_phys, false, 1);
StructTubeSpacer_phys = new G4PVPlacement
(0, spacecraft_pos + G4ThreeVector(-0.5*StructTube_sep*tan(30.*deg),
-0.5*StructTube_sep,+0.5*StructTube_hei+UpperDeckCore_thi
+2*UpperDeckSkin_thi+0.5*StructTubeSpacer_hei+UpperDeck_zoff),
"StructTubeSpacer_phys", StructTubeSpacer_log, wld_phys, false, 2);
StructTubeSpacer_log->SetVisAttributes(sol_grey_vat);
// Diagonal Panels **********************************************************
// Diagonal Panel: core (x3)
// Honeycomb core is represented by Al6061 at 0.05 g/cm3
G4Box* DiagPanelCore_box = new G4Box("DiagPanelCore_box",
0.5*DiagPanelCore_len-2.*cm, 0.5*DiagPanelCore_thi, 0.5*DiagPanelCore_hei);
G4Tubs* DiagPanelCutout_tub = new G4Tubs("DiagPanelCutout_tub", 0.,
0.5*DiagPanelCutout_dia, 2*DiagPanelCore_thi, 0., 360.*deg);
G4UnionSolid* DiagPanelCutout_sol = new G4UnionSolid("DiagPanelCutout_sol",
DiagPanelCutout_tub, DiagPanelCutout_tub,
G4Transform3D(G4RotationMatrix(), G4ThreeVector(DiagPanelCutout_off,0,0)));
G4RotationMatrix SMS_rot1; SMS_rot1.rotateX(90.*deg);
G4SubtractionSolid* DiagPanelCore_sol =
new G4SubtractionSolid("DiagPanelCore_sol", DiagPanelCore_box,
DiagPanelCutout_sol, G4Transform3D(SMS_rot1,
G4ThreeVector(-0.5*DiagPanelCutout_off,0,0)));
G4LogicalVolume* DiagPanelCore_log = new G4LogicalVolume
(DiagPanelCore_sol, AlHoneycomb, "DiagPanelCore_log");
G4VPhysicalVolume* DiagPanelCore_phys;
G4RotationMatrix SMS_rot2; SMS_rot2.rotateZ(90.*deg);
DiagPanelCore_phys = new G4PVPlacement(G4Transform3D(SMS_rot2,
spacecraft_pos + G4ThreeVector(-0.5*DiagPanelCore_len*tan(30.*deg),0,0)),
"DiagPanelCore_phys", DiagPanelCore_log, wld_phys, false, 0);
G4RotationMatrix SMS_rot3; SMS_rot3.rotateZ(-30.*deg);
DiagPanelCore_phys = new G4PVPlacement(G4Transform3D(SMS_rot3,
spacecraft_pos + G4ThreeVector
(.5*DiagPanelCore_len*sin(30.*deg)*tan(30.*deg),
0.5*DiagPanelCore_len*sin(30.*deg),0)), "DiagPanelCore_phys",
DiagPanelCore_log, wld_phys, false, 1);
G4RotationMatrix SMS_rot4; SMS_rot4.rotateZ(+30.*deg);
DiagPanelCore_phys = new G4PVPlacement(G4Transform3D(SMS_rot4,
spacecraft_pos + G4ThreeVector
(0.5*DiagPanelCore_len*sin(30*deg)*tan(30*deg),
-0.5*DiagPanelCore_len*sin(30.*deg),0)),
"DiagPanelCore_phys", DiagPanelCore_log, wld_phys, false, 2);
DiagPanelCore_log->SetVisAttributes(sol_white_vat);
// Diagonal Panel: skins (x6)
G4Box* DiagPanelSkin_box = new G4Box("DiagPanelSkin_box",
0.5*DiagPanelSkin_len-2.*cm, 0.5*DiagPanelSkin_thi, 0.5*DiagPanelSkin_hei);
G4SubtractionSolid* DiagPanelSkin_sol =
new G4SubtractionSolid("DiagPanelSkin_sol", DiagPanelSkin_box,
DiagPanelCutout_sol, G4Transform3D(SMS_rot1,
G4ThreeVector(-0.5*DiagPanelCutout_off,0,0)));
G4LogicalVolume* DiagPanelSkin_log = new G4LogicalVolume
(DiagPanelSkin_sol, CFRP, "DiagPanelSkin_log");
G4VPhysicalVolume* DiagPanelSkin_phys;
DiagPanelSkin_phys = new G4PVPlacement(G4Transform3D(SMS_rot2,
spacecraft_pos + G4ThreeVector(-0.5*DiagPanelCore_len*tan(30.*deg) +
0.5*(DiagPanelCore_thi+DiagPanelSkin_thi),0,0)),
"DiagPanelSkin_phys", DiagPanelSkin_log, wld_phys, false, 0);
DiagPanelSkin_phys = new G4PVPlacement(G4Transform3D(SMS_rot2,
spacecraft_pos + G4ThreeVector(-0.5*DiagPanelCore_len*tan(30.*deg) -
0.5*(DiagPanelCore_thi+DiagPanelSkin_thi),0,0)),
"DiagPanelSkin_phys", DiagPanelSkin_log, wld_phys, false, 1);
DiagPanelSkin_phys = new G4PVPlacement(G4Transform3D(SMS_rot3,
spacecraft_pos + G4ThreeVector
(0.5*DiagPanelCore_len*sin(30*deg)*tan(30*deg),
0.5*DiagPanelCore_len*sin(30.*deg),0) +
G4ThreeVector(0.5*(DiagPanelCore_thi+DiagPanelSkin_thi)*sin(30.*deg),
0.5*(DiagPanelCore_thi+DiagPanelSkin_thi)*cos(30.*deg),0)),
"DiagPanelSkin_phys", DiagPanelSkin_log, wld_phys, false, 2);
DiagPanelSkin_phys = new G4PVPlacement(G4Transform3D(SMS_rot3,
spacecraft_pos + G4ThreeVector
(0.5*DiagPanelCore_len*sin(30*deg)*tan(30*deg),
0.5*DiagPanelCore_len*sin(30.*deg),0) +
G4ThreeVector(-0.5*(DiagPanelCore_thi+DiagPanelSkin_thi)*sin(30.*deg),
-0.5*(DiagPanelCore_thi+DiagPanelSkin_thi)*cos(30.*deg),0)),
"DiagPanelSkin_phys", DiagPanelSkin_log, wld_phys, false, 3);
DiagPanelSkin_phys = new G4PVPlacement(G4Transform3D(SMS_rot4,
spacecraft_pos + G4ThreeVector
(0.5*DiagPanelCore_len*sin(30*deg)*tan(30*deg),
-0.5*DiagPanelCore_len*sin(30.*deg),0) +
G4ThreeVector(0.5*(DiagPanelCore_thi+DiagPanelSkin_thi)*sin(30.*deg),
-0.5*(DiagPanelCore_thi+DiagPanelSkin_thi)*cos(30.*deg),0)),
"DiagPanelSkin_phys", DiagPanelSkin_log, wld_phys, false, 3);
DiagPanelSkin_phys = new G4PVPlacement(G4Transform3D(SMS_rot4,
spacecraft_pos + G4ThreeVector
(0.5*DiagPanelCore_len*sin(30*deg)*tan(30*deg),
-0.5*DiagPanelCore_len*sin(30.*deg),0) +
G4ThreeVector(-0.5*(DiagPanelCore_thi+DiagPanelSkin_thi)*sin(30.*deg),
+0.5*(DiagPanelCore_thi+DiagPanelSkin_thi)*cos(30.*deg),0)),
"DiagPanelSkin_phys", DiagPanelSkin_log, wld_phys, false, 4);
DiagPanelSkin_log->SetVisAttributes(sol_white_vat);
// Radial Panels ************************************************************
// Radial Panels: skins (x3)
G4Trap* RadialPanelSkin_sol = new G4Trap("RadialPanelSkin_sol",
2*RadialPanelSkin_thi+RadialPanelCore_thi, RadialPanelSkin_hei,
RadialPanelSkin_top, RadialPanelSkin_bot);
G4LogicalVolume* RadialPanelSkin_log = new G4LogicalVolume
(RadialPanelSkin_sol, CFRP, "RadialPanelSkin_log");
G4VPhysicalVolume* RadialPanelSkin_phys;
G4RotationMatrix SMS_rot5; SMS_rot5.rotateX(-90.*deg);
RadialPanelSkin_phys = new G4PVPlacement
(G4Transform3D(SMS_rot5, spacecraft_pos +
G4ThreeVector(+RadialPanel_roff/cos(30.*deg),0,0)),
"RadialPanelSkin_phys", RadialPanelSkin_log, wld_phys, false, 0);
G4RotationMatrix SMS_rot6;
SMS_rot6.rotateX(-90.*deg); SMS_rot6.rotateZ(120.*deg);
RadialPanelSkin_phys = new G4PVPlacement
(G4Transform3D(SMS_rot6, spacecraft_pos +
G4ThreeVector(-RadialPanel_roff*tan(30.*deg),+RadialPanel_roff,0)),
"RadialPanelSkin_phys", RadialPanelSkin_log, wld_phys, false, 1);
G4RotationMatrix SMS_rot7;
SMS_rot7.rotateX(-90.*deg); SMS_rot7.rotateZ(-120.*deg);
RadialPanelSkin_phys = new G4PVPlacement
(G4Transform3D(SMS_rot7, spacecraft_pos +
G4ThreeVector(-RadialPanel_roff*tan(30.*deg),-RadialPanel_roff,0)),
"RadialPanelSkin_phys", RadialPanelSkin_log, wld_phys, false, 2);
RadialPanelSkin_log->SetVisAttributes(sol_white_vat);
// Radial Panels: core
// Honeycomb core is represented by Al6061 at 0.05 g/cm3
G4Trap* RadialPanelCore_sol = new G4Trap("RadialPanelCore_sol",
RadialPanelCore_thi, RadialPanelSkin_hei,
RadialPanelSkin_top, RadialPanelSkin_bot);
G4LogicalVolume* RadialPanelCore_log = new G4LogicalVolume
(RadialPanelCore_sol, AlHoneycomb, "RadialPanelCore_log");
G4VPhysicalVolume* RadialPanelCore_phys = new G4PVPlacement
(0, G4ThreeVector(0,0,0), "RadialPanelCore_phys",
RadialPanelCore_log, RadialPanelSkin_phys, false, 0);
RadialPanelCore_log->SetVisAttributes(sol_white_vat);
// Upper and Lower Decks ****************************************************
// Upper Deck - skin: 2*4.56 kg
G4Tubs* UpperDeckSkin_sol = new G4Tubs
("UpperDeckSkin_sol", 0., 0.5*UpperDeck_dia,
0.5*UpperDeckCore_thi + UpperDeckSkin_thi, 0., 360.*deg);
G4LogicalVolume* UpperDeckSkin_log = new G4LogicalVolume
(UpperDeckSkin_sol, CFRP, "UpperDeckSkin_log");
G4VPhysicalVolume* UpperDeckSkin_phys = new G4PVPlacement
(0, spacecraft_pos + G4ThreeVector(0,0,+0.5*StructTube_hei
+0.5*UpperDeckCore_thi+UpperDeckSkin_thi+UpperDeck_zoff),
"UpperDeckSkin_phys", UpperDeckSkin_log, wld_phys, false, 0);
UpperDeckSkin_log->SetVisAttributes(white_vat);
// upper deck - core: 8.3 kg
// Honeycomb core is represented by Al6061 at 0.05 g/cm3
G4Tubs* UpperDeckCore_sol = new G4Tubs
("UpperDeckCore_sol",0.,.5*UpperDeck_dia,.5*UpperDeckCore_thi,0.,360.*deg);
G4LogicalVolume* UpperDeckCore_log = new G4LogicalVolume
(UpperDeckCore_sol, AlHoneycomb, "UpperDeckCore_log");
G4VPhysicalVolume* UpperDeckCore_phys = new G4PVPlacement(0,G4ThreeVector(),
"UpperDeckCore_phys", UpperDeckCore_log, UpperDeckSkin_phys, false, 0);
UpperDeckCore_log->SetVisAttributes(white_vat);
// Lower Deck - skin: 2*2.95 kg
G4Tubs* LowerDeckSkin_sol = new G4Tubs
("LowerDeckSkin_sol", 0., 0.5*LowerDeck_dia,
0.5*LowerDeckCore_thi + LowerDeckSkin_thi, 0., 360.*deg);
G4LogicalVolume* LowerDeckSkin_log = new G4LogicalVolume
(LowerDeckSkin_sol, CFRP, "LowerDeckSkin_log");
G4VPhysicalVolume* LowerDeckSkin_phys = new G4PVPlacement
(0, spacecraft_pos + G4ThreeVector(0,0,-0.5*StructTube_hei
-0.5*LowerDeckCore_thi-LowerDeckSkin_thi-LowerDeck_zoff),
"LowerDeckSkin_phys", LowerDeckSkin_log, wld_phys, false, 0);
LowerDeckSkin_log->SetVisAttributes(sol_dgrey_vat);
// lower deck - core: 5.38 kg
// Honeycomb core is represented by Al6061 at 0.05 g/cm3
G4Tubs* LowerDeckCore_sol = new G4Tubs
("LowerDeckCore_sol",0.,.5*LowerDeck_dia,.5*LowerDeckCore_thi,0.,360.*deg);
G4LogicalVolume* LowerDeckCore_log = new G4LogicalVolume
(LowerDeckCore_sol, AlHoneycomb, "LowerDeckCore_log");
G4VPhysicalVolume* LowerDeckCore_phys = new G4PVPlacement(0,G4ThreeVector(),
"LowerDeckCore_phys", LowerDeckCore_log, LowerDeckSkin_phys, false, 0);
LowerDeckCore_log->SetVisAttributes(sol_dgrey_vat);
// Lower Deck MLI Blanket: 5.3 kg
G4Tubs* MLIBlanket_sol = new G4Tubs("MLIBlanket_sol",
0., 0.5*MLIBlanket_dia, 0.5*MLIBlanket_thi, 0., 360.*deg);
G4LogicalVolume* MLIBlanket_log = new G4LogicalVolume
(MLIBlanket_sol, MLImat, "MLIBlanket_log");
G4VPhysicalVolume* MLIBlanket_phys = new G4PVPlacement
(0, spacecraft_pos + G4ThreeVector(0,0,-0.5*StructTube_hei
-LowerDeckCore_thi-2*LowerDeckSkin_thi-LowerDeck_zoff-.5*MLIBlanket_thi),
"MLIBlanket_phys", MLIBlanket_log, wld_phys, false, 0);
MLIBlanket_log->SetVisAttributes(sol_orange_vat);
// Thermal Shield ***********************************************************
// Thermal Shield (Facesheet+HoneycombCore+Facesheet+Foam+Facesheet)
// Thermal Shield - facesheet: 3*5.47 kg
G4Tubs* ThermalShieldFacesheet_sol = new G4Tubs("ThermalShieldFacesheet_sol",
0., 0.5*UpperDeck_dia, 0.5*ThermalShield_thi, 0., 360.*deg);
G4LogicalVolume* ThermalShieldFacesheet_log = new G4LogicalVolume
(ThermalShieldFacesheet_sol, CFRP, "ThermalShieldFacesheet_log");
G4VPhysicalVolume* ThermalShieldFacesheet_phys = new G4PVPlacement(0,
spacecraft_pos + G4ThreeVector
(0,0,+.5*StructTube_hei+UpperDeckCore_thi+2*UpperDeckSkin_thi+
UpperDeck_zoff+0.5*ThermalShield_thi+ThermalShield_zoff),
"ThermalShieldFacesheet_phys",ThermalShieldFacesheet_log,wld_phys,false,0);
ThermalShieldFacesheet_log->SetVisAttributes(red_vat);
// Thermal Shield: core
// Honeycomb core is represented by Al6061 at 0.05 g/cm3
G4Tubs* ThermalShieldCore_sol = new G4Tubs("ThermalShieldCore_sol",
0., 0.5*UpperDeck_dia, 0.5*ThermalShieldCore_thi, 0., 360.*deg);
G4LogicalVolume* ThermalShieldCore_log = new G4LogicalVolume
(ThermalShieldCore_sol, AlHoneycomb, "ThermalShieldCore_log");
G4VPhysicalVolume* ThermalShieldCore_phys = new G4PVPlacement(0,
G4ThreeVector(0,0,.5*ThermalShieldFacesheet_thi+.5*ThermalShieldCore_thi),
"ThermalShieldCore_phys", ThermalShieldCore_log,
ThermalShieldFacesheet_phys, false, 0);
ThermalShieldCore_log->SetVisAttributes(red_vat);
// Thermal Shield: foam
G4Tubs* ThermalShieldFoam_sol = new G4Tubs("ThermalShieldFoam_sol",
0., 0.5*UpperDeck_dia, 0.5*ThermalShieldFoam_thi, 0., 360.*deg);
G4LogicalVolume* ThermalShieldFoam_log = new G4LogicalVolume
(ThermalShieldFoam_sol, foam, "ThermalShieldFoam_log");
G4VPhysicalVolume* ThermalShieldFoam_phys = new G4PVPlacement(0,
G4ThreeVector(0,0,-.5*ThermalShieldFacesheet_thi-.5*ThermalShieldFoam_thi),
"ThermalShieldFoam_phys", ThermalShieldFoam_log,
ThermalShieldFacesheet_phys, false, 0);
ThermalShieldFoam_log->SetVisAttributes(red_vat);
// Solar Array and OSR Assy *************************************************
// Solar Array: 13.5 kg
// Thickness for correct mass
G4Tubs* SolarArray_sol = new G4Tubs("SolarArray_sol",
SolarArray_i, SolarArray_o, 0.5*SolarArray_thi, 0., 360.*deg);
G4LogicalVolume* SolarArray_log = new G4LogicalVolume
(SolarArray_sol, Scell, "SolarArray_log");
G4VPhysicalVolume* SolarArray_phys = new G4PVPlacement(0, spacecraft_pos +
G4ThreeVector(0,0,+.5*StructTube_hei+UpperDeckCore_thi+2*UpperDeckSkin_thi+
UpperDeck_zoff+ThermalShield_thi+ThermalShield_zoff+0.5*SolarArray_thi),
"SolarArray_phys",SolarArray_log, wld_phys, false, 0);
SolarArray_log->SetVisAttributes(lblue_vat);
// Optical Solar Reflector: NO MASS
G4Tubs* OSRAssy_sol = new G4Tubs("OSRAssy_sol",
0., OSRAssy_o, 0.5*OSRAssy_thi, 0., 360.*deg);
G4LogicalVolume* OSRAssy_log = new G4LogicalVolume
(OSRAssy_sol, vacuum, "OSRAssy_log");
G4VPhysicalVolume* OSRAssy_phys = new G4PVPlacement(0, spacecraft_pos +
G4ThreeVector(0,0,+.5*StructTube_hei+UpperDeckCore_thi+2*UpperDeckSkin_thi+
UpperDeck_zoff+ThermalShield_thi+ThermalShield_zoff+0.5*OSRAssy_thi),
"OSRAssy_phys",OSRAssy_log, wld_phys, false, 0);
OSRAssy_log->SetVisAttributes(lblue_vat);
// Radiator Panels **********************************************************
// Radiator Panels: 3*3.87 kg
// Thickess adjusted for correct mass of FS+Core+FS
G4Cons* RadPanel_con = new G4Cons("RadPanel_con",
0.5*RadPanel_bot-RadPanel_thi, 0.5*RadPanel_bot,
0.5*RadPanel_top-RadPanel_thi, 0.5*RadPanel_top,
0.5*RadPanel_len, 0.*deg, 360.*deg);
// window cutouts
G4Tubs* RadPanelCutout_tub = new G4Tubs("RadPanelCutout_tub", 0.,
0.5*RadPanelCutout1_dia, 2*RadPanelCutout1_len, 0., 360.*deg);
G4RotationMatrix SMS_rot8; SMS_rot8.rotateY(90.*deg);
G4SubtractionSolid* RadPanel1_sol =
new G4SubtractionSolid("RadPanel1_sol", RadPanel_con,
RadPanelCutout_tub, G4Transform3D(SMS_rot8,
G4ThreeVector(-RadPanelCutout_roff,0,0)));
G4RotationMatrix SMS_rot9;
SMS_rot9.rotateY(90.*deg); SMS_rot9.rotateZ(49.*deg);
G4SubtractionSolid* RadPanel2_sol =
new G4SubtractionSolid("RadPanel2_sol", RadPanel1_sol,
RadPanelCutout_tub, G4Transform3D(SMS_rot9, G4ThreeVector
(RadPanelCutout_roff*sin(49.*deg),RadPanelCutout_roff*cos(49.*deg),0)));
G4RotationMatrix SMS_rot10;
SMS_rot10.rotateY(90.*deg); SMS_rot10.rotateZ(131.*deg);
G4SubtractionSolid* RadPanel3_sol =
new G4SubtractionSolid("RadPanel3_sol", RadPanel2_sol,
RadPanelCutout_tub, G4Transform3D(SMS_rot10, G4ThreeVector
(RadPanelCutout_roff*sin(131.*deg),RadPanelCutout_roff*cos(131.*deg),0)));
// box cutouts
G4Box* RadPanelCutout_box = new G4Box("RadPanelCutout_box",
0.5*RadPanelCutout2_len, 0.5*RadPanelCutout2_wid, 0.5*RadPanelCutout2_hei);
G4SubtractionSolid* RadPanel4_sol =
new G4SubtractionSolid("RadPanel4_sol", RadPanel3_sol,
RadPanelCutout_box, G4Transform3D(G4RotationMatrix(), G4ThreeVector
(RadPanelCutout_roff,0,RadPanelCutout2_zoff)));
G4RotationMatrix SMS_rot11; SMS_rot11.rotateZ(+120.*deg);
G4SubtractionSolid* RadPanel5_sol =
new G4SubtractionSolid("RadPanel5_sol", RadPanel4_sol,
RadPanelCutout_box, G4Transform3D(SMS_rot11,
G4ThreeVector(RadPanelCutout_roff*cos(120.*deg),
RadPanelCutout_roff*sin(120.*deg), RadPanelCutout2_zoff)));
G4RotationMatrix SMS_rot12; SMS_rot12.rotateZ(-120.*deg);
G4SubtractionSolid* RadPanel6_sol =
new G4SubtractionSolid("RadPanel6_sol", RadPanel5_sol,
RadPanelCutout_box, G4Transform3D(SMS_rot12,
G4ThreeVector(RadPanelCutout_roff*cos(-120.*deg),
RadPanelCutout_roff*sin(-120.*deg), RadPanelCutout2_zoff)));
G4LogicalVolume* RadPanel_log =
new G4LogicalVolume(RadPanel6_sol, Al6061, "RadPanel_log");
G4VPhysicalVolume* RadPanel_phys =
new G4PVPlacement(0, spacecraft_pos + G4ThreeVector(0,0,0),
"RadPanel_phys", RadPanel_log, wld_phys, false, 0);
RadPanel_log->SetVisAttributes(sol_white_vat);
//*****************************************************************************
// invisible spacecraft top
if(0) {
UpperDeckSkin_log->SetVisAttributes(G4VisAttributes::Invisible);
UpperDeckCore_log->SetVisAttributes(G4VisAttributes::Invisible);
ThermalShieldFacesheet_log->SetVisAttributes(G4VisAttributes::Invisible);
ThermalShieldCore_log->SetVisAttributes(G4VisAttributes::Invisible);
ThermalShieldFoam_log->SetVisAttributes(G4VisAttributes::Invisible);
// SolarArray_log->SetVisAttributes(G4VisAttributes::Invisible);
OSRAssy_log->SetVisAttributes(G4VisAttributes::Invisible);
}
// solid spacecraft top
if(0) {
UpperDeckSkin_log->SetVisAttributes(sol_white_vat);
UpperDeckCore_log->SetVisAttributes(sol_white_vat);
ThermalShieldFacesheet_log->SetVisAttributes(sol_red_vat);
ThermalShieldCore_log->SetVisAttributes(sol_red_vat);
ThermalShieldFoam_log->SetVisAttributes(sol_red_vat);
SolarArray_log->SetVisAttributes(sol_lblue_vat);
OSRAssy_log->SetVisAttributes(sol_lgreen_vat);
}
//*****************************************************************************
@@ -0,0 +1,101 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISADetectorConstruction class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
//*************************************************************************
// Sensor Vacuum Housing (TiAlloy)
// Modified to contain LTP Inertial Sensor and Caging Mechanism
//*************************************************************************
// Sensor housing
G4double SensorHousing_thi = 5.0*mm;
G4double SensorHousing_yoff = +30.0*mm;
// original dimentions
// G4double SensorHousing_len = 170.0*mm;
// G4double SensorHousing_wid = 120.0*mm;
// G4double SensorHousing_hei = 120.0*mm;
G4double SensorHousing_dia = 125.0*mm;
G4double SensorHousing_hei = 224.0*mm;
// Sensor vacuum housing ****************************************************
// // Outer dimensions as shown in Solid Model Document
// G4Box* SensorHousing_o_sol = new G4Box("SensorHousing_o_sol",
// 0.5*SensorHousing_len, 0.5*SensorHousing_hei, 0.5*SensorHousing_wid);
// G4LogicalVolume* SensorHousing_o_log =
// new G4LogicalVolume(SensorHousing_o_sol, TiAlloy,"SensorHousing_o_log");
// G4VPhysicalVolume* SensorHousing_o_phys = new G4PVPlacement(G4Transform3D
// (IS_rot, G4ThreeVector(0,SensorHousing_yoff,OpticalBench_off)),
// "SensorHousing_o_phys", SensorHousing_o_log, wld_phys, false, 0);
// G4Box* SensorHousing_i_sol = new G4Box("SensorHousing_i_sol",
// 0.5*SensorHousing_len-SensorHousing_thi,
// 0.5*SensorHousing_hei-SensorHousing_thi,
// 0.5*SensorHousing_wid-SensorHousing_thi);
// G4LogicalVolume* SensorHousing_i_log =
// new G4LogicalVolume(SensorHousing_i_sol, vacuum, "SensorHousing_i_log");
// G4VPhysicalVolume* SensorHousing_i_phys = new G4PVPlacement
// (0, G4ThreeVector(0,0,0), "SensorHousing_i_phys",
// SensorHousing_i_log, SensorHousing_o_phys, false, 0);
// SensorHousing_o_log->SetVisAttributes(blue_vat);
// SensorHousing_i_log->SetVisAttributes(blue_vat);
// Modified to contain LTP Inertial Sensor and Caging Mechanism
G4Tubs* SensorHousing_o_sol = new G4Tubs("SensorHousing_o_sol",
0., 0.5*SensorHousing_dia, 0.5*SensorHousing_hei, 0., 360.*deg);
G4LogicalVolume* SensorHousing_o_log =
new G4LogicalVolume(SensorHousing_o_sol, TiAlloy, "SensorHousing_o_log");
G4VPhysicalVolume* SensorHousing_o_phys = new G4PVPlacement(G4Transform3D
(IS_rot, G4ThreeVector(0,SensorHousing_yoff,OpticalBench_off)),
"SensorHousing_o_phys", SensorHousing_o_log, TelBox_phys, false, 0);
G4Tubs* SensorHousing_i_sol = new G4Tubs("SensorHousing_i_sol",
0., 0.5*SensorHousing_dia - SensorHousing_thi, 0.5*SensorHousing_hei
- SensorHousing_thi, 0., 360.*deg);
G4LogicalVolume* SensorHousing_i_log =
new G4LogicalVolume(SensorHousing_i_sol, vacuum, "SensorHousing_i_log");
G4VPhysicalVolume* SensorHousing_i_phys = new G4PVPlacement
(0, G4ThreeVector(0,0,0), "SensorHousing_i_phys",
SensorHousing_i_log, SensorHousing_o_phys, false, 0);
SensorHousing_o_log->SetVisAttributes(blue_vat);
SensorHousing_i_log->SetVisAttributes(blue_vat);
//*****************************************************************************
@@ -0,0 +1,164 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISAStackingAction class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
#include "LISAStackingAction.hh"
#include "LISAStackingActionMessenger.hh"
#include "G4Track.hh"
#include "G4TrackStatus.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTypes.hh"
#include <fstream>
LISAStackingAction::LISAStackingAction() {
// messenger defaults
PrimarySurveyFlag = false;
ParticleSurveyFlag = false;
// create messenger
stackingMessenger = new LISAStackingActionMessenger(this);
}
LISAStackingAction::~LISAStackingAction() {
delete stackingMessenger;
}
G4ClassificationOfNewTrack LISAStackingAction::ClassifyNewTrack
(const G4Track* aTrack) {
// write primary spectrum to file
if(PrimarySurveyFlag) {
if(!aTrack->GetParentID()) {
G4double energy = aTrack->GetKineticEnergy();
std::ofstream primaries("primaries.out",std::ios::app);
primaries << energy/MeV << G4endl;
return (G4ClassificationOfNewTrack) fKill;
}
}
// Particle Survey
if(ParticleSurveyFlag) {
G4String particle = aTrack->GetDefinition()->GetParticleName();
G4double energy = aTrack->GetKineticEnergy();
//
// gammas above 1 MeV
if(particle=="gamma" && energy>1*MeV) {
std::ofstream gammas("gammas.out",std::ios::app);
gammas << energy/MeV << G4endl;
}
// electrons and positrons above 1 MeV
else if((particle=="e-" || particle=="e+") && energy>1.*MeV) {
std::ofstream electrons("electrons.out",std::ios::app);
electrons << energy/MeV << G4endl;
}
// delta electrons
// else if(particle=="e-" && aTrack->GetParentID()>0) {
// std::ofstream deltas("deltas.out",std::ios::app);
// deltas << energy/eV << G4endl;
// return (G4ClassificationOfNewTrack) fKill;
// }
//
// neutrons
else if(particle=="neutron") {
std::ofstream neutrons("neutrons.out",std::ios::app);
neutrons << energy/MeV << G4endl;
}
// pions
else if(particle=="pi+" || particle=="pi-" || particle=="pi0") {
std::ofstream pions("pions.out",std::ios::app);
pions << energy/MeV << G4endl;
}
// fragments (energy per nucleon)
else if(particle=="deuteron" || particle=="triton" ||
particle=="He3" || particle=="alpha") {
G4int A = aTrack->GetDefinition()->GetBaryonNumber();
std::ofstream fragments("fragments.out",std::ios::app);
fragments << energy/A/MeV << G4endl;
}
// muons
else if(particle=="mu+" || particle=="mu-") {
std::ofstream muons("muons.out",std::ios::app);
muons << energy/MeV << G4endl;
}
// kaons
else if(particle=="kaon+" || particle=="kaon-" ||
particle=="kaon0S" || particle=="kaon0L" ) {
std::ofstream kaons("kaons.out",std::ios::app);
kaons << energy/MeV << G4endl;
}
// nuclei (energy per nucleon)
else if(aTrack->GetDefinition()->GetParticleType()=="nucleus") {
G4int A = aTrack->GetDefinition()->GetBaryonNumber();
std::ofstream nuclei("nuclei.out",std::ios::app);
nuclei << energy/A/MeV << "\t" << particle << G4endl;
}
// others
else if(particle!="proton" && energy>1.*MeV) {
std::ofstream others("others.out",std::ios::app);
others << energy/MeV << "\t" << particle << G4endl;
}
}
return (G4ClassificationOfNewTrack) fWaiting;
}
void LISAStackingAction::NewStage() {;}
void LISAStackingAction::PrepareNewEvent() {;}
@@ -0,0 +1,107 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISAStackingActionMessenger class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
#include "LISAStackingActionMessenger.hh"
#include "LISAStackingAction.hh"
LISAStackingActionMessenger::LISAStackingActionMessenger
(LISAStackingAction* stackAct) : stackingAction(stackAct){
// set flag for primaries survey
SetPriSurvey = new G4UIcmdWithABool("/surveys/surveyPrimaries",this);
SetPriSurvey->SetGuidance
("Dump primary energies (MeV) to file 'primaries.out'");
SetPriSurvey->SetGuidance("Default = false");
SetPriSurvey->SetParameterName("SurveyPrimariesFlag", false);
SetPriSurvey->AvailableForStates(G4State_Idle);
// set flag for particle survey
SetPartSurvey = new G4UIcmdWithABool("/surveys/surveyParticles",this);
SetPartSurvey->SetGuidance("Dump particle energies to different files");
SetPartSurvey->SetGuidance("Fragments and nuclei in MeV/nucleon, other in MeV.");
SetPartSurvey->SetGuidance("'gammas.out': gammas above 1 MeV");
SetPartSurvey->SetGuidance("'electrons.out': e- and e+ above 1 MeV");
SetPartSurvey->SetGuidance("'neutrons.out': all neutrons");
SetPartSurvey->SetGuidance("'pions.out': all pions");
SetPartSurvey->SetGuidance("'muons.out': all muons");
SetPartSurvey->SetGuidance("'kaons.out': all kaons");
SetPartSurvey->SetGuidance("'fragments.out': 2H, 3H, He3, alphas");
SetPartSurvey->SetGuidance("'nuclei.out': all nuclei");
SetPartSurvey->SetGuidance("'others.out': others above 1 MeV");
SetPartSurvey->SetGuidance("Default = false");
SetPartSurvey->SetParameterName("SurveyParticlesFlag", false);
SetPartSurvey->AvailableForStates(G4State_Idle);
}
LISAStackingActionMessenger::~LISAStackingActionMessenger() {
delete SetPriSurvey;
delete SetPartSurvey;
}
void LISAStackingActionMessenger::SetNewValue
(G4UIcommand* command, G4String newValue) {
if(command == SetPriSurvey) {
G4int vl;
const char* t = newValue;
std::istrstream is((char*)t);
is >> vl;
stackingAction->SetPrimarySurvey(vl!=0);
}
else if(command == SetPartSurvey) {
G4int vl;
const char* t = newValue;
std::istrstream is((char*)t);
is >> vl;
stackingAction->SetParticleSurvey(vl!=0);
}
}
@@ -0,0 +1,178 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISASteppingAction class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
#include "LISASteppingAction.hh"
#include "LISASteppingActionMessenger.hh"
#include "G4Step.hh"
#include "G4Track.hh"
#include "G4TrackStatus.hh"
#include "G4StepPoint.hh"
#include "G4ParticleDefinition.hh"
#include "G4DynamicParticle.hh"
#include "G4ParticleTypes.hh"
#include "G4VPhysicalVolume.hh"
#include "G4VTouchable.hh"
#include "G4TouchableHistory.hh"
#include "globals.hh"
#include "G4ios.hh"
#include <fstream>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
LISASteppingAction::LISASteppingAction() {
charge_in[0] = 0;
charge_in[1] = 0;
charge_out[0] = 0;
charge_out[1] = 0;
// defaults
FlagSpectrum = false;
// create messenger
steppingMessenger = new LISASteppingActionMessenger(this);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
LISASteppingAction::~LISASteppingAction() {
delete steppingMessenger;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void LISASteppingAction::UserSteppingAction(const G4Step* fStep) {
if(fStep->GetTrack()->GetNextVolume()) {
// step points
G4TouchableHistory* thePreTouchable =
(G4TouchableHistory*)(fStep->GetPreStepPoint()->GetTouchable());
G4TouchableHistory* thePostTouchable =
(G4TouchableHistory*)(fStep->GetPostStepPoint()->GetTouchable());
G4String PreVol = thePreTouchable->GetVolume()->GetName();
G4String PosVol = thePostTouchable->GetVolume()->GetName();
// particle
G4double charge = fStep->GetTrack()->GetDefinition()->GetPDGCharge();
G4String pName = fStep->GetTrack()->GetDefinition()->GetParticleName();
G4double energy = fStep->GetTrack()->GetKineticEnergy();
G4int tm = -1;
// *** entering a test mass ***
if(PreVol!="tmass_phys" && PosVol=="tmass_phys") {
tm = thePostTouchable->GetReplicaNumber(6);
charge_in[tm] += (int)charge;
// energy spectra at test-mass boundary
if(FlagSpectrum) {
// electrons entering test mass
if(pName=="e-") {
std::ofstream electrons_in("electrons_in.out",std::ios::app);
electrons_in << energy/eV << G4endl;
}
// hadrons entering test mass
else if(pName=="proton" ||
pName=="pi+" || pName=="pi-" ||
pName=="deuteron" || pName=="He3" ||
pName=="alpha" || pName=="triton") {
std::ofstream hadrons_in("hadrons_in.out",std::ios::app);
hadrons_in << energy/eV << G4endl;
}
}
} // *** entering a test mass ***
// *** leaving a test mass ***
else if(PreVol!=PosVol && PreVol=="tmass_phys") {
tm = thePreTouchable->GetReplicaNumber(6);
charge_out[tm] += (int)charge;
// energy spectra at test-mass boundary
if(FlagSpectrum) {
// electrons leaving test mass
if(pName=="e-") {
std::ofstream electrons_out("electrons_out.out",std::ios::app);
electrons_out << energy/eV << G4endl;
}
// hadrons leaving test mass
else if(pName=="proton" ||
pName=="pi+" || pName=="pi-" ||
pName=="deuteron" || pName=="He3" ||
pName=="alpha" || pName=="triton") {
std::ofstream hadrons_out("hadrons_out.out",std::ios::app);
hadrons_out << energy/eV << G4endl;
}
}
} // *** leaving a test mass ***
} // if(next volume)
// count particles hitting probe volume
// if(fStep->GetTrack()->GetNextVolume()) {
// static int i=0;
// G4String PosVol=fStep->GetPostStepPoint()
// ->GetPhysicalVolume()->GetName();
// if(PosVol=="probe_phys") {
// fStep->GetTrack()->SetTrackStatus(fStopAndKill);
// G4cout << i++ << G4endl;
// }
// }
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -0,0 +1,89 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISASteppingActionMessenger class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
#include "LISASteppingActionMessenger.hh"
#include "LISASteppingAction.hh"
LISASteppingActionMessenger::LISASteppingActionMessenger
(LISASteppingAction* stepAct) : steppingAction(stepAct){
newDir = new G4UIdirectory("/surveys/");
newDir->SetGuidance("Particle survey control commands.");
// set flag for spectrum saving
SetFlagSpectrum = new G4UIcmdWithABool("/surveys/surveyTestMasses",this);
SetFlagSpectrum->SetGuidance("Dump energies (eV) for e- and hadrons");
SetFlagSpectrum->SetGuidance("entering and leaving the test masses.");
SetFlagSpectrum->SetGuidance("'electrons_in.out' : e- entering TM");
SetFlagSpectrum->SetGuidance("'electrons_out.out': e- leaving TM");
SetFlagSpectrum->SetGuidance("'hadrons_in.out' : hadrons entering TM");
SetFlagSpectrum->SetGuidance("'hadrons_out.out' : hadrons leaving TM");
SetFlagSpectrum->SetGuidance("Default = false");
SetFlagSpectrum->SetParameterName("FlagSpectrum", false);
SetFlagSpectrum->AvailableForStates(G4State_Idle);
}
LISASteppingActionMessenger::~LISASteppingActionMessenger() {
delete SetFlagSpectrum;
delete newDir;
}
void LISASteppingActionMessenger::SetNewValue
(G4UIcommand* command, G4String newValue) {
if(command == SetFlagSpectrum) {
G4int vl;
const char* t = newValue;
std::istrstream is((char*)t);
is >> vl;
steppingAction->SetFlagSpectrum(vl!=0);
}
}
@@ -0,0 +1,206 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISADetectorConstruction class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
//***************************************************************************
// Support systems
//***************************************************************************
// Star Trackers
// FEEP Thrusters
// Communications Antennas
//***************************************************************************
// Star Trackers ************************************************************
G4double ST_rad = 0.5*2270*mm;
G4RotationMatrix ST_rot1; ST_rot1.rotateZ(+30.*deg);
G4ThreeVector ST_pos1(ST_rad*cos(56*deg),+ST_rad*sin(56*deg),180.*mm);
G4RotationMatrix ST_rot2; ST_rot2.rotateZ(-30.*deg);
G4ThreeVector ST_pos2(ST_rad*cos(56*deg),-ST_rad*sin(56*deg),180.*mm);
G4RotationMatrix ST_rot3; ST_rot3.rotateY(90.*deg);
// Star Tracker: 2 kg
G4double StarTracker_dia_o = 100.*mm;
G4double StarTracker_dia_i = 40.*mm;
G4double StarTracker_len = 120.*mm;
// Bracket: 0.25 kg
G4double StarTrackerBracket_wid = 120.*mm;
G4double StarTrackerBracket_hei = 104.*mm;
G4double StarTrackerBracket_thi = 7.5*mm;
G4Tubs* StarTracker_tub = new G4Tubs("StarTracker_tub",0.5*StarTracker_dia_i,
0.5*StarTracker_dia_o, 0.5*StarTracker_len, 0., 360.*deg);
G4Box* StarTrackerBracket_box = new G4Box("StarTrackerBracket_box",
0.5*StarTrackerBracket_thi, 0.5*StarTrackerBracket_wid,
0.5*StarTrackerBracket_hei);
G4UnionSolid* StarTracker_sol = new G4UnionSolid("StarTracker_sol",
StarTrackerBracket_box, StarTracker_tub, G4Transform3D(ST_rot3,
G4ThreeVector(0.5*(StarTracker_len + StarTrackerBracket_thi),0,0)));
G4LogicalVolume* StarTracker_log =
new G4LogicalVolume(StarTracker_sol, Al6061, "StarTracker_log");
G4VPhysicalVolume* StarTracker_phys;
StarTracker_phys = new G4PVPlacement(G4Transform3D(ST_rot1, spacecraft_pos
+ ST_pos1), "StarTracker_phys", StarTracker_log, wld_phys, false, 0);
StarTracker_phys = new G4PVPlacement(G4Transform3D(ST_rot2, spacecraft_pos
+ ST_pos2), "StarTracker_phys", StarTracker_log, wld_phys, false, 1);
StarTracker_log->SetVisAttributes(sol_cyan_vat);
// FEEP Thrusters ***********************************************************
G4double FEEP_rad = 0.5*2520*mm;
G4RotationMatrix FEEP_rot1;
FEEP_rot1.rotateZ(-90.*deg); FEEP_rot1.rotateX(180.*deg);
G4ThreeVector FEEP_pos1(FEEP_rad,0,170.*mm);
G4RotationMatrix FEEP_rot2;
FEEP_rot2.rotateZ(+30.*deg); FEEP_rot2.rotateX(180.*deg);
G4ThreeVector FEEP_pos2(-FEEP_rad*cos(60*deg),-FEEP_rad*sin(60*deg),170.*mm);
G4RotationMatrix FEEP_rot3;
FEEP_rot3.rotateZ(150.*deg); FEEP_rot3.rotateX(180.*deg);
G4ThreeVector FEEP_pos3(-FEEP_rad*cos(60*deg),+FEEP_rad*sin(60*deg),170.*mm);
// 1 support + 2 FEEPs: ~11 kg
G4double FEEP_dia_o = 140.*mm;
G4double FEEP_dia_i = 130.*mm;
G4double FEEP_len = 105.*mm;
G4double FEEP_xoff = 110.*mm;
G4double FEEP_yoff = 70.*mm;
G4double FEEP_zoff = 15.*mm;
G4double FEEPSup_len = 245.*mm;
G4double FEEPSup_wid = 276.*mm;
G4double FEEPSup_hei = 146.*mm;
G4double FEEPCut1_wid = 31.*mm;
G4double FEEPCut1_yoff = 50.*mm;
G4double FEEPCut2_len = 70.*mm;
G4double FEEPCut2_zoff = 10.*mm;
G4double FEEPCut3_xoff = 140.*mm;
G4RotationMatrix FEEP_rot4;
FEEP_rot4.rotateY((90.+15.)*deg); FEEP_rot4.rotateZ(-25.*deg);
G4RotationMatrix FEEP_rot5;
FEEP_rot5.rotateY((90.-15.)*deg); FEEP_rot5.rotateZ(+25.*deg);
// Mounting bracket
G4Box* FEEP_sol1 = new G4Box("FEEP_sol1",
0.5*FEEPSup_wid, 0.5*FEEPSup_len, 0.5*FEEPSup_hei);
G4Box* FEEPSupCutout1 = new G4Box("FEEPSupCutout1",
0.5*FEEPCut1_wid, 0.5*FEEPSup_len, 0.6*FEEPSup_hei);
G4SubtractionSolid* FEEP_sol2 = new G4SubtractionSolid("FEEP_sol2",
FEEP_sol1, FEEPSupCutout1, G4Transform3D(G4RotationMatrix(),
G4ThreeVector(0, -FEEPCut1_yoff, 0.)));
G4Box* FEEPSupCutout2 = new G4Box("FEEPSupCutout2",
0.6*FEEPSup_wid, 0.5*FEEPCut2_len, 0.51*FEEPSup_hei);
G4SubtractionSolid* FEEP_sol3 = new G4SubtractionSolid("FEEP_sol3",
FEEP_sol2, FEEPSupCutout2, G4Transform3D(G4RotationMatrix(),
G4ThreeVector(0,-0.5*FEEPSup_len+0.5*FEEPCut2_len-.5*mm, FEEPCut2_zoff)));
G4Box* FEEPSupCutout3 = new G4Box("FEEPSupCutout3",
FEEPSup_wid, FEEPSup_hei, FEEPCut2_len);
G4SubtractionSolid* FEEP_sol4 = new G4SubtractionSolid("FEEP_sol4",
FEEP_sol3, FEEPSupCutout3, G4Transform3D(FEEP_rot4,
G4ThreeVector(-FEEPCut3_xoff,FEEPCut2_len,0)));
G4SubtractionSolid* FEEP_sol5 = new G4SubtractionSolid("FEEP_sol5",
FEEP_sol4, FEEPSupCutout3, G4Transform3D(FEEP_rot5,
G4ThreeVector(+FEEPCut3_xoff,FEEPCut2_len,0)));
// FEEPs
G4Tubs* FEEP_tub = new G4Tubs("FEEP_tub", 0.5*FEEP_dia_i, 0.5*FEEP_dia_o,
0.5*FEEP_len, 0., 360.*deg);
G4UnionSolid* FEEP_sol6 = new G4UnionSolid("FEEP_sol",
FEEP_sol5, FEEP_tub, G4Transform3D(FEEP_rot4,
G4ThreeVector(-FEEP_xoff,FEEP_yoff,FEEP_zoff)));
G4UnionSolid* FEEP_sol7 = new G4UnionSolid("FEEP_sol",
FEEP_sol6, FEEP_tub, G4Transform3D(FEEP_rot5,
G4ThreeVector(+FEEP_xoff,FEEP_yoff,FEEP_zoff)));
G4LogicalVolume* FEEP_log =
new G4LogicalVolume(FEEP_sol7, Al6061, "FEEP_log");
G4VPhysicalVolume* FEEP_phys;
FEEP_phys = new G4PVPlacement(G4Transform3D(FEEP_rot1,
spacecraft_pos+FEEP_pos1), "FEEP_phys", FEEP_log, wld_phys, false, 0);
FEEP_phys = new G4PVPlacement(G4Transform3D(FEEP_rot2,
spacecraft_pos+FEEP_pos2), "FEEP_phys", FEEP_log, wld_phys, false, 1);
FEEP_phys = new G4PVPlacement(G4Transform3D(FEEP_rot3,
spacecraft_pos+FEEP_pos3), "FEEP_phys", FEEP_log, wld_phys, false, 2);
FEEP_log->SetVisAttributes(sol_cyan_vat);
// Communications Antennas **************************************************
// Antenna dish: ~1.4 kg
G4double Antenna_dia = 295.*mm;
G4double Antenna_thi = 7.*mm;
G4double Antenna_rad = 300.*mm;
// Antenna mount: 1 kg cylindrical shell
G4double AntennaMount_dia_o = 90.*mm;
G4double AntennaMount_dia_i = 77.*mm;
G4double AntennaMount_len = 220.*mm;
G4ThreeVector ant_pos1(Antenna_rad+0*mm,+1250*mm,+550.*mm);
G4ThreeVector ant_pos2(Antenna_rad-0*mm,-1250*mm,+550.*mm);
G4RotationMatrix ant_rot3; ant_rot3.rotateY(-90.*deg);
// Dish
G4Sphere* Antenna_sol = new G4Sphere("Antenna_sol", Antenna_rad-Antenna_thi,
Antenna_rad, 0., 360.*deg, 0, asin(0.5*Antenna_dia/Antenna_rad));
G4LogicalVolume* Antenna_log = new G4LogicalVolume
(Antenna_sol, Al6061, "Antenna_log");
G4VPhysicalVolume* Antenna_phys;
Antenna_phys = new G4PVPlacement(G4Transform3D(ant_rot3, spacecraft_pos
+ ant_pos1), "Antenna_phys", Antenna_log, wld_phys, false, 0);
Antenna_phys = new G4PVPlacement(G4Transform3D(ant_rot3, spacecraft_pos
+ ant_pos2), "Antenna_phys", Antenna_log, wld_phys, false, 1);
Antenna_log->SetVisAttributes(sol_cyan_vat);
// Mount
G4Tubs* AntennaMount_tub = new G4Tubs("AntennaMount_sol",
0.5*AntennaMount_dia_i, 0.5*AntennaMount_dia_o, 0.5*AntennaMount_len,
0., 360.*deg);
G4LogicalVolume* AntennaMount_log = new G4LogicalVolume
(AntennaMount_tub, Al6061, "AntennaMount_log");
G4VPhysicalVolume* AntennaMount_phys;
AntennaMount_phys = new G4PVPlacement(0, spacecraft_pos+ant_pos1+
G4ThreeVector(-Antenna_rad-60.*mm,0,-80.*mm),
"AntennaMount_phys", AntennaMount_log, wld_phys, false, 0);
AntennaMount_phys = new G4PVPlacement(0, spacecraft_pos+ant_pos2+
G4ThreeVector(-Antenna_rad-60.*mm,0,-80.*mm),
"AntennaMount_phys", AntennaMount_log, wld_phys, false, 1);
AntennaMount_log->SetVisAttributes(sol_cyan_vat);
//*****************************************************************************
@@ -0,0 +1,160 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// ********************************************************************
// * *
// * cosmicray_charging advanced example for Geant4 *
// * (adapted simulation of test-mass charging in the LISA mission) *
// * *
// * Henrique Araujo (h.araujo@imperial.ac.uk) & Peter Wass *
// * Imperial College London *
// * *
// * LISAVisManager class *
// * *
// ********************************************************************
//
// HISTORY
// 22/02/2004: migrated from LISA-V04
//
// ********************************************************************
#ifdef G4VIS_USE
#include "LISAVisManager.hh"
// Supported drivers...
// Not needing external packages or libraries...
#include "G4ASCIITree.hh"
#include "G4DAWNFILE.hh"
#include "G4GAGTree.hh"
#include "G4HepRepFile.hh"
#include "G4RayTracer.hh"
#include "G4VRML1File.hh"
#include "G4VRML2File.hh"
// Needing external packages or libraries...
#ifdef G4VIS_USE_DAWN
#include "G4FukuiRenderer.hh"
#endif
#ifdef G4VIS_USE_OPACS
#include "G4Wo.hh"
#include "G4Xo.hh"
#endif
#ifdef G4VIS_USE_OPENGLX
#include "G4OpenGLImmediateX.hh"
#include "G4OpenGLStoredX.hh"
#endif
#ifdef G4VIS_USE_OPENGLWIN32
#include "G4OpenGLImmediateWin32.hh"
#include "G4OpenGLStoredWin32.hh"
#endif
#ifdef G4VIS_USE_OPENGLXM
#include "G4OpenGLImmediateXm.hh"
#include "G4OpenGLStoredXm.hh"
#endif
#ifdef G4VIS_USE_OIX
#include "G4OpenInventorX.hh"
#endif
#ifdef G4VIS_USE_OIWIN32
#include "G4OpenInventorWin32.hh"
#endif
#ifdef G4VIS_USE_VRML
#include "G4VRML1.hh"
#include "G4VRML2.hh"
#endif
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
LISAVisManager::LISAVisManager () {}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void LISAVisManager::RegisterGraphicsSystems () {
// Graphics Systems not needing external packages or libraries...
RegisterGraphicsSystem (new G4ASCIITree);
RegisterGraphicsSystem (new G4DAWNFILE);
RegisterGraphicsSystem (new G4GAGTree);
RegisterGraphicsSystem (new G4HepRepFile);
RegisterGraphicsSystem (new G4RayTracer);
RegisterGraphicsSystem (new G4VRML1File);
RegisterGraphicsSystem (new G4VRML2File);
// Graphics systems needing external packages or libraries...
#ifdef G4VIS_USE_DAWN
RegisterGraphicsSystem (new G4FukuiRenderer);
#endif
#ifdef G4VIS_USE_OPACS
RegisterGraphicsSystem (new G4Wo);
RegisterGraphicsSystem (new G4Xo);
#endif
#ifdef G4VIS_USE_OPENGLX
RegisterGraphicsSystem (new G4OpenGLImmediateX);
RegisterGraphicsSystem (new G4OpenGLStoredX);
#endif
#ifdef G4VIS_USE_OPENGLWIN32
RegisterGraphicsSystem (new G4OpenGLImmediateWin32);
RegisterGraphicsSystem (new G4OpenGLStoredWin32);
#endif
#ifdef G4VIS_USE_OPENGLXM
RegisterGraphicsSystem (new G4OpenGLImmediateXm);
RegisterGraphicsSystem (new G4OpenGLStoredXm);
#endif
#ifdef G4VIS_USE_OIX
RegisterGraphicsSystem (new G4OpenInventorX);
#endif
#ifdef G4VIS_USE_OIWIN32
RegisterGraphicsSystem (new G4OpenInventorWin32);
#endif
#ifdef G4VIS_USE_VRML
RegisterGraphicsSystem (new G4VRML1);
RegisterGraphicsSystem (new G4VRML2);
#endif
if (fVerbose > 0) {
G4cout <<
"\nYou have successfully chosen to use the following graphics systems."
<< G4endl;
PrintAvailableGraphicsSystems ();
}
}
#endif
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....