larg4::OpDetReadoutGeometry Class Reference

#include "OpDetReadoutGeometry.h"

Inheritance diagram for larg4::OpDetReadoutGeometry:

Public Member Functions
	OpDetReadoutGeometry (G4String OpDetSensitiveName, const G4String name="OpDetReadoutGeometry")
virtual	~OpDetReadoutGeometry ()
virtual void	Construct ()

Private Member Functions
void	FindVolumes (G4VPhysicalVolume *, G4String, std::vector< G4Transform3D >, std::vector< G4LogicalVolume * > &, std::vector< G4Transform3D > &)

Private Attributes
std::vector< G4LogicalVolume * >	fOpDetVolumes
std::vector< G4Transform3D >	fOpDetTransformations
G4String	fOpDetSensitiveName

Detailed Description

Definition at line 37 of file OpDetReadoutGeometry.h.

Constructor & Destructor Documentation

larg4::OpDetReadoutGeometry::OpDetReadoutGeometry	(	G4String	OpDetSensitiveName,
		const G4String	name = "OpDetReadoutGeometry"
	)

Definition at line 24 of file OpDetReadoutGeometry.cxx.

References fOpDetSensitiveName.

                                                                                             :
    G4VUserParallelWorld(name)
  {
    fOpDetSensitiveName = OpDetSensitiveName;   
  }

larg4::OpDetReadoutGeometry::~OpDetReadoutGeometry ( )

virtual

Definition at line 30 of file OpDetReadoutGeometry.cxx.

  {}

Member Function Documentation

void larg4::OpDetReadoutGeometry::Construct ( )

virtual

Definition at line 33 of file OpDetReadoutGeometry.cxx.

References larg4::OpDetLookup::AddPhysicalVolume(), FindVolumes(), fOpDetSensitiveName, fOpDetTransformations, fOpDetVolumes, g4b::DetectorConstruction::GetWorld(), larg4::OpDetLookup::Instance(), sim::LArG4Parameters::OpticalParamModels(), sim::LArG4Parameters::OpticalParamOrientations(), sim::LArG4Parameters::OpticalParamParameters(), sim::LArG4Parameters::OpticalParamVolumes(), and larg4::TheOpDetLookup.

  {
    mf::LogInfo("OpDetReadoutGeometry") << "constructing parallel world, looking for " 
                                      << fOpDetSensitiveName;

    // Get an empty parallel world volume
    G4VPhysicalVolume * ParallelWorld = GetWorld();
    
    // Start with empty vectors
    std::vector<G4LogicalVolume*>  OpDetVolumes;
    std::vector<G4Transform3D>     OpDetTransformations;
    
    // Get the primary world volume
    G4VPhysicalVolume * WorldPhysical = g4b::DetectorConstruction::GetWorld();

    // Find the OpDet volumes
    std::vector<G4Transform3D> EmptyVector;
    EmptyVector.clear();
    FindVolumes(WorldPhysical, fOpDetSensitiveName, EmptyVector, OpDetVolumes, OpDetTransformations );

    fOpDetVolumes          = OpDetVolumes;
    fOpDetTransformations  = OpDetTransformations;

    // Get the OpDet Lookup Table
    OpDetLookup * TheOpDetLookup = OpDetLookup::Instance();

    // Create sensitive detector
    OpDetSensitiveDetector * TheSD = new OpDetSensitiveDetector("OpDetSensitiveDetector");


    if(OpDetVolumes.size()>0)
      {

        
        
        // Make placements
        for(unsigned int i=0; i!=OpDetVolumes.size(); i++)
        {
          std::stringstream VolumeName;
          VolumeName.flush();
          VolumeName.str("OpDetVolume_");
          VolumeName<<i;
          
          G4Transform3D      TheTransform = OpDetTransformations.at(i);

          G4VSolid * TheSolid = OpDetVolumes.at(i)->GetSolid();
          G4Material * TheMaterial = OpDetVolumes.at(i)->GetMaterial();
          G4LogicalVolume * TheLogVolume = new G4LogicalVolume(TheSolid,TheMaterial,VolumeName.str().c_str());
          
          TheLogVolume->SetSensitiveDetector(TheSD   );
         

          G4PVPlacement * ThePlacement 
            = new G4PVPlacement( TheTransform,
                                 VolumeName.str().c_str(),
                                 TheLogVolume,
                                 ParallelWorld,
                                 false,          
                                 0);             
          
          //      CLHEP::Hep3Vector trans = ThePlacement->GetTranslation();

          TheOpDetLookup->AddPhysicalVolume(ThePlacement);

        }
      }


    // Now add any optically parameterized volumes

    std::vector<G4LogicalVolume*>  OpParamVolumesFound;
    std::vector<G4Transform3D>     OpParamTransformationsFound;
    
    art::ServiceHandle<sim::LArG4Parameters> lgp;
    
    std::vector<std::string> OpParamModels       = lgp->OpticalParamModels();
    std::vector<std::string> OpParamVolumes      = lgp->OpticalParamVolumes();
    std::vector<int>         OpParamOrientations = lgp->OpticalParamOrientations();;
    std::vector<std::vector<std::vector<double > > > OpParamParameters    = lgp->OpticalParamParameters();
    
    if((OpParamModels.size()!=OpParamVolumes.size())||
       (OpParamModels.size()!=OpParamOrientations.size())||
       (OpParamModels.size()!=OpParamParameters.size()))
      {
        throw cet::exception("OpDetReadoutGeometry")<<"sizes of OpParam specification vectors do not match\n";
      }
    
    for(size_t imodel=0; imodel!=OpParamVolumes.size(); ++imodel)
      {
        EmptyVector.clear();
        FindVolumes(WorldPhysical, OpParamVolumes.at(imodel), EmptyVector, OpParamVolumesFound, OpParamTransformationsFound );
        mf::LogInfo("OpDetReadoutGeometry")<< "Found " << OpParamVolumesFound.size()<< " volumes of name " << OpParamVolumes.at(imodel)<< " to attach optical parameterization " << OpParamModels.at(imodel)<<std::endl;
        
        
        // Since the same named model may be instantiated more than once with
        //  different parameters,  create a unique sensitive detector name for this
        //  instance
        
        std::stringstream SDName("");
        SDName<<OpParamModels.at(imodel)<<"_"<<imodel;
        
        OpParamSD * ParamSD = new OpParamSD(SDName.str().c_str(), OpParamModels.at(imodel), OpParamOrientations.at(imodel), OpParamParameters.at(imodel));
        

        if(OpParamVolumesFound.size()>0)
          {
            for(unsigned int ivol=0; ivol!=OpParamVolumes.size(); ivol++)
              {
                std::stringstream VolumeName;
                VolumeName.flush();
                VolumeName.str("OpParamVolume_");
                VolumeName<<ivol;
                
                G4Transform3D      TheTransform = OpParamTransformationsFound.at(ivol);
                
                G4VSolid * TheSolid = OpParamVolumesFound.at(ivol)->GetSolid();
                G4Material * TheMaterial = OpParamVolumesFound.at(ivol)->GetMaterial();
                G4LogicalVolume * TheLogVolume = new G4LogicalVolume(TheSolid,TheMaterial,VolumeName.str().c_str());
                

                G4PVPlacement * ThePlacement 
                  = new G4PVPlacement( TheTransform,
                                       VolumeName.str().c_str(),
                                       TheLogVolume,
                                       ParallelWorld,
                                       false,          
                                       0);             
                
                TheLogVolume->SetSensitiveDetector(ParamSD   );   
                

                // This line just suppressed a compiler warning
                ThePlacement->GetTranslation();         
                

              }
            
          }
      }
  }

