G3Division Class Reference

#include <G3Division.hh>

Public Member Functions
void	CreatePVReplica ()
	G3Division (G3DivType type, G3VolTableEntry *vte, G3VolTableEntry *mvte, G4int nofDivision, G4int iaxis, G4int nmed, G4double c0, G4double step)
	G3Division (G3VolTableEntry *vte, G3VolTableEntry *mvte, const G3Division &division)
void	UpdateVTE ()
virtual	~G3Division ()

Private Member Functions
G3VolTableEntry *	CreateEnvelope (G4String shape, G4double hi, G4double lo, G4double par[], G4int npar)
void	CreateSolid (G4String shape, G4double par[], G4int npar)
G3VolTableEntry *	Dvn ()
G3VolTableEntry *	Dvn2 ()
G3VolTableEntry *	Dvt ()
G3VolTableEntry *	Dvt2 ()
void	Exception (G4String where, G4String what)
void	SetRangeAndAxis ()

Private Attributes
EAxis	fAxis
G4double	fC0
G4double	fHighRange
G4int	fIAxis
G4double	fLowRange
G3VolTableEntry *	fMVTE
G4int	fNmed
G4int	fNofDivisions
G4double	fOffset
G4double	fStep
G3DivType	fType
G3VolTableEntry *	fVTE
G4double	fWidth

Detailed Description

Definition at line 54 of file G3Division.hh.

Constructor & Destructor Documentation

G3Division() [1/2]

G3Division::G3Division	(	G3DivType	type,
		G3VolTableEntry *	vte,
		G3VolTableEntry *	mvte,
		G4int	nofDivision,
		G4int	iaxis,
		G4int	nmed,
		G4double	c0,
		G4double	step
	)

Definition at line 49 of file G3Division.cc.

  : fType(type),
    fVTE(vte),
    fMVTE(mvte),
    fNofDivisions(nofDivisions),
    fIAxis(iaxis),
    fNmed(nmed),
    fC0(c0),
    fStep(step),
    fLowRange(0.),
    fHighRange(0.),
    fWidth(0.),
    fOffset(0.),
    fAxis(kXAxis)
{
  fVTE->SetHasNegPars(true);
}

References fVTE, and G3VolTableEntry::SetHasNegPars().

G3Division() [2/2]

G3Division::G3Division	(	G3VolTableEntry *	vte,
		G3VolTableEntry *	mvte,
		const G3Division &	division
	)

Definition at line 69 of file G3Division.cc.

  : fVTE(vte),
    fMVTE(mvte)
{
  // only "input" parameters are copied from division
  fType = division.fType;
  fNofDivisions = division.fNofDivisions;
  fIAxis = division.fIAxis;
  fNmed = division.fNmed;
  fC0 = division.fC0;
  fStep = division.fStep;
 
  // other parameters are set as in standard constructor
  fLowRange = 0.;
  fHighRange = 0.;
  fWidth = 0.;
  fOffset = 0.;
  fAxis = kXAxis;
  fVTE->SetHasNegPars(true);
}

References fAxis, fC0, fHighRange, fIAxis, fLowRange, fNmed, fNofDivisions, fOffset, fStep, fType, fVTE, fWidth, kXAxis, and G3VolTableEntry::SetHasNegPars().

~G3Division()

G3Division::~G3Division ( )

virtual

Definition at line 91 of file G3Division.cc.

{}

Member Function Documentation

CreateEnvelope()

G3VolTableEntry * G3Division::CreateEnvelope ( G4String  shape, G4double  hi, G4double  lo, G4double  par[], G4int  npar  )

private

Definition at line 437 of file G3Division.cc.

