Editing Program Structure

==Getting Started with Geant4==
===Defining the main() Program===
The contents of main() will vary according to the needs of a given simulation application and therefore must be supplied by the user

First you must include all of the files you will be calling into the main() method
 #include "G4RunManager.hh"
 #include "G4UImanager.hh"

 #include "ExG4DetectorConstruction01.hh"
 #include "ExG4PhysicsList00.hh"
 #include "ExG4ActionInitialization01.hh"
Secondly construct the default run manager
  G4RunManager* runManager = new G4RunManager;
Then you need to set the mandatory initialization classes
 runManager->SetUserInitialization(new ExG4DetectorConstruction01);
 runManager->SetUserInitialization(new ExG4PhysicsList00);
 runManager->SetUserInitialization(new ExG4ActionInitialization01);
 //this code initializes G4DetectorConstruction, G4PhysicsList, G4ActionInitialization
Initialization of the G4 kernel
 runManager->Initialize();
The next step for a simple main() method would be getting the pointer to the UI(User Interface) manager and set verbosities
 G4UImanager* UI = G4UImanager::GetUIpointer();
 UI->ApplyCommand("/run/verbose 1");
 UI->ApplyCommand("/event/verbose 1");
 UI->ApplyCommand("/tracking/verbose 1")
Starting the run process
 int numberOfEvent = 3; //you can put however many events you would like this example is set at 3.
 runManager->BeamOn(numberOfEvent);
Then you need to terminate the job and close the main() method
 delete runManager;
   return 0;
 }

==Detector Geometry==

A detector geometry in Geant4 is made of a number of volumes. The largest of these volumes is called the <span style="color:red">'''world'''</span> volume.

===World Volume===

This <span style="color:red">'''world'''</span> volume must contain all other volumes within the detector geometry. Other volumes that are created, must be included inside the <span style="color:red">'''world'''</span> volume. The most simple and efficient shape to describe this <span style="color:red">'''world'''</span> volume would be a box.
Each volume is created by describing its shape and its physical characteristics, and then placing it inside a containing volume.
When a volume is placed within another volume, we call the former volume the daughter volume and the latter the mother volume. The coordinate system used to specify where the daughter volume is placed, is the coordinate system of the mother volume.

