ML2PhantomConstruction.cc

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * 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.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
// The code was written by :
//  ^Claudio Andenna  claudio.andenna@ispesl.it, claudio.andenna@iss.infn.it
//      *Barbara Caccia barbara.caccia@iss.it
//      with the support of Pablo Cirrone (LNS, INFN Catania Italy)
//  with the contribute of Alessandro Occhigrossi*
//
// ^INAIL DIPIA - ex ISPESL and INFN Roma, gruppo collegato Sanità, Italy
// *Istituto Superiore di Sanità and INFN Roma, gruppo collegato Sanità, Italy
//  Viale Regina Elena 299, 00161 Roma (Italy)
//  tel (39) 06 49902246
//  fax (39) 06 49387075
//
// more information:
// http://g4advancedexamples.lngs.infn.it/Examples/medical-linac
//
//*******************************************************//

#include "ML2PhantomConstruction.hh"
#include "ML2PhantomConstructionMessenger.hh"
#include "G4SystemOfUnits.hh"

CML2PhantomConstruction::CML2PhantomConstruction(void): PVPhmWorld(0), sensDet(0)
{
    phantomContstructionMessenger=new CML2PhantomConstructionMessenger(this);
    idCurrentCentre=0;
}

CML2PhantomConstruction::~CML2PhantomConstruction(void)
{
    if (phantomName=="fullWater")
    {
        delete Ph_fullWater;
    }
    else if (phantomName=="boxInBox")
    {
        delete Ph_BoxInBox;
    }
}

CML2PhantomConstruction* CML2PhantomConstruction::instance = 0;

CML2PhantomConstruction* CML2PhantomConstruction::GetInstance(void)
{
  if (instance == 0)
    {
      instance = new CML2PhantomConstruction();
     
    }
  return instance;
}
bool CML2PhantomConstruction::design(void)
{
// switch between two different phantoms according to the main macro selection
    bool bPhanExists=false;

    std::cout << "I'm building "<< phantomName<<"  phantom"<< G4endl;

    if (phantomName=="fullWater")
    {
        Ph_fullWater=new CML2Ph_FullWater();bPhanExists=true;
        halfPhantomInsideSize=Ph_fullWater->getHalfContainerSize();
    }
    else if (phantomName=="boxInBox")
    {
        Ph_BoxInBox=new CML2Ph_BoxInBox();bPhanExists=true;
        halfPhantomInsideSize=Ph_BoxInBox->getHalfContainerSize();
    }

    if (centre.size()<1)
    {addNewCentre(G4ThreeVector(0.,0.,0.));}
    return bPhanExists;
}
G4int CML2PhantomConstruction::getTotalNumberOfEvents()
{
    if (phantomName=="fullWater")
    {return Ph_fullWater->getTotalNumberOfEvents();}
    else if (phantomName=="boxInBox")
    {return Ph_BoxInBox->getTotalNumberOfEvents();}
    return 0;
}

