Import Geant4 6.2.0 source tree

examples/advanced/cosmicray_charging/CRCharging.cc

@@ -0,0 +1,140 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// * main program class                                               *
+// *                                                                  *
+// ********************************************************************
+//
+// HISTORY
+// 22/02/2004: migrated from LISA-V04
+//
+// ********************************************************************
+
+#include "G4RunManager.hh"
+#include "G4UImanager.hh"
+#include "G4UIterminal.hh"
+#include "G4UItcsh.hh"
+
+#ifdef G4UI_USE_XM
+#include "G4UIXm.hh"
+#endif
+
+#include "Randomize.hh"
+
+#ifdef G4VIS_USE
+#include "LISAVisManager.hh"
+#endif
+
+#include "LISADetectorConstruction.hh"
+#include "LISAPhysicsList.hh"
+#include "LISAPrimaryGeneratorAction.hh"
+#include "LISARunAction.hh"
+#include "LISAEventAction.hh"
+#include "LISASteppingAction.hh"
+#include "LISAStackingAction.hh"
+
+#include <vector>
+
+
+int main(int argc,char** argv) {
+  
+  // choose the Random engine
+  HepRandom::setTheEngine(new RanecuEngine);
+  
+
+  // Construct the default run manager
+  G4RunManager* runManager = new G4RunManager;
+
+  // set mandatory initialization classes
+  LISADetectorConstruction* detector = new LISADetectorConstruction;
+  runManager->SetUserInitialization(detector);
+  runManager->SetUserInitialization(new LISAPhysicsList);
+  LISAPrimaryGeneratorAction* generatorAction = new LISAPrimaryGeneratorAction;
+  runManager->SetUserAction(generatorAction);
+  
+  // set user action classes
+  LISASteppingAction* steppingAction = new LISASteppingAction;
+  runManager->SetUserAction(steppingAction);
+  runManager->SetUserAction(new LISAStackingAction);
+  runManager->SetUserAction(
+     new LISAEventAction(generatorAction,steppingAction));
+  runManager->SetUserAction(new LISARunAction);
+
+  
+  G4UIsession* session=0;
+  if (argc==1) {  // Define UI session for interactive mode.
+    // G4UIterminal is a (dumb) terminal.
+#ifdef G4UI_USE_XM
+    session = new G4UIXm(argc,argv);
+#else           
+#ifdef G4UI_USE_TCSH
+    session = new G4UIterminal(new G4UItcsh);      
+#else
+    session = new G4UIterminal();
+#endif
+#endif
+  }
+  
+#ifdef G4VIS_USE
+  // visualization manager
+  G4VisManager* visManager = new LISAVisManager;
+  visManager->Initialize();
+#endif
+  
+
+  //Initialize G4 kernel
+  runManager->Initialize();
+  
+  // get the pointer to the User Interface manager 
+  G4UImanager* UI = G4UImanager::GetUIpointer();  
+  
+  // Define UI session for interactive mode.
+  if(session) {  
+    // G4UIterminal is a (dumb) terminal.
+    UI->ApplyCommand("/control/execute init.mac");    
+    session->SessionStart();
+    delete session;
+  }
+  // Batch mode
+  else { 
+    G4String command = "/control/execute ";
+    G4String fileName = argv[1];
+    UI->ApplyCommand(command+fileName);
+  }
+  
+  // job termination
+#ifdef G4VIS_USE
+  delete visManager;
+#endif
+  delete runManager;
+
+  return 0;
+}
+

examples/advanced/cosmicray_charging/GNUmakefile

@@ -0,0 +1,22 @@
+# --------------------------------------------------------------
+# GNUmakefile for examples module.  Gabriele Cosmo, 06/04/98.
+# --------------------------------------------------------------
+
+name := CRCharging
+G4TARGET := $(name)
+G4EXLIB := true
+
+ifndef G4INSTALL
+  G4INSTALL = ../../..
+endif
+
+.PHONY: all
+all:  lib bin 
+
+include $(G4INSTALL)/config/binmake.gmk
+
+ifdef G4ANALYSIS_USE
+ CPPFLAGS += `aida-config --include`
+ LDFLAGS  += `aida-config --lib`
+ LOADLIBS += `aida-config --lib`
+endif

examples/advanced/cosmicray_charging/History

@@ -0,0 +1,24 @@
+-------------------------------------------------------------------
+
+     =========================================================
+     Geant4 - an Object-Oriented Toolkit for Simulation in HEP
+     =========================================================
+
+                      Category History file
+                      ---------------------
+This file should be used by G4 developers and category coordinators
+to briefly summarize all major modifications introduced in the code
+and keep track of all category-tags.
+It DOES NOT substitute the  CVS log-message one should put at every
+committal in the CVS repository !
+
+     ----------------------------------------------------------
+     * Reverse chronological order (last date on top), please *
+     ----------------------------------------------------------
+
+07.05.2004 - Henrique Araujo, tag cosmicray_charging-V06-01-00
+             First submission of cosmicray_charging example.
+
+28.05.2004 - Henrique Araujo, tag cosmicray_charging-V06-01-01
+             Minor changes to GNUMakeFile
+             Ported to PI Light (no changes in code required)

