G4HumanPhantomConstruction Class Reference

#include <G4HumanPhantomConstruction.hh>

Inheritance diagram for G4HumanPhantomConstruction:

Collaboration diagram for G4HumanPhantomConstruction:

Public Member Functions
	G4HumanPhantomConstruction ()
	~G4HumanPhantomConstruction ()
G4VPhysicalVolume *	Construct ()
void	SetBodyPartSensitivity (G4String, G4bool)
void	SetPhantomSex (G4String)
void	SetPhantomModel (G4String)
void	ConstructSDandField ()
Public Member Functions inherited from G4VUserDetectorConstruction
	G4VUserDetectorConstruction ()
virtual	~G4VUserDetectorConstruction ()
virtual void	CloneSD ()
virtual void	CloneF ()
void	RegisterParallelWorld (G4VUserParallelWorld *)
G4int	ConstructParallelGeometries ()
void	ConstructParallelSD ()
G4int	GetNumberOfParallelWorld () const
G4VUserParallelWorld *	GetParallelWorld (G4int i) const

Private Member Functions
G4VPhysicalVolume *	ConstructWorld ()

Private Attributes
G4HumanPhantomMaterial *	material
G4HumanPhantomMessenger *	messenger
G4String	model
G4String	sex
std::map< std::string, G4bool >	sensitivities

Additional Inherited Members
Protected Member Functions inherited from G4VUserDetectorConstruction
void	SetSensitiveDetector (const G4String &logVolName, G4VSensitiveDetector *aSD, G4bool multi=false)
void	SetSensitiveDetector (G4LogicalVolume *logVol, G4VSensitiveDetector *aSD)

Detailed Description

Definition at line 45 of file G4HumanPhantomConstruction.hh.

Constructor & Destructor Documentation

G4HumanPhantomConstruction()

G4HumanPhantomConstruction::G4HumanPhantomConstruction

(

)

Definition at line 58 of file G4HumanPhantomConstruction.cc.

{
  messenger = new G4HumanPhantomMessenger(this);
  material = new G4HumanPhantomMaterial();
}

~G4HumanPhantomConstruction()

G4HumanPhantomConstruction::~G4HumanPhantomConstruction

(

)

Definition at line 64 of file G4HumanPhantomConstruction.cc.

{
  delete material;
  delete messenger;
}

Member Function Documentation

Construct()

G4VPhysicalVolume * G4HumanPhantomConstruction::Construct ( void  )

virtual

Implements G4VUserDetectorConstruction.

Definition at line 70 of file G4HumanPhantomConstruction.cc.