{
    // verbose
    // G4cout << "  G3Division::CreateEnvelope " << "fIAaxis= " << fIAxis
    //        << " hi= " << hi
    //        << " lo= " << lo
    //        << G4endl;
 
    G4double *Rpar = new G4double[npar+2];
    for (G4int i=0; i<npar; ++i){ Rpar[i] = par[i];}
    G4double pos[3] = {0.,0.,0.};
  
    if ( shape == "BOX" ) {
      Rpar[fIAxis-1] = (hi - lo)/2./cm;
      pos [fIAxis-1] = (hi + lo)/2.;
    }
    else if ( shape == "TRD1" ) {
      if ( fIAxis == 1 || fIAxis == 2  ) {
        Exception("CreateEnvelope","TRD1-x,y");
      }
      else if ( fIAxis == 3 ) {
    // x = x1 + (c-z1)(x2 -x1)/(z2-z1)
    G4double tn, x1, z1;
        tn = (Rpar[1] - Rpar[0])/(2.* Rpar[3]); 
        x1 = Rpar[0]; z1 = -Rpar[3];
        Rpar[0] = x1 + tn * (lo/cm - z1);
        Rpar[1] = x1 + tn * (hi/cm - z1);
        Rpar[3] = (hi - lo)/2./cm;
        pos[2]  = (hi + lo)/2.;
      }
    }
    else if ( shape == "TRD2" ) {
      if ( fIAxis == 1 || fIAxis == 2) {
        Exception("CreateEnvelope","TRD2-x,y");
      }
      else if ( fIAxis == 3 ) {
    // x = x1 + (c-z1)(x2 -x1)/(z2-z1)
    // y = y1 + (c-z1)(y2 -y1)/(z2-z1)
    G4double tn1, tn2, x1, y1, z1;
        tn1 = (Rpar[1] - Rpar[0])/(2.* Rpar[4]); 
        tn2 = (Rpar[3] - Rpar[2])/(2.* Rpar[4]); 
        x1 = Rpar[0]; y1 = Rpar[2]; z1 = -Rpar[3];
        Rpar[0] = x1 + tn1 * (lo/cm - z1);
        Rpar[1] = x1 + tn1 * (hi/cm - z1);
        Rpar[2] = y1 + tn2 * (lo/cm - z1);
        Rpar[3] = y1 + tn2 * (hi/cm - z1);
        Rpar[4] = (hi - lo)/2./cm;
        pos[2]  = (hi + lo)/2.;
      }
    }
    else if ( shape == "TRAP" ) {
      Exception("CreateEnvelope","TRAP-x,y,z");
    }
    else if ( shape == "TUBE" ) {
      if ( fIAxis == 1 ) {
        Rpar[0] = lo/cm;
        Rpar[1] = hi/cm;
      }
      else if ( fIAxis == 2 ) {
        Rpar[3] = lo/deg;
        Rpar[4] = hi/deg;
        npar = npar + 2;
        shape = "TUBS";
      }
      else if ( fIAxis == 3 ) {
        Rpar[2] = (hi - lo)/2./cm;
        pos [2] = (hi + lo)/2.;
      }
    }
    else if ( shape == "TUBS" ) {
      if ( fIAxis == 1 ) {
        Rpar[0] = lo/cm;
        Rpar[1] = hi/cm;
      }
      else if ( fIAxis == 2 ) {
        Rpar[3] = lo/deg;
        Rpar[4] = hi/deg;
      }
      else if ( fIAxis == 3 ) {
        Rpar[2] = (hi - lo)/2./cm;
        pos [2] = (hi + lo)/2.;
      }
    }
    else if ( shape == "CONE" ) {
      if ( fIAxis == 1) {
        Exception("CreateEnvelope","CONE-x,z");
      }
      else if ( fIAxis == 2 ) {
        Rpar[5] = lo/deg;
        Rpar[6] = hi/deg;
        npar = npar + 2;
        shape = "CONS";
      }
      else if ( fIAxis == 3 ) {
        G4double tn1, tn2, rmin, rmax, z1;
        tn1 = (Rpar[3] - Rpar[1])/(2.* Rpar[0]); 
        tn2 = (Rpar[4] - Rpar[2])/(2.* Rpar[0]); 
        rmin = Rpar[1]; rmax = Rpar[2]; z1 = -Rpar[0];
        Rpar[1] = rmin + tn1 * (lo/cm - z1);
        Rpar[3] = rmin + tn1 * (hi/cm - z1);
        Rpar[2] = rmax + tn2 * (lo/cm - z1);
        Rpar[4] = rmax + tn2 * (hi/cm - z1);
        Rpar[0] = (hi - lo)/2./cm;
        pos[2]  = (hi + lo)/2.;
      }
    }
    else if ( shape == "CONS" ) {
      if ( fIAxis == 1 ) {
        Exception("CreateEnvelope","CONS-x");
      }
      else if ( fIAxis == 2 ) {
        Rpar[5] = lo/deg;
        Rpar[6] = hi/deg;
      }
      else if ( fIAxis == 3 ) {
        G4double tn1, tn2, rmin, rmax, z1;
        tn1 = (Rpar[3] - Rpar[1])/(2.* Rpar[0]); 
        tn2 = (Rpar[4] - Rpar[2])/(2.* Rpar[0]); 
        rmin = Rpar[1]; rmax = Rpar[2]; z1 = -Rpar[0];
        Rpar[1] = rmin + tn1 * (lo/cm - z1);
        Rpar[3] = rmin + tn1 * (hi/cm - z1);
        Rpar[2] = rmax + tn2 * (lo/cm - z1);
        Rpar[4] = rmax + tn2 * (hi/cm - z1);
        Rpar[0] = (hi - lo)/2./cm;
        pos[2]  = (hi + lo)/2.;
      }
    }
    else if ( shape == "SPHE" ) {
      Exception("CreateEnvelope","SPHE-x,y,z");                
    }
    else if ( shape == "PARA" ) {
      Exception("CreateEnvelope","PARA-x,y,z");
    }
    else if ( shape == "PGON" ) {
      if ( fIAxis == 2) {
    Rpar[0] = lo/deg;
    Rpar[1] = hi/deg;
    // rotm = ???
      }
      else {
        Exception("CreateEnvelope","PGON-x,z");
      }
    }
    else if ( shape == "PCON" ) {
      if ( fIAxis == 2) {
    Rpar[0] = lo/deg;
    Rpar[1] = hi/deg;
    // rotm = ???
      }
      else {
        Exception("CreateEnvelope","PCON-x,z");
      }
    }
    else {
       Exception("CreateEnvelope", "Unknown shape" + shape);
    }  
 
    // create new VTE corresponding to envelope
    G4String envName = fVTE->GetName() + "_ENV"; 
    G3VolTableEntry* envVTE 
      = G4CreateVTE(envName, shape, fNmed, Rpar, npar);
 
    // create a G3Pos object and add it to envVTE
    G4String motherName = fMVTE->GetMasterClone()->GetName();
    G4ThreeVector* offset = new G4ThreeVector(pos[0],pos[1],pos[2]);    
    G4String only = "ONLY";
    G3Pos* aG3Pos = new G3Pos(motherName, 1, offset, 0, only);              
    envVTE->AddG3Pos(aG3Pos);
 
    delete [] Rpar; 
 
    return envVTE;
}