examples/advanced/cosmicray_charging/README

@@ -0,0 +1,45 @@
+========================================================================
+
+                  cosmicray_charging advanced example
+
+                     Henrique Araujo & Peter Wass
+                       Imperial College London
+
+                              April 2004
+
+========================================================================
+
+This Geant4 example was derived from an application aimed at
+simulating the electrostatic charging of isolated test masses in the
+LISA mission by galactic cosmic ray protons and helium nuclei. This
+work was supported by the European Space Agency through the SEPTIMESS
+project under Contract No. 16339/02/NL/FM.
+
+LISA, the Laser Interferometer Space Antenna for the detection of
+gravitational waves, is a joint ESA/NASA mission composed of three
+identical spacecraft orbiting the Sun in a triangular formation, each
+containing two cubic test masses in pure geodesic (drag free) motion. 
+The interferometric measurements between different spacecraft
+are affected by the accrual of charge in the test masses caused by the
+interaction of energetic cosmic rays.
+
+With this example we intend to demonstrate an application of Geant4 to
+space environment simulations, using an extensive set of physics
+models spanning from TeV energies down to a few hundred eV. This code
+retains most (but not all) of the complex spacecraft and sensor
+geometry implemented for the original purpose. In particular, some
+complex elements of the inertial sensor surrounding the test masses
+have not been included. Differential energy spectra for protons, He-4
+and He-3 nuclei at solar minimum conditions are the only input macros
+provided. The remaining application classes have been kept unchanged.
+
+A Software Users' Manual suitable for Geant4 users of all levels is
+distributed with this application (/docs). The technical description
+of the original software package, including further software
+documentation, physics analysis and a similar effort for the precursor
+ESA mission LISA Pathfinder are available from the SEPTIMESS project
+website at http://reat.space.qinetiq.com/septimess/ or from
+http://astro.ic.ac.uk/~haraujo/SEPTIMESS/ .
+
+Any queries regarding this example or the original work can be
+directed to h.araujo@imperial.ac.uk.

examples/advanced/cosmicray_charging/include/LISAAnalysisManager.hh

@@ -0,0 +1,105 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// ********************************************************************
+
+
+#ifdef G4ANALYSIS_USE
+#ifndef LISAAnalysisManager_h
+#define LISAAnalysisManager_h 1
+
+#include "globals.hh"
+
+#include <AIDA/AIDA.h>
+
+namespace AIDA {
+  class IAnalysisFactory;
+  class ITree;
+  class IHistogramFactory;
+  class ITupleFactory;
+  class ITuple;
+  class IHistogram1D;
+  class IHistogram2D;
+  class IPlotter;
+  class IFitter;
+  class IFitResult;
+  class IFitData;
+  class IRangeSet;
+  class IFitParameterSettings;
+  class IFunctionFactory;
+  class IFunction;
+  class IFitFactory;
+}
+
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
+
+class LISAAnalysisManager {
+
+  public:
+    virtual ~LISAAnalysisManager();
+    void Init();
+    void Dispose();
+
+
+    // Run analysis
+    void bookRun(G4String);
+    void FinishRun();
+    void analyseRun
+     (G4int evt, G4int tm, G4double energy, G4int charge, 
+      G4int in, G4int out, long seed1, long seed2);
+
+    // grab instance
+    static LISAAnalysisManager* getInstance();
+ 
+
+  private:
+  
+    // private constructor for singleton
+    LISAAnalysisManager();
+ 
+    static LISAAnalysisManager* instance;
+  
+ 
+    AIDA::IAnalysisFactory  *af;
+    AIDA::ITreeFactory      *tf; 
+    AIDA::ITree             *run_tree;
+    AIDA::ITupleFactory     *run_tpf;
+    AIDA::ITuple            *run_tuple;
+
+
+};
+#endif
+#endif
+
+
+

examples/advanced/cosmicray_charging/include/LISADetectorConstruction.hh