{
  material -> DefineMaterials();
  
  

  G4BasePhantomBuilder*  builder = 0;

  if (model == "MIRDHead" || model == "ORNLHead")
    { 
      G4cout << "HeadBuilder instantiated" << G4endl;
      builder = new G4PhantomHeadBuilder;
      if (model ==  "MIRDHead") builder->SetModel("MIRD");
      else if (model ==  "ORNLHead") builder->SetModel("ORNLMale");
    }
  else
    {  
      if (sex =="Female") 
    { 
      if (model == "MIX") builder = new G4CustomFemaleBuilder;
      else {builder = new G4FemaleBuilder;}
      builder->SetModel(model);
      G4cout <<model << " "<< sex << G4endl;
    }
      else if (sex == "Male") 
    {
      builder = new G4MaleBuilder;
      builder->SetModel(model);
          if (model == "MIX") 
        { 
          G4cout<< "Custom Male is not available!!! MIRD model is selected !" 
            << G4endl;
          model = "MIRD";  
          builder->SetModel(model);}
    }
    }
  
  builder->SetMotherVolume(ConstructWorld());
  
  // the argument indicates the sensitivity of the volume
  
  builder->BuildHead("black", false, sensitivities["Head"]);
  builder->BuildSkull("orange", false,sensitivities["Skull"]); 
  builder->BuildBrain("yellow", true,sensitivities["Brain"]); 

  if (model != "MIRDHead" && model != "ORNLHead")
    { 
      //  builder->SetModel(model);
      builder->BuildTrunk("yellow", false, sensitivities["Trunk"]);
      
      builder->BuildLeftLeg("yellow", false,sensitivities["LeftLeg"]);
      builder->BuildRightLeg("yellow", false,sensitivities["RightLeg"]);
      
      builder->BuildLeftArmBone("grey", true,sensitivities["LeftArmBone"]);
      builder->BuildRightArmBone("grey", true, sensitivities["RightArmBone"]);  
    
      builder->BuildLeftLegBone("grey", true,sensitivities["LeftLegBone"]);
      builder ->BuildRightLegBone("grey", true,sensitivities["RightLegBone"]);
 
      builder->BuildUpperSpine("yellow", true,sensitivities["UpperSpine"]); 
      
      if (model == "MIRD" || model == "MIX") 
    {
      builder->BuildLeftScapula("grey", true, sensitivities["LeftScapula"]); 
      builder->BuildRightScapula("grey", true, sensitivities["RightScapula"]);
      builder->BuildLeftAdrenal("yellow", true, sensitivities["LeftAdrenal"]);
      builder->BuildRightAdrenal("yellow", true, sensitivities["RightAdrenal"]);
      builder->BuildThymus("orange", true,sensitivities["Thymus"]); 
      builder->BuildLeftClavicle("grey", true,sensitivities["LeftClavicle"]);
      builder->BuildRightClavicle("grey", true,sensitivities["RightClavicle"]);
      builder->BuildSmallIntestine("orange", true,sensitivities["SmallIntestine"]);
      builder->BuildRibCage("grey", true,sensitivities["RibCage"]); 
    }
  
      builder->BuildMiddleLowerSpine("yellow", true,sensitivities["MiddleLowerSpine"]);
  
      builder->BuildPelvis("grey", true,sensitivities["Pelvis"]); 
  
      builder->BuildStomach("orange", true,sensitivities["Stomach"]); 
      builder->BuildUpperLargeIntestine("lightBlue", true,sensitivities["UpperLargeIntestine"]);
      builder->BuildLowerLargeIntestine("lightBlue", true,sensitivities["LowerLargeIntestine"]);
         
      builder->BuildSpleen("green", true,sensitivities["Spleen"]);
      builder->BuildPancreas("purple", true,sensitivities["Pancreas"]); 
      //builder->BuildLiver("orange", true,sensitivities["Liver"]); 

      builder->BuildLeftKidney("green", true,sensitivities["LeftKidney"]);
      builder->BuildRightKidney("green", true,sensitivities["RightKidney"]);
      builder->BuildUrinaryBladder("green", true,sensitivities["UrinaryBladder"]);
 
      //builder->BuildHeart("red", true,sensitivities["Hearth"]);// to do MIRD
     // builder->BuildLeftLung("blue", true,sensitivities["LeftLung"]);
      //builder->BuildRightLung("blue", true,sensitivities["RightLung"]);
     // builder->BuildThyroid("orange", true,sensitivities["Thyroid"]); 

      if(sex=="Female"){

    builder->BuildLeftOvary("purple", true,sensitivities["LeftOvary"]);
    builder->BuildRightOvary("purple", true,sensitivities["RightOvary"]);
    builder->BuildUterus("purple", true,sensitivities["Uterus"]);

    if (model == "ORNLFemale" || model == "MIRD")
      {
        builder->BuildLeftBreast("purple", true,sensitivities["LeftBreast"]); 
        builder->BuildRightBreast("purple", true,sensitivities["RightBreast"]);
      }
    else if (model == "MIX")
      {
        builder->BuildVoxelLeftBreast("purple",false, sensitivities["LeftBreast"]); 
        builder->BuildVoxelRightBreast("purple", false, sensitivities["RightBreast"]);  
      } 
      }
      
      if(sex=="Male"){
    
    if (model == "MIRD"){ 
      builder -> BuildMaleGenitalia("yellow",false,sensitivities["MaleGenitalia"]);
      builder -> BuildLeftTeste("purple",true,sensitivities["LeftTeste"]);
      builder -> BuildRightTeste("purple",true,sensitivities["RightTeste"]);
    }
    else G4cout <<  "ORNL does not have model for male genitalia and testes yet" << G4endl;
      }
      
    }
  G4VPhysicalVolume* result=builder->GetPhantom(); 
  delete builder;
  return result; 
}