References G3VolTableEntry::AddG3Pos(), cm, deg, Exception(), fIAxis, fMVTE, fNmed, fVTE, G4CreateVTE(), G3VolTableEntry::GetMasterClone(), G3VolTableEntry::GetName(), pos, and Rpar.

Referenced by Dvn2(), Dvt(), and Dvt2().

CreatePVReplica()

void G3Division::CreatePVReplica

(

)

Definition at line 127 of file G3Division.cc.

{
  G4String name = fVTE->GetName();
  G4LogicalVolume* lv =  fVTE->GetLV();
  G4LogicalVolume* mlv = fMVTE->GetLV();
  
  G4String shape = fMVTE->GetShape();
  if (shape == "PARA") {
    // The para volume cannot be replicated using G4PVReplica.
    // (Replicating a volume along a cartesian axis means "slicing" it
    // with slices -perpendicular- to that axis.)
    
    // position the replicated elements    
    for (G4int i=0; i<fNofDivisions; i++) {
       G4ThreeVector position = G4ThreeVector(); 
       position[fIAxis-1] = fLowRange + fWidth/2. + i*fWidth;
       if (position.y()!=0.) 
         position.setX(position.y()*((G4Para*)lv->GetSolid())->GetTanAlpha());
 
       #ifndef G3G4_NO_REFLECTION
       G4ReflectionFactory::Instance()
         ->Place(G4Translate3D(position), name, lv, mlv, 0, i);
 
       #else  
       new G4PVPlacement(0, position, lv, name, mlv, 0, i);
 
       #endif
    }
    
    // G4PVReplica cannot be created
    return;   
  }     
  
  #ifdef G3G4DEBUG
    G4cout << "Create G4PVReplica name " << name << " logical volume name " 
       << lv->GetName() << " mother logical volme name "
       << mlv->GetName() << " axis " << fAxis << " ndivisions " 
       << fNofDivisions << " width " << fWidth << " Offset "
       << fOffset << G4endl;
  #endif
 
  #ifndef G3G4_NO_REFLECTION
  G4ReflectionFactory::Instance()
    ->Replicate(name, lv, mlv, fAxis, fNofDivisions, fWidth, fOffset);
 
  #else    
  new G4PVReplica(name, lv, mlv, fAxis, fNofDivisions, fWidth, fOffset);
 
  #endif
}

References fAxis, fIAxis, fLowRange, fMVTE, fNofDivisions, fOffset, fVTE, fWidth, G4cout, G4endl, G3VolTableEntry::GetLV(), G3VolTableEntry::GetName(), G4LogicalVolume::GetName(), G3VolTableEntry::GetShape(), G4LogicalVolume::GetSolid(), G4ReflectionFactory::Instance(), G4InuclParticleNames::name(), G4ReflectionFactory::Place(), and G4ReflectionFactory::Replicate().

Referenced by G3toG4BuildPVTree().

CreateSolid()

void G3Division::CreateSolid ( G4String  shape, G4double  par[], G4int  npar  )

private

Definition at line 614 of file G3Division.cc.