@@ -0,0 +1,111 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// ********************************************************************
+
+#ifndef LISADetectorConstruction_h
+#define LISADetectorConstruction_h 1
+
+#include "G4VUserDetectorConstruction.hh"
+
+#include "G4UserLimits.hh"
+
+#include "G4Material.hh"
+#include "G4MaterialTable.hh"
+#include "G4MaterialPropertiesTable.hh"
+#include "G4Element.hh"
+#include "G4Isotope.hh"
+#include "G4UnitsTable.hh"
+
+#include "G4Box.hh"
+#include "G4Tubs.hh"
+#include "G4Sphere.hh"
+#include "G4Cons.hh"
+#include "G4Trap.hh"
+#include "G4Torus.hh"
+#include "G4Trd.hh"
+#include "G4VSolid.hh"
+#include "G4UnionSolid.hh"
+#include "G4SubtractionSolid.hh"
+
+#include "G4ThreeVector.hh"
+#include "G4RotationMatrix.hh"
+#include "G4Transform3D.hh"
+
+#include "G4PVPlacement.hh"
+#include "G4LogicalVolume.hh"
+#include "G4VPhysicalVolume.hh"
+
+#include "G4Region.hh"
+
+#include "G4VisAttributes.hh"
+#include "G4Colour.hh"
+
+#include "G4ios.hh"
+#include "globals.hh"
+
+#include <math.h>
+
+
+class LISADetectorConstruction : public G4VUserDetectorConstruction {
+
+  public:
+    LISADetectorConstruction();
+    ~LISADetectorConstruction();
+
+    G4VPhysicalVolume* Construct();
+
+  private:
+    void ConstructMaterials();
+    G4VPhysicalVolume* ConstructDetector();
+
+
+  private:
+  // pointers to materials
+  G4Material *vacuum;
+  G4Material *Al6061;
+  G4Material *AlHoneycomb;
+  G4Material *Scell;
+  G4Material *MLImat;
+  G4Material *molybdenum;
+  G4Material *TiAlloy;
+  G4Material *gold;
+  G4Material *AuPt;
+  G4Material *CFRP;
+  G4Material *ULEglass;
+  G4Material *SHAPAL;
+  G4Material *SiC;
+  G4Material *foam;
+  
+
+};
+
+#endif
+

examples/advanced/cosmicray_charging/include/LISADetectorMaterials.hh

@@ -0,0 +1,134 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// ********************************************************************
+
+
+void LISADetectorConstruction::ConstructMaterials(void) {
+
+  // Elements
+
+  G4Element* elementH  = new G4Element("Hydrogen",  "H",  1.,  1.0079*g/mole);
+  G4Element* elementC  = new G4Element("Carbon",    "C",  6.,  12.011*g/mole);
+  G4Element* elementN  = new G4Element("Nitrogen",  "N",  7.,  14.007*g/mole);
+  G4Element* elementO  = new G4Element("Oxygen",    "O",  8., 15.9994*g/mole);
+  G4Element* elementMg = new G4Element("Magnesium", "Mg",12., 24.3050*g/mole);
+  G4Element* elementAl = new G4Element("Aluminium", "Al",13., 26.9815*g/mole);
+  G4Element* elementSi = new G4Element("Silicon",   "Si",14., 28.0855*g/mole);
+  G4Element* elementTi = new G4Element("Titanium",  "Ti",22.,   47.90*g/mole);
+  G4Element* elementV  = new G4Element("Vanadium",  "V", 23., 50.9415*g/mole);
+  G4Element* elementFe = new G4Element("Iron",      "Fe",26.,  55.845*g/mole);
+  G4Element* elementMo = new G4Element("Molybdenum","Mo",42.,   95.94*g/mole);
+  G4Element* elementPt = new G4Element("Platinum",  "Pt",78.,  195.08*g/mole);
+  G4Element* elementAu = new G4Element("Gold",      "Au",79.,  196.97*g/mole);
+
+
+  // Materials
+
+  vacuum = new G4Material("vacuum", 1, 1.00794*g/mole, 
+     1.0E-25*g/cm3, kStateGas, 0.1*kelvin, 1.0E-19*pascal);
+
+  // Aluminium alloy 6061-T6
+  Al6061 = new G4Material("Al6061",          2.70*g/cm3, 4);
+  Al6061->AddElement(elementAl, 0.980);
+  Al6061->AddElement(elementMg, 0.010);
+  Al6061->AddElement(elementSi, 0.006);
+  Al6061->AddElement(elementFe, 0.004);
+
+  // Aluminium Alloy honeycomb
+  AlHoneycomb = new G4Material("AlHoneycomb",0.05*g/cm3, 4);
+  AlHoneycomb->AddElement(elementAl, 0.980);
+  AlHoneycomb->AddElement(elementMg, 0.010);
+  AlHoneycomb->AddElement(elementSi, 0.006);
+  AlHoneycomb->AddElement(elementFe, 0.004);
+
+  // Solar Cells****
+  Scell = new G4Material("Scell",            7.82*g/cm3, 1);
+  Scell->AddElement(elementSi, 1.00);
+
+  // MLI Blanket: mylar (composition from STAR Stopping Power database)
+  MLImat = new G4Material("MLImat",          1.40*g/cm3, 3);
+  MLImat->AddElement(elementH, 0.041959);
+  MLImat->AddElement(elementC, 0.625017);
+  MLImat->AddElement(elementO, 0.333025);
+
+  // Molybdenum
+  molybdenum = new G4Material("molybdenum", 10.22*g/cm3, 1);
+  molybdenum->AddElement(elementMo, 1.00);
+
+  // Titanium Alloy (Ti-6Al-4V)
+  TiAlloy   = new G4Material("TiAlloy",    4.43*g/cm3, 3);
+  TiAlloy->AddElement(elementTi, 0.90);
+  TiAlloy->AddElement(elementAl, 0.06);
+  TiAlloy->AddElement(elementV,  0.04);
+
+  // Gold
+  gold       = new G4Material("gold",       19.32*g/cm3, 1);
+  gold->AddElement(elementAu, 1.00);
+
+  // Gold-Platinum 70%/30%
+  AuPt = new G4Material("AuPt",             19.92*g/cm3, 2);
+  AuPt->AddElement(elementAu, 0.70);
+  AuPt->AddElement(elementPt, 0.30);
+
+  // CRFP (Carbon Fiber Reinforced Polymer): M55 Quasiisotropic Layup
+  CFRP = new G4Material("CFRP",               1.66*g/cm3, 1);
+  CFRP->AddElement(elementC,1);
+
+  // Silicate glass
+  G4Material* SiGlass = new G4Material("SiGlass", 2.20*g/cm3,  2);
+  SiGlass->AddElement(elementO, 2);
+  SiGlass->AddElement(elementSi,1);
+  // Titanium glass
+  G4Material* TiGlass = new G4Material("TiGlass", 4.25*g/cm3,  2);
+  TiGlass->AddElement(elementO, 2);
+  TiGlass->AddElement(elementTi,1);
+  // Corning 7972 ULE Titanium Silicate Glass
+  ULEglass = new G4Material("ULEglass",      2.21*g/cm3, 2);
+  ULEglass->AddMaterial(SiGlass, 0.925);
+  ULEglass->AddMaterial(TiGlass, 0.075);
+
+  // SHAPAL-M (AlN)
+  SHAPAL = new G4Material("SHAPAL-M",        2.90*g/cm3, 2);
+  SHAPAL->AddElement(elementAl,1);
+  SHAPAL->AddElement(elementN, 1);
+
+  // Silicon carbide
+  SiC = new G4Material("SiC",                 3.1*g/cm3, 2);
+  SiC->AddElement(elementSi,1);
+  SiC->AddElement(elementC, 1);
+
+  // Foam: Polystyrene-based
+  foam = new G4Material("foam",0.05*g/cm3, 2);
+  foam->AddElement(elementC, 0.90);
+  foam->AddElement(elementH, 0.10);
+
+
+}