Here is the call graph for this function:

ConstructSDandField()

void G4HumanPhantomConstruction::ConstructSDandField ( )

virtual

Reimplemented from G4VUserDetectorConstruction.

Definition at line 282 of file G4HumanPhantomConstruction.cc.

{
   G4HumanPhantomSD* SD = new G4HumanPhantomSD("SD", "HumanPhantomCollection");

if (model != "ORNLMale" && model != "ORNLFemale" && model!= "ORNLHead")  
{
  SetSensitiveDetector("logicalHead",SD);
  SetSensitiveDetector("logicalSkull",SD);
  SetSensitiveDetector("logicalBrain",SD);
  if (model != "MIRDHead")
    { 
      SetSensitiveDetector("logicalTrunk",SD);
      SetSensitiveDetector("logicalLeftLeg",SD); 
      SetSensitiveDetector("logicalRightLeg",SD);
      SetSensitiveDetector("logicalLeftArmBone",SD); 
      SetSensitiveDetector("logicalRightArmBone",SD);
      SetSensitiveDetector("logicalLeftLegBone",SD); 
      SetSensitiveDetector("logicalRightLegBone",SD);
      SetSensitiveDetector("logicalUpperSpine",SD);
      SetSensitiveDetector("logicalLeftScapula",SD);
      SetSensitiveDetector("logicalRightScapula",SD);
      SetSensitiveDetector("logicalLeftAdrenal",SD);
      SetSensitiveDetector("logicalRightAdrenal",SD);      SetSensitiveDetector("logicalThymus",SD);      SetSensitiveDetector("logicalLeftClavicle",SD);
      SetSensitiveDetector("logicalRightClavicle",SD);
      SetSensitiveDetector("logicalSmallIntestine",SD); 
      SetSensitiveDetector("logicalRibCage",SD);       SetSensitiveDetector("logicalMiddleLowerSpine",SD); 
      SetSensitiveDetector("logicalStomach",SD); 
      SetSensitiveDetector("logicalUpperLargeIntestine",SD);
      SetSensitiveDetector("logicalLowerLargeIntestine",SD);
      SetSensitiveDetector("logicalSpleen",SD);
      SetSensitiveDetector("logicalPancreas",SD);
      SetSensitiveDetector("logicalLeftKidney",SD);
      SetSensitiveDetector("logicalRightKidney",SD);       
      SetSensitiveDetector("logicalUrinaryBladder",SD);

      if(sex=="Female"){

    SetSensitiveDetector("logicalLeftOvary",SD);
        SetSensitiveDetector("logicalRightOvary",SD); 
        SetSensitiveDetector("logicalUterus",SD);
        SetSensitiveDetector("logicalLeftBreast",SD);
        SetSensitiveDetector("logicalRightBreast",SD); 
    }

      if(sex=="Male"){
    
    
      SetSensitiveDetector("logicalMaleGenitalia",SD);
          SetSensitiveDetector("logicalLeftTeste",SD);
      SetSensitiveDetector("logicalRightTeste",SD);
    }
    
      }
  }else 
 { 
  SetSensitiveDetector("HeadVolume",SD);
  SetSensitiveDetector("SkullVolume",SD);
  SetSensitiveDetector("BrainVolume",SD);
  G4cout << "Work in progress!!!! " << G4endl;
  G4cout <<"ORNL model!!!! Head is sensitive only!!!" << G4endl;
} 

   
}