{
    G4double *Rpar = new G4double[npar+2];
    for (G4int i=0; i<npar; ++i){ Rpar[i] = par[i];}
 
    // verbose
    // G4cout << "G3Division::CreateSolid volume before: " 
    //        << fVTE->GetName() << " " << shape << G4endl;    
    // G4cout << " npar,Rpar: " << npar;
    // for (G4int ii = 0; ii < npar; ++ii) G4cout << " " << Rpar[ii];
    // G4cout << G4endl;
  
    if ( shape == "BOX" ) {
      if      ( fIAxis == 1 ) Rpar[0] = fWidth/2./cm;
      else if ( fIAxis == 2 ) Rpar[1] = fWidth/2./cm; 
      else if ( fIAxis == 3 ) Rpar[2] = fWidth/2./cm; 
    }
    else if ( shape == "TRD1" ) {
      if ( fIAxis == 1 || fIAxis == 2 ) {
        Exception("CreateSolid", "TRD1-x,y");
      }
      else if ( fIAxis == 3 ) {
         Rpar[3] = fWidth/2./cm; 
      }
    }
    else if ( shape == "TRD2" ) {
      if ( fIAxis == 1 || fIAxis == 2 ) {
        Exception("CreateSolid", "TRD2-x,y");
      }
      else if ( fIAxis == 3 ) {
         Rpar[4] =  fWidth/2./cm; 
      }
    }
    else if ( shape == "TRAP" ) {
      if ( fIAxis == 1 || fIAxis == 2) {
        Exception("CreateSolid", "TRAP-x,y");
      }
      else if ( fIAxis == 3 ) {
         Rpar[0] =  fWidth/2./cm; 
      }
    }
    else if ( shape == "TUBE" ) {
      if ( fIAxis == 1 ) {
         Rpar[1] = Rpar[0] + fWidth/cm;
         fOffset = Rpar[0]*cm;
      }
      else if ( fIAxis == 2 ) {
         Rpar[3] = 0.; 
         Rpar[4] = fWidth/deg; 
         shape = "TUBS";
         npar = npar + 2;
      }
      else if ( fIAxis == 3 ) {
         Rpar[2] = fWidth/2./cm; 
      }
    }
    else if ( shape == "TUBS" ) {
      if ( fIAxis == 1 ) {
        Rpar[1] = Rpar[0] + fWidth/cm;
        fOffset = Rpar[0]*cm;
      }
      else if ( fIAxis == 2 ) {
         fOffset = Rpar[3]*deg; 
         Rpar[3] = 0.;
         Rpar[4] =  fWidth/deg;
      }
      else if ( fIAxis == 3 ) {
         Rpar[2] = fWidth/2./cm; 
      }
    }
    else if ( shape == "CONE" ) {
      if ( fIAxis == 1 ) {
        Exception("CreateSolid", "CONE-x"); 
      }
      else if ( fIAxis == 2 ) {
         Rpar[5] = 0.;
         Rpar[6] = fWidth/deg;
         shape = "CONS";
         npar = npar + 2;
      }
      else if ( fIAxis == 3 ) {
         Rpar[0] = fWidth/2./cm; 
      }
    }
    else if ( shape == "CONS" ) {
      if ( fIAxis == 1 ) {
        Exception("CreateSolid", "CONS-x"); 
      }
      else if ( fIAxis == 2 ) {
         fOffset = Rpar[5]*deg;
         Rpar[5] = 0.;
         Rpar[6] = fWidth/deg;
      }
      else if ( fIAxis == 3 ) {
         Rpar[0] = fWidth/2./cm; 
      }
    }
    else if (shape == "PARA") {
      if      ( fIAxis == 1 ) {
         Rpar[0] = fWidth/2./cm;
      }  
      else if ( Rpar[4] == 0. && Rpar[5] == 0. ) {
         // only special case for axis 2,3 is supported
        if ( fIAxis == 2 ) {
          Rpar[1] = fWidth/2./cm;
    }  
    else if ( fIAxis == 3) {
          Rpar[2] = fWidth/2./cm;
    }
      }   
      else    
         Exception("CreateSolid", shape);
    }    
    else if (shape == "SPHE") {
      Exception("CreateSolid", shape);
    }
    else if ( shape == "PGON" ) {
      if ( fIAxis == 2 ) {
         fOffset = Rpar[0]*deg;
         Rpar[0] = 0.;
         Rpar[1] = fWidth/deg;
         Rpar[2] = 1.;
      }
      else
       Exception("CreateSolid", shape);
    }
    else if ( shape == "PCON" ) {
      if ( fIAxis == 2 ) {
         fOffset = Rpar[0]*deg;
         Rpar[0] = 0.;
         Rpar[1] = fWidth/deg;
      }
      else {
        Exception("CreateSolid", shape);
      } 
    }
    else {
       Exception("CreateSolid", "Unknown shape" + shape);
    }  
 
    // create solid and set it to fVTE
    G4bool hasNegPars;
    G4bool deferred;   
    G4bool okAxis[3];
    G4VSolid* solid
    = G3toG4MakeSolid(fVTE->GetName(), shape, Rpar, npar, hasNegPars, deferred, okAxis);  
 
    if (hasNegPars) {
       G4String err_message = "CreateSolid VTE " + fVTE->GetName()
                            + " has negative parameters.";
       G4Exception("G3Division::CreateSolid()", "G3toG40006",
                   FatalException, err_message);
       return;
    }   
    
    // update vte
    fVTE->SetSolid(solid);
    fVTE->SetNRpar(npar, Rpar); 
    fVTE->SetHasNegPars(hasNegPars);
 
    // verbose
    // G4cout << "G3Division::CreateSolid volume after: " 
    //        << fVTE->GetName() << " " << shape << G4endl;    
    // G4cout << " npar,Rpar: " << npar;
    // for (G4int iii = 0; iii < npar; ++iii) G4cout << " " << Rpar[iii];
    // G4cout << G4endl;
    delete [] Rpar;
}

References cm, deg, Exception(), FatalException, fIAxis, fOffset, fVTE, fWidth, G3toG4MakeSolid(), G4Exception(), G3VolTableEntry::GetName(), Rpar, G3VolTableEntry::SetHasNegPars(), G3VolTableEntry::SetNRpar(), and G3VolTableEntry::SetSolid().

Referenced by Dvn(), Dvn2(), Dvt(), and Dvt2().

Dvn()

G3VolTableEntry * G3Division::Dvn ( )

private

Definition at line 786 of file G3Division.cc.