bool CML2PhantomConstruction::Construct(G4VPhysicalVolume *PVWorld,
        G4int saving_in_ROG_Voxels_every_events, G4int seed,
        G4String ROGOutFile, G4bool bSaveROG, G4bool bOV)
{
    idVolumeName=0;
    bOnlyVisio=bOV;
// a call to select the right phantom
    if(design())
    {
        phantomContstructionMessenger->SetReferenceWorld(bOV);  // create the phantom-world box
        G4Material *Vacuum=G4NistManager::Instance()->FindOrBuildMaterial("G4_Galactic");

        G4Box *phmWorldB = new G4Box("phmWorldG", halfPhantomInsideSize.getX(), halfPhantomInsideSize.getY(), halfPhantomInsideSize.getZ());
        G4LogicalVolume *phmWorldLV = new G4LogicalVolume(phmWorldB, Vacuum, "phmWorldL", 0, 0, 0);
        G4VisAttributes* simpleAlSVisAtt= new G4VisAttributes(G4Colour::White());
        simpleAlSVisAtt->SetVisibility(false);
//      simpleAlSVisAtt->SetForceWireframe(false);
        phmWorldLV->SetVisAttributes(simpleAlSVisAtt);
    

        PVPhmWorld= new G4PVPlacement(0, G4ThreeVector(0.,0.,0.), "phmWorldPV", phmWorldLV, PVWorld, false, 0);
    
    // create the actual phantom
        if (phantomName=="fullWater")
        {
            Ph_fullWater->Construct(PVPhmWorld, saving_in_ROG_Voxels_every_events, seed, ROGOutFile, bSaveROG);
            sensDet=Ph_fullWater->getSensDet();
            createPhysicalVolumeNamesList(Ph_fullWater->getPhysicalVolume());
            Ph_fullWater->writeInfo();
        }
        else if (phantomName=="boxInBox")
        {
            Ph_BoxInBox->Construct(PVPhmWorld, saving_in_ROG_Voxels_every_events, seed, ROGOutFile, bSaveROG);
            sensDet=Ph_BoxInBox->getSensDet();
            createPhysicalVolumeNamesList(Ph_BoxInBox->getPhysicalVolume());
            Ph_BoxInBox->writeInfo();
        }
        // I create the data base volumeName-volumeID in the sensitive detector 

        sensDet->setVolumeNameIdLink(volumeNameIdLink);
    }
    else
    {
        return false;
    }
    return true;
}
void CML2PhantomConstruction::createPhysicalVolumeNamesList(G4String  *matNames, G4int nMatNames)
{
    SvolumeNameId svnid;
    for (int i=0;i< nMatNames; i++)
    {
        svnid.volumeId=i;
        svnid.volumeName=matNames[i];
        volumeNameIdLink.push_back(svnid);
    }
}
void CML2PhantomConstruction::createPhysicalVolumeNamesList(G4VPhysicalVolume  *PV)
{
    int nLVD1;
    nLVD1=(int) PV->GetLogicalVolume()->GetNoDaughters();
    SvolumeNameId svnid;
        std::cout << "PV in name: " <<PV->GetName() << G4endl;
    if (nLVD1>0)
    {
        for (int i=0; i <nLVD1; i++)
        {
            createPhysicalVolumeNamesList(PV->GetLogicalVolume()->GetDaughter(i));
        }
        idVolumeName++;
        svnid.volumeId=idVolumeName;
        svnid.volumeName=PV->GetLogicalVolume()->GetMaterial()->GetName();
        volumeNameIdLink.push_back(svnid);
        std::cout << "physical volume name: " <<svnid.volumeName << G4endl;
    }
    else
    {
        idVolumeName++;
        svnid.volumeId=idVolumeName;
        svnid.volumeName=PV->GetLogicalVolume()->GetMaterial()->GetName();
        volumeNameIdLink.push_back(svnid);
        std::cout << "physical volume name: " <<svnid.volumeName << G4endl;
    }
}
bool  CML2PhantomConstruction::applyNewCentre()
{
    if (idCurrentCentre <(int) centre.size())
    {
        currentCentre=centre[idCurrentCentre];
        applyNewCentre(currentCentre);
        idCurrentCentre++;
        return true;
    }
    return false;
}
void CML2PhantomConstruction::writeInfo()
{
    if (!bOnlyVisio)
    {std::cout <<"Actual centre: "<<idCurrentCentre<<"/"<<centre.size() <<"  "<< G4endl;}
    std::cout <<"Phantom and its ROG centre: " << currentCentre<< G4endl;
}
void CML2PhantomConstruction::applyNewCentre(G4ThreeVector ctr)
{
    if (sensDet!=0)
    {   
        currentCentre=ctr;
        G4GeometryManager::GetInstance()->OpenGeometry();
        PVPhmWorld->SetTranslation(ctr);
        sensDet->GetROgeometry()->GetROWorld()->GetLogicalVolume()->GetDaughter(0)->SetTranslation(ctr);
        sensDet->resetVoxelsSingle();
        G4GeometryManager::GetInstance()->CloseGeometry();
        G4RunManager::GetRunManager()->GeometryHasBeenModified();
    }
}
G4String CML2PhantomConstruction::getCurrentTranslationString()
{
    char cT[5];
    G4int cTI;
    G4String translationName;
    cTI=(G4int)((currentCentre.getX()/mm));
    sprintf(cT,"%d",cTI);
    translationName="_TrX"+G4String(cT)+"_";
    cTI=(G4int)((currentCentre.getY()/mm));
    sprintf(cT,"%d",cTI);
    translationName+="Y"+G4String(cT)+"_";
    cTI=(G4int)((currentCentre.getZ()/mm));
    sprintf(cT,"%d",cTI);
    translationName+="Z"+G4String(cT);
    return translationName;
}