Here is the call graph for this function:

ConstructWorld()

G4VPhysicalVolume * G4HumanPhantomConstruction::ConstructWorld ( )

private

Definition at line 204 of file G4HumanPhantomConstruction.cc.

{
  G4Material* air = material -> GetMaterial("Air");

  // World Volume
  // G4double worldSize = 1.*m ;
  G4double worldSize = 1.5 *m ;
  G4Box* world = new G4Box("world", worldSize, worldSize, worldSize);

  G4LogicalVolume* logicWorld = new G4LogicalVolume(world, 
                            air, 
                            "logicalWorld", 0, 0,0);

  G4VPhysicalVolume* motherVolume = new G4PVPlacement(0,G4ThreeVector(),
                              "physicalWorld",
                              logicWorld,
                              0,
                              false,
                              0);

  // Visualization Attributes
  G4VisAttributes* WorldVisAtt = new G4VisAttributes(G4Colour(0.94,0.5,0.5));
    
  WorldVisAtt->SetForceSolid(false);
  logicWorld->SetVisAttributes(G4VisAttributes::Invisible);
 
  return motherVolume;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetBodyPartSensitivity()

void G4HumanPhantomConstruction::SetBodyPartSensitivity	(	G4String	,
		G4bool
	)

Definition at line 199 of file G4HumanPhantomConstruction.cc.

{
  G4cout << "This method is not currently working !!!!" << G4endl;
}

Here is the caller graph for this function:

SetPhantomModel()

void G4HumanPhantomConstruction::SetPhantomModel

(

G4String

newModel

)

Definition at line 249 of file G4HumanPhantomConstruction.cc.

{
  model = newModel;

  if (model == "MIRD")
    {
      G4cout<<" >> Phantom " << model << " will be built."<<G4endl;
    }
  if (model == "ORNLFemale")
    {
      G4cout<<" >> Phantom " << model << " will be built."<<G4endl;
    }

  if (model == "ORNLMale")
    {
      G4cout<<" >> Phantom " << model << " will be built."<<G4endl;
    }

  if (model == "MIX")
    {
      G4cout<<" >> Phantom " << model << " will be built."<<G4endl;
    }
  if (model == "MIRDHead")
    {
      G4cout<<" >> Phantom " << model << " will be built."<<G4endl;
    }

  if (model == "ORNLHead")
    {
      G4cout<<" >> Phantom " << model << " will be built."<<G4endl;
    }
}

Here is the caller graph for this function:

SetPhantomSex()

void G4HumanPhantomConstruction::SetPhantomSex

(

G4String

newSex

)

Definition at line 233 of file G4HumanPhantomConstruction.cc.

{
  sex=newSex;

  if (sex == "Male")
    {
      G4cout << ">> Male Phantom will be built." << G4endl;
    }
  if (sex == "Female")
    {
      G4cout << ">> Female Phantom will be built." << G4endl;
    }
  if ((sex != "Female") && (sex != "Male"))
    G4cout << sex << " can not be defined!" << G4endl;
}

Here is the caller graph for this function:

Member Data Documentation

material

G4HumanPhantomMaterial* G4HumanPhantomConstruction::material

private

Definition at line 60 of file G4HumanPhantomConstruction.hh.

messenger

G4HumanPhantomMessenger* G4HumanPhantomConstruction::messenger

private

Definition at line 61 of file G4HumanPhantomConstruction.hh.

model

G4String G4HumanPhantomConstruction::model

private

Definition at line 64 of file G4HumanPhantomConstruction.hh.

sensitivities

std::map<std::string,G4bool> G4HumanPhantomConstruction::sensitivities

private

Definition at line 66 of file G4HumanPhantomConstruction.hh.

sex

G4String G4HumanPhantomConstruction::sex

private

Definition at line 65 of file G4HumanPhantomConstruction.hh.

---

The documentation for this class was generated from the following files:

• G4HumanPhantomConstruction.hh
• G4HumanPhantomConstruction.cc