void larg4::OpDetReadoutGeometry::FindVolumes ( G4VPhysicalVolume *  PhysicalVolume, G4String  OpDetName, std::vector< G4Transform3D >  TransformSoFar, std::vector< G4LogicalVolume * > &  OpDetVolumes, std::vector< G4Transform3D > &  OpDetTransformations  )

private

Definition at line 176 of file OpDetReadoutGeometry.cxx.

Referenced by Construct().

  {
    
    // Add the next layer of transformation to the vector
    G4ThreeVector Translation = PhysicalVolume->GetObjectTranslation();
    G4RotationMatrix Rotation = PhysicalVolume->GetObjectRotationValue();
    G4Transform3D NextTransform( Rotation, Translation );
    
    TransformSoFar.push_back(NextTransform);


    // Check if this volume is a OpDet
    G4String OpDetNameUnderscore = OpDetName+"_";
    G4String VolumeName = PhysicalVolume->GetName();   
    if( ( VolumeName == OpDetName ) ||
        ( VolumeName.find( OpDetNameUnderscore,0,OpDetNameUnderscore.length() )==0 )
        )
      {

        // We found a OpDet! Store its volume and global transformation
        G4ThreeVector     Trans(0,0,0);
        G4RotationMatrix  Rot(0,0,0);
        G4Transform3D TotalTransform(Rot,Trans);
        //for ( std::vector<G4Transform3D>::reverse_iterator it = TransformSoFar.rbegin();
        //     it != TransformSoFar.rend(); ++it )
        


        for ( std::vector<G4Transform3D>::iterator it = TransformSoFar.begin();
              it != TransformSoFar.end(); ++it )
          {
            CLHEP::Hep3Vector trans = (*it).getTranslation();
            CLHEP::HepRotation rot =  (*it).getRotation();
            TotalTransform =  TotalTransform * (*it);
          }

        OpDetVolumes.push_back(PhysicalVolume->GetLogicalVolume());     
        OpDetTransformations.push_back(TotalTransform);

      }
    else
      {
        // We did not find a OpDet.  Keep looking through daughters.
        G4LogicalVolume * LogicalVolume = PhysicalVolume->GetLogicalVolume();
                
        // Loop through the daughters of the volume
        G4int NumberDaughters = LogicalVolume->GetNoDaughters();
        for(G4int i=0; i!=NumberDaughters; ++i)
          {
            // Get the ith daughter volume
            G4VPhysicalVolume * Daughter = LogicalVolume->GetDaughter(i);
            
            // Recursively step into this volume
            FindVolumes(Daughter, OpDetName, TransformSoFar, OpDetVolumes, OpDetTransformations);
          }
      }
  }

Member Data Documentation

G4String larg4::OpDetReadoutGeometry::fOpDetSensitiveName

private

Definition at line 48 of file OpDetReadoutGeometry.h.

Referenced by Construct(), and OpDetReadoutGeometry().

std::vector<G4Transform3D> larg4::OpDetReadoutGeometry::fOpDetTransformations

private

Definition at line 47 of file OpDetReadoutGeometry.h.

Referenced by Construct().

std::vector<G4LogicalVolume*> larg4::OpDetReadoutGeometry::fOpDetVolumes

private

Definition at line 46 of file OpDetReadoutGeometry.h.

Referenced by Construct().

---

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

• larsim/v06_53_00/source/larsim/LArG4/OpDetReadoutGeometry.h
• larsim/v06_53_00/source/larsim/LArG4/OpDetReadoutGeometry.cxx