{   
  // no envelope need to be created 
 
  // get parameters from mother
  G4String shape = fMVTE->GetShape(); 
  G4double* Rpar = fMVTE->GetRpar();
  G4int     npar = fMVTE->GetNpar();
 
  // set width for replica and create solid
  fWidth = (fHighRange - fLowRange)/fNofDivisions;
  CreateSolid(shape, Rpar, npar);
 
  return 0;           
}

References CreateSolid(), fHighRange, fLowRange, fMVTE, fNofDivisions, fWidth, G3VolTableEntry::GetNpar(), G3VolTableEntry::GetRpar(), G3VolTableEntry::GetShape(), and Rpar.

Referenced by UpdateVTE().

Dvn2()

G3VolTableEntry * G3Division::Dvn2 ( )

private

Definition at line 802 of file G3Division.cc.

{
  // to be defined as const of this class
  G4double Rmin = 0.0001*cm;
 
  G4String shape = fMVTE->GetShape();
  G4double* Rpar = fMVTE->GetRpar();
  G4int     npar = fMVTE->GetNpar();
 
  G4double c0 = fC0;
  if (fAxis == kPhi)  c0 = c0*deg;
  else                c0 = c0*cm;
          
  // create envelope (if needed)
  G3VolTableEntry* envVTE = 0;
  if( std::abs(c0 - fLowRange) > Rmin) {
    envVTE = CreateEnvelope(shape, fHighRange, c0, Rpar, npar);
    Rpar = envVTE->GetRpar();
    npar = envVTE->GetNpar();
  }  
 
  // set width for replica and create solid
  fWidth = (fHighRange - c0)/fNofDivisions;
  CreateSolid(shape, Rpar, npar);
 
  return envVTE;
}

References cm, CreateEnvelope(), CreateSolid(), deg, fAxis, fC0, fHighRange, fLowRange, fMVTE, fNofDivisions, fWidth, G3VolTableEntry::GetNpar(), G3VolTableEntry::GetRpar(), G3VolTableEntry::GetShape(), kPhi, and Rpar.

Referenced by UpdateVTE().

Dvt()

G3VolTableEntry * G3Division::Dvt ( )

private

Definition at line 830 of file G3Division.cc.

{
  // to be defined as const of this class
  G4double Rmin = 0.0001*cm;
 
  // get parameters from mother
  G4String shape = fMVTE->GetShape();
  G4double* Rpar = fMVTE->GetRpar();
  G4int     npar = fMVTE->GetNpar();
 
  // calculate the number of divisions    
  G4int ndvmx = fNofDivisions;
  G4double step = fStep;
  
  if (fAxis == kPhi)  step = step*deg;
  else                step = step*cm;
 
  G4int ndiv = G4int((fHighRange - fLowRange + Rmin)/step);
  // to be added warning
  if (ndvmx > 255) ndvmx = 255;
  if (ndiv > ndvmx && ndvmx > 0 ) ndiv = ndvmx;
 
  // create envVTE (if needed)
  G3VolTableEntry* envVTE = 0;
  G4double delta = std::abs((fHighRange - fLowRange) - ndiv*step);
  if (delta > Rmin) {
    envVTE 
       = CreateEnvelope(shape, fHighRange-delta/2., fLowRange+delta/2., 
                        Rpar, npar);
    Rpar = envVTE->GetRpar();
    npar = envVTE->GetNpar();
  }
 
  // set width for replica and create solid
  fWidth = step;
  fNofDivisions = ndiv;
  CreateSolid(shape, Rpar, npar);
 
  return envVTE;
}

References cm, CreateEnvelope(), CreateSolid(), deg, fAxis, fHighRange, fLowRange, fMVTE, fNofDivisions, fStep, fWidth, G3VolTableEntry::GetNpar(), G3VolTableEntry::GetRpar(), G3VolTableEntry::GetShape(), kPhi, and Rpar.

Referenced by UpdateVTE().

Dvt2()

G3VolTableEntry * G3Division::Dvt2 ( )

private

Definition at line 871 of file G3Division.cc.

{
  // to be defined as const of this class
  G4double Rmin = 0.0001*cm;
 
  // get parameters from mother
  G4String shape = fMVTE->GetShape();
  G4double* Rpar = fMVTE->GetRpar();
  G4int     npar = fMVTE->GetNpar();
 
  // calculate the number of divisions   
  G4int ndvmx = fNofDivisions;
  G4double step = fStep;
  G4double c0 = fC0;
 
  if(fAxis == kPhi){
    step = step*deg;
    c0 = c0*deg;
  } 
  else {
    step = step*cm;
    c0 = c0*cm;
  }  
 
  G4int ndiv = G4int((fHighRange - c0 + Rmin)/step);
  // to be added warning
  if (ndvmx > 255) ndvmx = 255;
  if (ndiv > ndvmx && ndvmx > 0 ) ndiv = ndvmx;
 
  // create envelope (if needed)
  G3VolTableEntry* envVTE = 0;
  G4double delta = std::abs((fHighRange - c0) - ndiv*step);
  if (std::abs(c0 - fLowRange) > Rmin) {
    envVTE 
      = CreateEnvelope(shape, fHighRange-delta/2., c0+delta/2., Rpar, npar);
    Rpar = envVTE->GetRpar();
    npar = envVTE->GetNpar();
  }
 
  // set with for replica and create solid
  fWidth = step;
  fNofDivisions = ndiv;
  CreateSolid(shape, Rpar, npar);
 
  return envVTE;     
}