examples/advanced/cosmicray_charging/include/LISAEventAction.hh

@@ -0,0 +1,75 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// ********************************************************************
+
+#ifndef LISAEventAction_h
+#define LISAEventAction_h 1
+
+#include "G4UserEventAction.hh"
+#include "globals.hh"
+#include "G4ios.hh"
+#include <strstream>
+
+class LISAPrimaryGeneratorAction;
+class LISASteppingAction;
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
+class LISAEventAction : public G4UserEventAction {
+
+  public:
+    LISAEventAction(LISAPrimaryGeneratorAction*, LISASteppingAction*);
+    virtual ~LISAEventAction();
+    virtual void BeginOfEventAction(const G4Event*);
+    virtual void EndOfEventAction(const G4Event*);
+
+  private:
+    LISAPrimaryGeneratorAction* genAction;
+    LISASteppingAction* stepAction;
+
+  public:
+  inline void SetFilename(const G4String& name)  {filename = name;};
+
+
+  private:
+    G4int event_id;
+    G4double energy_pri;
+    G4int  charge_in[2];
+    G4int charge_out[2];
+    G4int charge_tot[2];
+    const long* seeds;
+    G4String filename;
+
+};
+
+#endif
+
+

examples/advanced/cosmicray_charging/include/LISAPhysicsList.hh

@@ -0,0 +1,67 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// ********************************************************************
+
+#ifndef LISAPhysicsList_h
+#define LISAPhysicsList_h 1
+
+#include "G4VUserPhysicsList.hh"
+#include "globals.hh"
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
+
+class LISAPhysicsList: public G4VUserPhysicsList {
+
+  public:
+    LISAPhysicsList();
+    virtual ~LISAPhysicsList();
+
+  public:
+    virtual void SetCuts();
+
+  protected:
+    // particles and physics
+    virtual void ConstructParticle();
+    virtual void ConstructProcess();
+    
+    // physics processes
+    virtual void AddTransportation();
+    virtual void ElectromagneticPhysics();
+    virtual void HadronicPhysics();
+    virtual void ElectroNuclearPhysics();
+    virtual void GeneralPhysics();
+
+  private:
+    G4int VerboseLevel;
+
+};
+
+#endif

examples/advanced/cosmicray_charging/include/LISAPrimaryGeneratorAction.hh

@@ -0,0 +1,63 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// ********************************************************************
+
+#ifndef LISAPrimaryGeneratorAction_h
+#define LISAPrimaryGeneratorAction_h 1
+
+#include "G4VUserPrimaryGeneratorAction.hh"
+#include "globals.hh"
+
+class G4GeneralParticleSource;
+class G4Event;
+
+class LISAPrimaryGeneratorAction : public G4VUserPrimaryGeneratorAction {
+
+   public:
+      LISAPrimaryGeneratorAction();
+      ~LISAPrimaryGeneratorAction();
+      void GeneratePrimaries(G4Event* anEvent);
+
+   private:
+      G4GeneralParticleSource* particleGun;
+
+   private:
+      long seeds[2];
+      G4double energy_pri;
+
+   public:
+      const long* GetEventSeeds()   {return seeds;};
+      G4double GetEnergyPrimary()   {return energy_pri;};
+
+};
+
+#endif
+