*To describe a volume's shape, we use the concept of a solid. A '''solid''' is a geometrical object that has a shape and specific values for each of that shape's dimensions. A cube with a side of 10 centimeters and a cylinder of radius 30 cm and length 75 cm are examples of solids.
*To describe a volume's full properties, we use a '''logical''' volume. It includes the geometrical properties of the solid, and adds physical characteristics: the material of the volume; whether it contains any sensitive detector elements; the magnetic field; etc.
*To position the volume. To do this you create a '''physical''' volume, which places a copy of the logical volume inside a larger, containing, volume.

Our code to create the <span style="color:red">'''World'''</span> volume:
 G4double world_sizeXY = 1.2*env_sizeXY;
  G4double world_sizeZ  = 1.2*env_sizeZ;
  G4Material* world_mat = nist->FindOrBuildMaterial("G4_AIR");
  
  G4Box* '''solid'''World =    
    new G4Box("World",                       //its name
       0.5*world_sizeXY, 0.5*world_sizeXY, 0.5*world_sizeZ);     //its size
      
  G4LogicalVolume* '''logic'''World =                         
    new G4LogicalVolume(solidWorld,          //its solid
                        world_mat,           //its material
                        "World");            //its name
                                   
  G4VPhysicalVolume* '''phys'''World = 
    new G4PVPlacement(0,                     //no rotation
                      G4ThreeVector(),       //at (0,0,0)
                      logicWorld,            //its logical volume
                      "World",               //its name
                      0,                     //its mother  volume
                      false,                 //no boolean operation
                      0,                     //copy number
                      checkOverlaps);        //overlaps checking

===The Envelope (The world within the world)===

The <span style="color:blue">'''Envelope'''</span> is a smaller volume that exists within the <span style="color:red">'''world'''</span> volume. While the <span style="color:red">'''world'''</span> volume is created to house all inner volumes, the <span style="color:blue">'''envelope'''</span> is where the experiment occurs. The <span style="color:blue">'''envelope'''</span> can be thought of as a box within a box, as it is essentially a smaller box within the <span style="color:red">'''world'''</span> box. Within the <span style="color:blue">'''envelope'''</span>, other volumes (including materials) can be placed, and particles can be allowed to pass through. Although the volumes are described as a box, they can be other shapes as well, such as a cylinder. The code for creating boxes and cylinders can be found [http://geant4.cern.ch/UserDocumentation/UsersGuides/ForApplicationDeveloper/html/ch02s02.html#sect.HowToDefDetectorGeom.ChooseSolid here].

The code for creating the <span style="color:blue">'''envelope'''</span> is near identical to the code for creating the <span style="color:red">'''world'''</span>. The only difference is that the volume is given a different name, and the dimensions should be small enough to fit inside the <span style="color:red">'''world'''</span>. Inside the <span style="color:blue">'''envelope'''</span>, other volumes and even materials with varying properties can be placed. This will be discussed in the next section.

===Creating the Geometry inside the Envelope===
Inside the <span style="color:blue">'''envelope'''</span> you can conduct many types of experiments. For our experiment we have placed two scoring volumes inside our <span style="color:blue">'''envelope'''</span>. Remember, each volume is created by describing its shape and its physical characteristics, and then placing it inside a containing volume; Please Refer to [http://jlabdaq.pcs.cnu.edu/wiki/index.php/Program_Structure#The_Envelope_.28The_world_within_the_world.29 The Envelope (The world within the world)]
A sample code of someone creating the <span style="color:blue">'''envelope'''</span>:
'''A shape'''
In this section of code we are defining the shape in our chosen coordinate system, which is Cartesian. Follow the comments throughout the code for a better understanding:
 G4Material* shape1_mat = nist->FindOrBuildMaterial("MATERIAL");
  G4ThreeVector pos1 = G4ThreeVector(x, y ,z);
  // whatever shape you want     
  G4double shape1_dya = cm, shape1_dyb = cm;
  G4double shape1_dxa = cm, shape1_dxb = cm;
  G4double shape1_dz  = cm;      
  G4Trd* '''solid'''Shape1 =    
    new G4Trd("Shape1",                      //its name
              0.5*shape1_dxa, 0.5*shape1_dxb, 
              0.5*shape1_dya, 0.5*shape1_dyb, 0.5*shape1_dz); //its size
                
  G4LogicalVolume* '''logic'''Shape1 =                         
    new G4LogicalVolume('''solid'''Shape1,         //its solid
                        shape1_mat,          //its material
                        "Shape1");           //its name
               
  new G4PVPlacement(0,                       //no rotation
                    pos1,                    //at position
                    logicShape1,             //its logical volume
                    "Shape1",                //its name
                    logicEnv,                //its mother  volume
                    false,                   //no boolean operation
                    0,                       //copy number
                    checkOverlaps);          //overlaps checking
                
 
Next is the creation of the scintillators

===How to Specify the Material in the Detector Geometry===
So within the <span style="color:blue">'''Envelope'''</span> we constructed these volumes, volumes however can be filled with a material. Geant4 does a great job in allowing the user extreme customization. I say this because, I can literally fill up these volumes with whatever I would like as long as it is in the ''G4Material'' class. 
The ''G4Material'' class describes the macroscopic properties of matter:
*density,
*state,
*temperature,
*pressure,
*as well as macroscopic quantities like radiation length, mean free path, dE/dx, etc
The ''G4Material'' class is the one which is visible to the rest of the toolkit, and is used by the tracking, the geometry, and the physics. It contains all the information relative to the eventual elements and isotopes of which it is made, at the same time hiding the implementation details.
We defined our volumes within our <span style="color:blue">'''envelope'''</span> and then went on to tell the program what material we would like in each volume.
This is the section of code we used:
 G4Material* shape1_mat = nist->FindOrBuildMaterial("G4_POLYETHYLENE");
 G4Material* shape2_mat = nist->FindOrBuildMaterial("G4_POLYETHYLENE");
 //"nist" is calling the data from the National Institute of Technology
This is a list of elements, compounds, space ISS materials, bio-chemical materials, HEP, and nuclear materials [http://geant4.cern.ch/UserDocumentation/UsersGuides/ForApplicationDeveloper/html/apas08.html here]

==How to Specify Particles==
In our experiment we declared our particle which is a muon because we are interested in the particles withing cosmic ray's
The G4ParticleTable class is provided as a dictionary of particles. Various utility methods are provided, such as:

 FindParticle(G4String name);         // find the particle by name
 FindParticle(G4int PDGencoding)      // find the particle by PDG encoding .
G4ParticleTable is defined as a singleton object, and the static method G4ParticleTable::GetParticleTable() provides its pointer.
However in our code we declared a muon by
 G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
  G4String particleName;
  G4ParticleDefinition* particle
    = particleTable->FindParticle(particleName="mu+");
  fParticleGun->SetParticleDefinition(particle);
  //fParticleGun->SetParticleMomentumDirection(G4ThreeVector(xcosine,ycosine,zcosine));
  // fParticleGun->SetParticleEnergy(e0);


Particles are registered automatically during construction. The user has no control over particle registration.
===Dictionary of Particles===
The G4ParticleTable class is provided as a dictionary of particles. Various utility methods are provided, such as:
 FindParticle(G4String name);         // find the particle by name
FindParticle(G4int PDGencoding)      // find the particle by PDG encoding .
G4ParticleTable is defined as a singleton object, and the static method G4ParticleTable::GetParticleTable() provides its pointer.

As for heavy ions (including hyper-nuclei), objects are created dynamically by requests from users and processes. The G4ParticleTable class provides methods to create ions, such as:
 G4ParticleDefinition* GetIon(  G4int    atomicNumber,  
                               G4int    atomicMass, 
                               G4double   excitationEnergy);
==How to Specify Physics processes==
Physics processes describe how particles interact with materials. Geant4 provides seven major categories of processes:
*electromagnetic,
*hadronic,
*transportation,
*decay,
*optical,
*photolepton_hadron, and
*parameterisation.
All physics processes are derived from the G4VProcess base class. Its virtual methods
*AtRestDoIt,
*AlongStepDoIt, and
*PostStepDoIt

===G4VProcess===
G4VProcess is the base class for all physics processes. Each physics process must implement virtual methods of G4VProcess which describe the interaction (DoIt) and determine when an interaction should occur (GPIL). In order to accommodate various types of interactions G4VProcess provides three DoIt methods:

 G4VParticleChange* AlongStepDoIt( const G4Track& track, const G4Step& stepData )

This method is invoked while G4SteppingManager is transporting a particle through one step. The corresponding AlongStepDoIt for each defined process is applied for every step regardless of which process produces the minimum step length. Each resulting change to the track information is recorded and accumulated in G4Step. After all processes have been invoked, changes due to AlongStepDoIt are applied to G4Track, including the particle relocation and the safety update. Note that after the invocation of AlongStepDoIt, the endpoint of the G4Track object is in a new volume if the step was limited by a geometric boundary. In order to obtain information about the old volume, G4Step must be accessed, since it contains information about both endpoints of a step.

 G4VParticleChange* PostStepDoIt( const G4Track& track, const G4Step& stepData )

This method is invoked at the end point of a step, only if its process has produced the minimum step length, or if the process is forced to occur. G4Track will be updated after each invocation of PostStepDoIt, in contrast to the AlongStepDoIt method.

 G4VParticleChange* AtRestDoIt( const G4Track& track, const G4Step& stepData )

This method is invoked only for stopped particles, and only if its process produced the minimum step length or the process is forced to occur.

For each of the above DoIt methods G4VProcess provides a corresponding pure virtual GPIL method:

 G4double PostStepGetPhysicalInteractionLength( const G4Track& track, G4double previousStepSize, G4ForceCondition* condition )

This method generates the step length allowed by its process. It also provides a flag to force the interaction to occur regardless of its step length.

 G4double AlongStepGetPhysicalInteractionLength( const G4Track& track, G4double previousStepSize, G4double currentMinimumStep, G4double& proposedSafety, G4GPILSelection* selection )

This method generates the step length allowed by its process.

 G4double AtRestGetPhysicalInteractionLength( const G4Track& track, G4ForceCondition* condition )

This method generates the step length in time allowed by its process. It also provides a flag to force the interaction to occur regardless of its step length.

Other pure virtual methods in G4VProcess follow:

 virtual G4bool IsApplicable(const G4ParticleDefinition&)

returns true if this process object is applicable to the particle type.

 virtual void PreparePhysicsTable(const G4ParticleDefinition&) and

 virtual void BuildPhysicsTable(const G4ParticleDefinition&)

is messaged by the process manager, whenever cross section tables should be prepared and rebuilt due to changing cut-off values. It is not mandatory if the process is not affected by cut-off values.

 virtual void StartTracking() and

 virtual void EndTracking()

are messaged by the tracking manager at the beginning and end of tracking the current track.
===How to specify the type of Physics process===
The user must create a class derived from ''G4VUserPhysicsList'' and implement the pure virtual method ''ConstructProcess()''.
For a Physics process you must register the ''G4Transportation'' class with all particle classes. The AddTransportation() method is listed and provided in G4VUserPhysicsList class.
 void MyPhysicsList::ConstructProcess()
  {
    // Define transportation process
    AddTransportation();
  }

==How to Generate a Primary Action==
G4userPrimaryGeneratorAction is one of the mandatory classes available for deriving your own concrete class. In your concrete class, you have to specify how a primary event should be generated. Actual generation of primary particles will be done by concrete classes of G4VPrimaryGenerator.
 void S1PrimaryGeneratorAction::GeneratePrimaries(G4Event* anEvent)
 {

===Selection of the Generator===
In the constructor of your G4VUserPrimaryGeneratorAction, you should instantiate the primary generator(s). If necessary, you need to set some initial conditions for the generator(s).
This is an example of a constructor
 S1PrimaryGeneratorAction::S1PrimaryGeneratorAction()
:G4VUserPrimaryGeneratorAction(),
//inside this constructor you should have some code calling your generator(s)
===G4Primary Generator===
G4ParticleGun is a generator provided by Geant4. We called This class generates primary particle(s) with a given momentum and position. It does not provide any sort of randomizing. The constructor of G4ParticleGun takes an integer which causes the generation of one or more primaries of exactly same kinematics. It is a rather frequent user requirement to generate a primary with randomized energy, momentum, and/or position. Such randomization can be achieved by invoking various set methods provided by G4ParticleGun. Geant4 provides various random number generation methods with various distributions [http://geant4.web.cern.ch/geant4/UserDocumentation/UsersGuides/ForApplicationDeveloper/html/ch03s02.html (see Section 3.2)].
Within your Primary Generator Action you must establish your conditions of your experiment
{Example}
*establish a random position on both top and bottom of your geometry within your envelope
 xtop = (G4UniformRand()*(Variables->getGeometryX()*0.5));
 ytop = (G4UniformRand()*(Variables->getGeometryY()*0.5));
 xbottom = (G4UniformRand()*(Variables->getGeometrytX()*0.5));
 ybottom = = (G4UniformRand()*(Variables->getGeometryY()*0.5));
*establish how far below the bottom geometry the particles should start
 G4double bottomOfBottomGeo = (Variables->getGeoZ()*-0.5)+Variables->getBottomGeoPos();
 zinitial = (bottomOfBottomGeo - 1.0);
*establish the components of the vector to fire along to hit both random points
 baseX = (xtop-xbottom);
 baseY = (ytop-ybottom);
 heightZ = (Variables->getTopGeoPos() - Variables->getBottomGeoPos());
===G4ParticleGun Generator===
G4ParticleGun is a generator provided by Geant4. This class generates primary particle(s) with a given momentum and position. It does not provide any sort of randomizing. The constructor of G4ParticleGun takes an integer which causes the generation of one or more primaries of exactly same kinematics. It is a rather frequent user requirement to generate a primary with randomized energy, momentum, and/or position.
G4ParticleGun is normally found in one of your constructors within your PrimaryGeneratorAction.
 fParticleGun = new G4ParticleGun(n_particle);
Next you must decribe the default Particle Kinematics:
 G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
 G4String particleName = "nameofparticlehere";
 G4ParticleDefinition* particle = particleTable->FindParticle(particleName);
 fParticleGun->SetParticleDefinition(particle);

==External Links==
*[http://geant4.cern.ch/UserDocumentation/UsersGuides/ForApplicationDeveloper/html/index.html Geant4 User's Guide for Application Developers]