References cm, CreateEnvelope(), CreateSolid(), deg, fAxis, fC0, fHighRange, fLowRange, fMVTE, fNofDivisions, fStep, fWidth, G3VolTableEntry::GetNpar(), G3VolTableEntry::GetRpar(), G3VolTableEntry::GetShape(), kPhi, and Rpar.

Referenced by UpdateVTE().

Exception()

void G3Division::Exception ( G4String  where, G4String  what  )

private

Definition at line 180 of file G3Division.cc.

{
  G4String err_message = "G3Division::" + where + " for "
                       + what + " is not implemented";
  G4Exception("G3Division::Exception()", "G3toG40004",
              FatalException, err_message);
  return;
}  

References FatalException, and G4Exception().

Referenced by CreateEnvelope(), CreateSolid(), and SetRangeAndAxis().

SetRangeAndAxis()

void G3Division::SetRangeAndAxis ( )

private

Definition at line 189 of file G3Division.cc.

{
    G4String shape = fMVTE->GetShape();
    G4double *Rpar = fMVTE->GetRpar();
    
    switch (fIAxis) {
      case 1: fAxis = kXAxis;
              break;
      case 2: fAxis = kYAxis;
              break;
      case 3: fAxis = kZAxis;
              break;
      default: G4Exception("G3Division::SetRangeAndAxis()", "G3toG40005",
                            FatalException, "Wrong axis index definition!");
    }
 
    if ( shape == "BOX" ) {
      fHighRange = Rpar[fIAxis-1]*cm;
      fLowRange = -fHighRange;
    }
    else if ( shape == "TRD1" ) {
      if (fIAxis == 1){
        fHighRange = std::max(Rpar[0]*cm, Rpar[1]*cm);
      }
      else if( fIAxis == 2) {
       fHighRange = Rpar[2]*cm;
      }
      else if( fIAxis == 3) {
       fHighRange = Rpar[3]*cm;
      }
      fLowRange = - fHighRange;
    }
    else if ( shape == "TRD2" ) {
      if (fIAxis == 1){
        fHighRange = std::max(Rpar[0]*cm, Rpar[1]*cm);
      }
      else if( fIAxis == 2) {
        fHighRange = std::max(Rpar[2]*cm, Rpar[3]*cm);
      }
      else if( fIAxis == 3) {
       fHighRange = Rpar[4]*cm;
      }
    }
    else if ( shape == "TRAP" ) {
      if ( fIAxis == 3 ) fHighRange = Rpar[0]*cm;
      else               fHighRange = 0.;
      fLowRange = -fHighRange;
    }
    else if ( shape == "TUBE" ) {
      if (fIAxis == 1){
        fHighRange = Rpar[1]*cm;
        fLowRange = Rpar[0]*cm;
        fAxis = kRho;
      }
      else if( fIAxis == 2) {
        fHighRange = 360.*deg;
        fLowRange = 0.;
        fAxis = kPhi;
      }
      else if( fIAxis == 3) {
       fHighRange = Rpar[2]*cm;
       fLowRange = -fHighRange;
      }
    }
    else if ( shape == "TUBS" ) {
      if (fIAxis == 1){
        fHighRange = Rpar[1]*cm;
        fLowRange = Rpar[0]*cm;
        fAxis = kRho;
      }
      else if( fIAxis == 2) {
 
       fLowRange = Rpar[3]*deg;
       fHighRange = Rpar[4]*deg - fLowRange;
       if ( Rpar[4]*deg <= fLowRange )fHighRange = fHighRange + 360.*deg;
       fHighRange = fHighRange + fLowRange;
       fAxis = kPhi;
      }
      else if( fIAxis == 3) {
       fHighRange = Rpar[2]*cm;
       fLowRange = -fHighRange;
      }
    }
    else if ( shape == "CONE" ) {
      if (fIAxis == 1){
        fHighRange = std::max(Rpar[2]*cm,Rpar[4]*cm);
        fLowRange = std::max(Rpar[1]*cm,Rpar[3]*cm);
        fAxis = kRho;
      }
      else if( fIAxis == 2) {
 
       fLowRange = 0.;
       fHighRange = 360.*deg;
       fAxis = kPhi;
      }
      else if( fIAxis == 3) {
       fHighRange = Rpar[0]*cm;
       fLowRange = -fHighRange;
      }
    }
    else if ( shape == "CONS" ) {
      if (fIAxis == 1){
        fHighRange = std::max(Rpar[2]*cm,Rpar[4]*cm);
        fLowRange = std::max(Rpar[1]*cm,Rpar[3]*cm);
        fAxis = kRho;
      }
      else if( fIAxis == 2) {
 
       fLowRange = Rpar[5]*deg;
       fHighRange = Rpar[6]*deg - fLowRange;
       if ( Rpar[6]*deg <= fLowRange )fHighRange = fHighRange + 360.*deg;
       fHighRange = fHighRange + fLowRange;
       fAxis = kPhi;
      }
      else if( fIAxis == 3) {
       fHighRange = Rpar[2]*cm;
       fLowRange = -fHighRange;
      }
    }
    else if ( shape == "SPHE" ) {
      if (fIAxis == 1){
        fHighRange = Rpar[1]*cm;
        fLowRange = Rpar[0]*cm;
        fAxis = kRho;
      }
      else if( fIAxis == 2) {
       fLowRange = std::min(Rpar[2]*deg,Rpar[3]*deg);
       fHighRange = std::max(Rpar[2]*deg,Rpar[3]*deg);
       fAxis = kPhi;
      }
      else if( fIAxis == 3) {
       fLowRange = std::min(Rpar[4]*deg,Rpar[5]*deg);
       fHighRange = std::max(Rpar[4]*deg,Rpar[5]*deg);
       fAxis = kPhi; // ?????? 
      }
    }
    else if ( shape == "PARA" ) {
      fHighRange = Rpar[fIAxis-1]*cm;
      fLowRange = -fHighRange;
    }
    else if ( shape == "PGON" ) {
        G4int i;
        G4int nz = G4int(Rpar[3]);
 
        G4double pPhi1 = Rpar[0]*deg;
        G4double dPhi  = Rpar[1]*deg;
    
        G4double *DzArray = new G4double[nz];
        G4double *Rmax    = new G4double[nz];
        G4double *Rmin    = new G4double[nz];
        G4double rangehi[3], rangelo[3];
        rangehi[0] = -kInfinity  ;
        rangelo[0] =  kInfinity ;
        rangehi[2] = -kInfinity ;
        rangelo[2] =  kInfinity ;
 
        for(i=0; i<nz; i++) 
        {
            G4int i4=3*i+4;
            G4int i5=i4+1;
            G4int i6=i4+2;
            
            DzArray[i] = Rpar[i4]*cm;
            Rmin[i] = Rpar[i5]*cm;
            Rmax[i] = Rpar[i6]*cm;
            rangelo[0] = std::min(rangelo[0], Rmin[i]);
            rangehi[0] = std::max(rangehi[0], Rmax[i]);
            rangelo[2] = std::min(rangelo[2], DzArray[i]);
            rangehi[2] = std::max(rangehi[2], DzArray[i]);
        }
        for (i=0;i<nz;i++){
            assert(Rmin[i]>=0 && Rmax[i]>=Rmin[i]);
        }
        rangehi[1] = pPhi1 + dPhi;
        rangelo[1] = pPhi1;
        fHighRange = rangehi[fIAxis-1];
        fLowRange = rangelo[fIAxis-1];
        if      (fIAxis == 1)fAxis = kRho;
        else if (fIAxis == 2)fAxis = kPhi;
        else if (fIAxis == 3)fAxis = kZAxis;
 
        delete [] DzArray;
        delete [] Rmin;
        delete [] Rmax;
 
    }
    else if ( shape == "PCON" ) {
 
        G4int i;
        G4double pPhi1 = Rpar[0]*deg;
        G4double dPhi  = Rpar[1]*deg;    
        G4int nz = G4int(Rpar[2]);
    
        G4double *DzArray = new G4double[nz];
        G4double *Rmax    = new G4double[nz];
        G4double *Rmin    = new G4double[nz];
        G4double rangehi[3],rangelo[3];
 
        rangehi[0] = -kInfinity  ;
        rangelo[0] =  kInfinity ;
        rangehi[2] = -kInfinity ;
        rangelo[2] =  kInfinity ;
        
        for(i=0; i<nz; i++){
            G4int i4=3*i+3;
            G4int i5=i4+1;
            G4int i6=i4+2;
            
            DzArray[i] = Rpar[i4]*cm;
            Rmin[i] = Rpar[i5]*cm;
            Rmax[i] = Rpar[i6]*cm;
            rangelo[0] = std::min(rangelo[0], Rmin[i]);
            rangehi[0] = std::max(rangehi[0], Rmax[i]);
            rangelo[2] = std::min(rangelo[2], DzArray[i]);
            rangehi[2] = std::max(rangehi[2], DzArray[i]);
        }
        for (i=0;i<nz;i++){
            assert(Rmin[i]>=0 && Rmax[i]>=Rmin[i]);
        }
        rangehi[1] = pPhi1 + dPhi;
        rangelo[1] = pPhi1;
        fHighRange = rangehi[fIAxis-1];
        fLowRange = rangelo[fIAxis-1];
        if      (fIAxis == 1)fAxis = kRho;
        else if (fIAxis == 2)fAxis = kPhi;
        else if (fIAxis == 3)fAxis = kZAxis;
 
 
        delete [] DzArray;
        delete [] Rmin;
        delete [] Rmax;
    }
    else if ( shape == "ELTU" ||  shape == "HYPE" || shape == "GTRA" ||
         shape == "CTUB") {
       Exception("SetRangeAndAxis", shape);
    }
    else {
       Exception("SetRangeAndAxis", "Unknown shape" + shape);
    }  
 
    // verbose
    #ifdef G3G4DEBUG
      G4cout << "Shape " << shape << " SetRangeAndAxis: " 
         << fLowRange << " " << fHighRange << " " << fAxis << G4endl;
    #endif
}