examples/advanced/cosmicray_charging/include/LISARunAction.hh

@@ -0,0 +1,66 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// ********************************************************************
+
+#ifndef LISARunAction_h
+#define LISARunAction_h 1
+
+#include "G4UserRunAction.hh"
+#include "globals.hh"
+
+class LISARunActionMessenger;
+class G4Run;
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
+class LISARunAction : public G4UserRunAction {
+
+  public:
+    LISARunAction();
+   ~LISARunAction();
+
+  public:
+    void BeginOfRunAction(const G4Run*);
+    void EndOfRunAction(const G4Run*);
+
+
+  public:
+    inline void SetAutoSeed (const G4bool val)    {autoSeed    = val;}
+
+  private:
+    LISARunActionMessenger* runMessenger;
+
+    G4bool autoSeed;
+
+};
+
+#endif
+

examples/advanced/cosmicray_charging/include/LISARunActionMessenger.hh

@@ -0,0 +1,59 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// ********************************************************************
+
+#ifndef LISARunActionMessenger_h
+#define LISARunActionMessenger_h 1
+
+#include "G4UImessenger.hh"
+#include "G4UIcommand.hh"
+#include "G4UIcmdWithABool.hh"
+#include <strstream>
+#include "globals.hh"
+
+class LISARunAction;
+
+class LISARunActionMessenger: public G4UImessenger {
+
+  public:
+    LISARunActionMessenger(LISARunAction*);
+   ~LISARunActionMessenger();
+
+  void SetNewValue(G4UIcommand*, G4String);
+    
+  private:
+    LISARunAction* runAction;   
+
+    G4UIcmdWithABool* SetAutoSeedCmd;
+
+};
+
+#endif

examples/advanced/cosmicray_charging/include/LISAStackingAction.hh

@@ -0,0 +1,65 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// ********************************************************************
+
+#ifndef LISAStackingAction_h
+#define LISAStackingAction_h 1
+
+#include "globals.hh"
+#include "G4UserStackingAction.hh"
+
+class LISAStackingActionMessenger;
+class G4Track;
+
+class LISAStackingAction : public G4UserStackingAction {
+
+  public:
+    LISAStackingAction();
+    virtual ~LISAStackingAction();
+
+    virtual G4ClassificationOfNewTrack ClassifyNewTrack(const G4Track* aTrack);
+    virtual void NewStage();
+    virtual void PrepareNewEvent();
+
+  public:
+    inline void SetPrimarySurvey (const G4bool val) {PrimarySurveyFlag  = val;}
+    inline void SetParticleSurvey(const G4bool val) {ParticleSurveyFlag = val;}
+
+  private:
+    LISAStackingActionMessenger* stackingMessenger;
+    G4bool PrimarySurveyFlag;
+    G4bool ParticleSurveyFlag;
+
+
+};
+
+#endif
+

examples/advanced/cosmicray_charging/include/LISAStackingActionMessenger.hh

@@ -0,0 +1,59 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// ********************************************************************
+
+#ifndef LISAStackingActionMessenger_h
+#define LISAStackingActionMessenger_h 1
+
+#include "G4UImessenger.hh"
+#include "G4UIcommand.hh"
+#include "G4UIcmdWithABool.hh"
+#include "globals.hh"
+
+class LISAStackingAction;
+
+class LISAStackingActionMessenger: public G4UImessenger {
+
+  public:
+    LISAStackingActionMessenger(LISAStackingAction*);
+    ~LISAStackingActionMessenger();
+
+    void SetNewValue(G4UIcommand*, G4String);
+    
+  private:
+    LISAStackingAction* stackingAction;   
+
+    G4UIcmdWithABool* SetPriSurvey;
+    G4UIcmdWithABool* SetPartSurvey;
+
+};
+
+#endif

examples/advanced/cosmicray_charging/include/LISASteppingAction.hh

@@ -0,0 +1,73 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// ********************************************************************
+
+#ifndef LISASteppingAction_h
+#define LISASteppingAction_h 1
+
+#include "G4UserSteppingAction.hh"
+#include "globals.hh"
+
+class LISAEventAction;
+class LISASteppingActionMessenger;
+
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
+class LISASteppingAction : public G4UserSteppingAction {
+
+  public:
+    LISASteppingAction();
+    virtual ~LISASteppingAction();
+
+    virtual void UserSteppingAction(const G4Step*);
+
+  public:
+    inline void Discharge(void)          {charge_in[0]=0; charge_out[0]=0;
+                                         charge_in[1]=0; charge_out[1]=0;};
+
+    inline G4int GetChargeIn(const G4int tm)       {return charge_in[tm];}
+    inline G4int GetChargeOut(const G4int tm)      {return charge_out[tm];}
+
+
+    inline void SetFlagSpectrum(const G4bool val)  {FlagSpectrum  = val;}
+
+  private:
+    G4int charge_in[2];
+    G4int charge_out[2];
+
+    LISASteppingActionMessenger* steppingMessenger;
+    G4bool FlagSpectrum;
+
+
+
+};
+
+#endif