References cm, deg, Exception(), FatalException, fAxis, fHighRange, fIAxis, fLowRange, fMVTE, G4cout, G4endl, G4Exception(), G3VolTableEntry::GetRpar(), G3VolTableEntry::GetShape(), kInfinity, kPhi, kRho, kXAxis, kYAxis, kZAxis, G4INCL::Math::max(), G4INCL::Math::min(), and Rpar.

Referenced by UpdateVTE().

UpdateVTE()

void G3Division::UpdateVTE

(

)

Definition at line 96 of file G3Division.cc.

{
  if (fVTE->HasNegPars() && !(fMVTE->HasNegPars())) {
 
    // set nmed from mother 
    if (fNmed == 0) fNmed = fMVTE->GetNmed();
    fVTE->SetNmed(fNmed);
   
    SetRangeAndAxis();
    
    // create envelope (if necessary)
    // and solid    
    G3VolTableEntry* envVTE = 0;
    if      (fType == kDvn)  envVTE = Dvn(); 
    else if (fType == kDvn2) envVTE = Dvn2(); 
    else if (fType == kDvt)  envVTE = Dvt(); 
    else if (fType == kDvt2) envVTE = Dvt2();
    
    if (envVTE) {
      // reset mother <-> daughter
      fMVTE->ReplaceDaughter(fVTE, envVTE);
      fVTE->ReplaceMother(fMVTE, envVTE);
      envVTE->AddDaughter(fVTE);
      envVTE->AddMother(fMVTE);
 
      // replace mother with envelope
      fMVTE = envVTE;
    }
  }  
}