examples/advanced/cosmicray_charging/include/LISASteppingActionMessenger.hh

@@ -0,0 +1,61 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// ********************************************************************
+
+#ifndef LISASteppingActionMessenger_h
+#define LISASteppingActionMessenger_h 1
+
+#include "G4UImessenger.hh"
+#include "G4UIcommand.hh"
+#include "G4UIcmdWithABool.hh"
+#include "G4UIdirectory.hh"
+#include "globals.hh"
+
+class LISASteppingAction;
+
+class LISASteppingActionMessenger: public G4UImessenger {
+
+  public:
+    LISASteppingActionMessenger(LISASteppingAction*);
+    ~LISASteppingActionMessenger();
+
+    void SetNewValue(G4UIcommand*, G4String);
+    
+  private:
+    LISASteppingAction* steppingAction;   
+
+    G4UIcmdWithABool* SetFlagSpectrum;
+
+    G4UIdirectory* newDir;
+
+};
+
+#endif

examples/advanced/cosmicray_charging/include/LISAVisManager.hh

@@ -0,0 +1,55 @@
+//
+// ********************************************************************
+// * 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                                          *
+// *                                                                  *
+// ********************************************************************
+
+#ifndef LISAVisManager_h
+#define LISAVisManager_h 1
+
+#ifdef G4VIS_USE
+
+#include "G4VisManager.hh"
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
+
+class LISAVisManager: public G4VisManager {
+
+  public:
+    LISAVisManager();
+
+  private:
+    void RegisterGraphicsSystems ();
+
+};
+
+#endif
+
+#endif
+

examples/advanced/cosmicray_charging/init.mac

@@ -0,0 +1,25 @@
+#############################################################################*#
+# Initialisation macro for interactive mode                                   #
+###############################################################################
+#
+/control/verbose 1
+/control/saveHistory
+#
+# Create empty scene
+/vis/scene/create
+#
+# Create a scene handler for a specific graphics system
+# (Edit the next line(s) to choose another graphic system)
+/vis/open OGLSX
+#/vis/open OGLIX
+#/vis/open OGLSXm
+#/vis/open OGLIXm
+#/vis/open DANWFILE
+#
+# Add detector to scene
+/vis/drawVolume
+#
+# Flush visualization
+#/vis/viewer/flush
+#
+/vis/viewer/set/lineSegmentsPerCircle 120

examples/advanced/cosmicray_charging/primaries/helium3_solmin.mac

@@ -0,0 +1,66 @@
+#################################################################
+# Differential energy spectrum for solar minimum HELIUM-3 at 1 AU
+#################################################################
+#
+/vis/disable
+/tracking/storeTrajectory 0
+/control/verbose 1
+/run/verbose 1
+/event/verbose 0
+#
+/control/suppressAbortion 1
+#
+# Random seeds
+/run/autoSeed 1
+#/random/resetEngineFrom seeds.rndm
+#
+# particle surveys
+#/surveys/surveyParticles 1
+#/surveys/surveyPrimaries 1
+#/surveys/surveyTestMasses 1
+#
+/gps/particle He3
+#
+# Isotropic distribution
+/gps/type Surface
+/gps/shape Sphere
+/gps/radius 1499. mm
+/gps/centre 0. 0. 0. mm
+/gps/angtype cos
+#
+# Differential energy spectrum for solar minimum
+# Helium flux (/m2/s/sr/MeV) from Vannuccini 2001
+# He-3/He-4 compiled by C. Grimani
+# EPN TAKEN FOR A=4!!!
+# INTEGRAL FLUX = 0.0591 He/cm2/s
+/gps/energytype Arb
+/gps/histname arb
+#
+/gps/histpoint 4.000E+02 2.409E+01
+/gps/histpoint 5.970E+02 2.972E+01
+/gps/histpoint 8.910E+02 3.448E+01
+/gps/histpoint 1.330E+03 3.691E+01
+/gps/histpoint 1.985E+03 3.068E+01
+/gps/histpoint 2.962E+03 2.202E+01
+/gps/histpoint 4.421E+03 1.459E+01
+/gps/histpoint 6.599E+03 9.011E+00
+/gps/histpoint 9.848E+03 4.512E+00
+/gps/histpoint 1.470E+04 2.042E+00
+/gps/histpoint 2.194E+04 8.501E-01
+/gps/histpoint 3.274E+04 3.318E-01
+/gps/histpoint 4.887E+04 1.234E-01
+/gps/histpoint 7.293E+04 4.435E-02
+/gps/histpoint 1.089E+05 1.555E-02
+/gps/histpoint 1.625E+05 5.360E-03
+/gps/histpoint 2.425E+05 1.826E-03
+#/gps/histpoint 3.619E+05 6.172E-04
+#/gps/histpoint 5.401E+05 2.075E-04
+#/gps/histpoint 8.061E+05 6.949E-05
+#/gps/histpoint 1.203E+06 2.322E-05
+#/gps/histpoint 1.796E+06 7.745E-06
+#/gps/histpoint 2.680E+06 2.581E-06
+#/gps/histpoint 4.000E+06 8.593E-07
+#
+/gps/arbint Lin
+#
+/run/beamOn 1000000

examples/advanced/cosmicray_charging/primaries/helium4_solmin.mac

@@ -0,0 +1,65 @@
+#################################################################
+# Differential energy spectrum for solar minimum HELIUM-4 at 1 AU
+#################################################################
+#
+/vis/disable
+/tracking/storeTrajectory 0
+/control/verbose 1
+/run/verbose 1
+/event/verbose 0
+#
+/control/suppressAbortion 1
+#
+# Random seeds
+/run/autoSeed 1
+#/random/resetEngineFrom seeds.rndm
+#
+# particle surveys
+#/surveys/surveyParticles 1
+#/surveys/surveyPrimaries 1
+#/surveys/surveyTestMasses 1
+#
+/gps/particle alpha
+#
+# Isotropic distribution
+/gps/type Surface
+/gps/shape Sphere
+/gps/radius 1499. mm
+/gps/centre 0. 0. 0. mm
+/gps/angtype cos
+#
+# Differential energy spectrum for solar minimum
+# Helium flux (/m2/s/sr/MeV) from Vannuccini 2001
+# He-3/He-4 compiled by C. Grimani
+# INTEGRAL FLUX = 0.315 He/cm2/s
+/gps/energytype Arb
+/gps/histname arb
+#
+/gps/histpoint 4.000E+02 2.666E+02
+/gps/histpoint 5.970E+02 2.619E+02
+/gps/histpoint 8.910E+02 2.419E+02
+/gps/histpoint 1.330E+03 2.062E+02
+/gps/histpoint 1.985E+03 1.641E+02
+/gps/histpoint 2.962E+03 1.177E+02
+/gps/histpoint 4.421E+03 7.428E+01
+/gps/histpoint 6.599E+03 4.096E+01
+/gps/histpoint 9.848E+03 2.051E+01
+/gps/histpoint 1.470E+04 9.280E+00
+/gps/histpoint 2.194E+04 3.864E+00
+/gps/histpoint 3.274E+04 1.508E+00
+/gps/histpoint 4.887E+04 5.611E-01
+/gps/histpoint 7.293E+04 2.016E-01
+/gps/histpoint 1.089E+05 7.068E-02
+/gps/histpoint 1.625E+05 2.436E-02
+/gps/histpoint 2.425E+05 8.300E-03
+#/gps/histpoint 3.619E+05 2.805E-03
+#/gps/histpoint 5.401E+05 9.430E-04
+#/gps/histpoint 8.061E+05 3.159E-04
+#/gps/histpoint 1.203E+06 1.055E-04
+#/gps/histpoint 1.796E+06 3.521E-05
+#/gps/histpoint 2.680E+06 1.173E-05
+#/gps/histpoint 4.000E+06 3.906E-06
+#
+/gps/arbint Lin
+#
+/run/beamOn 1000000

examples/advanced/cosmicray_charging/primaries/protons_solmin.mac