References G3VolTableEntry::AddDaughter(), G3VolTableEntry::AddMother(), Dvn(), Dvn2(), Dvt(), Dvt2(), fMVTE, fNmed, fType, fVTE, G3VolTableEntry::GetNmed(), G3VolTableEntry::HasNegPars(), kDvn, kDvn2, kDvt, kDvt2, G3VolTableEntry::ReplaceDaughter(), G3VolTableEntry::ReplaceMother(), G3VolTableEntry::SetNmed(), and SetRangeAndAxis().

Referenced by G4CloneDaughters(), G4CreateCloneVTEWithDivision(), and G4ProcessDaughters().

Field Documentation

fAxis

EAxis G3Division::fAxis

private

Definition at line 95 of file G3Division.hh.

Referenced by CreatePVReplica(), Dvn2(), Dvt(), Dvt2(), G3Division(), and SetRangeAndAxis().

fC0

G4double G3Division::fC0

private

Definition at line 89 of file G3Division.hh.

Referenced by Dvn2(), Dvt2(), and G3Division().

fHighRange

G4double G3Division::fHighRange

private

Definition at line 92 of file G3Division.hh.

Referenced by Dvn(), Dvn2(), Dvt(), Dvt2(), G3Division(), and SetRangeAndAxis().

fIAxis

G4int G3Division::fIAxis

private

Definition at line 87 of file G3Division.hh.

Referenced by CreateEnvelope(), CreatePVReplica(), CreateSolid(), G3Division(), and SetRangeAndAxis().

fLowRange

G4double G3Division::fLowRange

private

Definition at line 91 of file G3Division.hh.

Referenced by CreatePVReplica(), Dvn(), Dvn2(), Dvt(), Dvt2(), G3Division(), and SetRangeAndAxis().

fMVTE

G3VolTableEntry* G3Division::fMVTE

private

Definition at line 85 of file G3Division.hh.

Referenced by CreateEnvelope(), CreatePVReplica(), Dvn(), Dvn2(), Dvt(), Dvt2(), SetRangeAndAxis(), and UpdateVTE().

fNmed

G4int G3Division::fNmed

private

Definition at line 88 of file G3Division.hh.

Referenced by CreateEnvelope(), G3Division(), and UpdateVTE().

fNofDivisions

G4int G3Division::fNofDivisions

private

Definition at line 86 of file G3Division.hh.

Referenced by CreatePVReplica(), Dvn(), Dvn2(), Dvt(), Dvt2(), and G3Division().

fOffset

G4double G3Division::fOffset

private

Definition at line 94 of file G3Division.hh.

Referenced by CreatePVReplica(), CreateSolid(), and G3Division().

fStep

G4double G3Division::fStep

private

Definition at line 90 of file G3Division.hh.

Referenced by Dvt(), Dvt2(), and G3Division().

fType

G3DivType G3Division::fType

private

Definition at line 83 of file G3Division.hh.

Referenced by G3Division(), and UpdateVTE().

fVTE

G3VolTableEntry* G3Division::fVTE

private

Definition at line 84 of file G3Division.hh.

Referenced by CreateEnvelope(), CreatePVReplica(), CreateSolid(), G3Division(), and UpdateVTE().

fWidth

G4double G3Division::fWidth

private

Definition at line 93 of file G3Division.hh.

Referenced by CreatePVReplica(), CreateSolid(), Dvn(), Dvn2(), Dvt(), Dvt2(), and G3Division().

---

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

• source/g3tog4/include/G3Division.hh
• source/g3tog4/src/G3Division.cc