@@ -0,0 +1,71 @@
+#################################################################
+# Differential energy spectrum for solar minimum PROTONS at 1 AU
+#################################################################
+#
+/vis/disable
+/tracking/storeTrajectory 0
+/control/verbose 1
+/run/verbose 1
+/event/verbose 0
+#
+/control/suppressAbortion 1
+#
+# Random seeds
+/run/autoSeed 1
+#/random/resetEngineFrom seeds.rndm
+#
+# particle surveys
+#/surveys/surveyParticles 1
+#/surveys/surveyPrimaries 1
+#/surveys/surveyTestMasses 1
+#
+/gps/particle proton
+#
+# Isotropic distribution
+/gps/type Surface
+/gps/shape Sphere
+/gps/radius 1499. mm
+/gps/centre 0. 0. 0. mm
+/gps/angtype cos
+#
+# Differential energy spectrum for solar minimum
+# proton flux (/m2/s/sr/MeV) from Vannuccini 2001
+# INTEGRAL FLUX = 4.29 p/cm2/s
+/gps/energytype Arb
+/gps/histname arb
+#
+/gps/histpoint   1.0000e+01   1.0886e+02
+/gps/histpoint   1.4874e+01   1.6753e+02
+/gps/histpoint   2.2122e+01   2.5783e+02
+/gps/histpoint   3.2903e+01   3.9680e+02
+/gps/histpoint   4.8939e+01   6.1068e+02
+/gps/histpoint   7.2790e+01   9.3985e+02
+/gps/histpoint   1.0826e+02   1.3421e+03
+/gps/histpoint   1.6103e+02   1.6191e+03
+/gps/histpoint   2.3950e+02   1.8305e+03
+/gps/histpoint   3.5622e+02   1.9002e+03
+/gps/histpoint   5.2983e+02   1.7726e+03
+/gps/histpoint   7.8805e+02   1.4572e+03
+/gps/histpoint   1.1721e+03   1.0417e+03
+/gps/histpoint   1.7433e+03   6.4545e+02
+/gps/histpoint   2.5929e+03   3.4914e+02
+/gps/histpoint   3.8566e+03   1.6753e+02
+/gps/histpoint   5.7362e+03   7.2810e+01
+/gps/histpoint   8.5317e+03   2.9280e+01
+/gps/histpoint   1.2690e+04   1.1109e+01
+/gps/histpoint   1.8874e+04   4.0399e+00
+/gps/histpoint   2.8072e+04   1.4257e+00
+/gps/histpoint   4.1753e+04   4.9270e-01
+/gps/histpoint   6.2102e+04   1.6783e-01
+/gps/histpoint   9.2367e+04   5.6602e-02
+/gps/histpoint   1.3738e+05   1.8962e-02
+/gps/histpoint   2.0434e+05   6.3234e-03
+/gps/histpoint   3.0392e+05   2.1023e-03
+/gps/histpoint   4.5204e+05   6.9745e-04
+/gps/histpoint   6.7234e+05   2.3106e-04
+/gps/histpoint   1.0000e+06   7.6479e-05
+#
+/gps/arbint Lin
+
+#
+/run/beamOn 10000

examples/advanced/cosmicray_charging/seeds.rndm

@@ -0,0 +1,2 @@
+0
+3495773572     1779568655

examples/advanced/cosmicray_charging/shoot.mac

@@ -0,0 +1,32 @@
+#################################################################
+# Shoots 1 GeV protons randomly from generator surface
+#################################################################
+#
+/vis/enable
+/tracking/storeTrajectory 1
+/control/verbose 1
+/run/verbose 1
+/event/verbose 0
+#
+/control/suppressAbortion 1
+#
+# Random seeds
+#/run/autoSeed 1
+/random/resetEngineFrom seeds.rndm
+#
+# particle surveys
+#/surveys/surveyParticles 1
+#/surveys/surveyPrimaries 1
+#/surveys/surveyTestMasses 1
+#
+/gps/particle proton
+/gps/energy 1 GeV
+#
+# Isotropic distribution
+/gps/type Surface
+/gps/shape Sphere
+/gps/radius 1499. mm
+/gps/centre 0. 0. 0. mm
+/gps/angtype cos
+#
+/run/beamOn 100

examples/advanced/cosmicray_charging/src/LISAAnalysisManager.cc

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

examples/advanced/cosmicray_charging/src/LISAColours.icc

@@ -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);
+
+
+//*****************************************************************************

examples/advanced/cosmicray_charging/src/LISADetectorConstruction.cc

@@ -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;
+
+}

examples/advanced/cosmicray_charging/src/LISAElectronicsBoxes.icc

@@ -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);
+
+
+
+  // **************************************************************************
+
+

examples/advanced/cosmicray_charging/src/LISAEventAction.cc

@@ -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;
+    }
+  }
+
+
+}
+

examples/advanced/cosmicray_charging/src/LISAInertialSensor.icc

@@ -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);
+
+
+
+//*****************************************************************************

examples/advanced/cosmicray_charging/src/LISAInterferometerAssembly.icc

@@ -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);
+
+
+// ****************************************************************************

examples/advanced/cosmicray_charging/src/LISAPrimaryGeneratorAction.cc

@@ -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();
+
+}
+

examples/advanced/cosmicray_charging/src/LISARunAction.cc

@@ -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....

examples/advanced/cosmicray_charging/src/LISARunActionMessenger.cc

@@ -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);
+  }
+
+}
+

examples/advanced/cosmicray_charging/src/LISAScienceModuleStructures.icc

@@ -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);
+  }
+
+//*****************************************************************************

examples/advanced/cosmicray_charging/src/LISASensorHousing.icc

@@ -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);
+
+
+//*****************************************************************************

examples/advanced/cosmicray_charging/src/LISAStackingAction.cc

@@ -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() {;}
+
+
+
+
+
+
+

examples/advanced/cosmicray_charging/src/LISAStackingActionMessenger.cc

@@ -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);
+  }
+
+
+
+}
+

examples/advanced/cosmicray_charging/src/LISASteppingAction.cc

@@ -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....
+

examples/advanced/cosmicray_charging/src/LISASteppingActionMessenger.cc

@@ -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);
+  }
+
+
+
+}
+

examples/advanced/cosmicray_charging/src/LISASupportSystems.icc

@@ -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);
+
+//*****************************************************************************

examples/advanced/cosmicray_charging/src/LISAVisManager.cc

@@ -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....