G4gsposp.cc File Reference

#include "G3G4Interface.hh"
#include "G3toG4.hh"
#include "G3VolTable.hh"
#include "G3toG4MakeSolid.hh"
#include "G3Division.hh"
#include "G4SystemOfUnits.hh"
#include "G4VSolid.hh"

Go to the source code of this file.

Functions
G4bool	G3NegVolPars (G4double pars[], G4int *nparpt, G3VolTableEntry *vte, G3VolTableEntry *mvte, const char routine[])
void	PG4gsposp (G4String *tokens)
void	G4ProcessDaughters (G3VolTableEntry *vte)
void	G4CloneDaughters (G3VolTableEntry *vte, G3VolTableEntry *vteClone)
void	G4CreateCloneVTE (G3VolTableEntry *vte, G3VolTableEntry *mvte, G4double pars[], G4int npar, G4int num, G4double x, G4double y, G4double z, G4int irot, G4String vonly)
void	G4gsposp (G4String vname, G4int num, G4String vmoth, G4double x, G4double y, G4double z, G4int irot, G4String vonly, G4double pars[], G4int npar)

Function Documentation

G4bool G3NegVolPars	(	G4double	pars[],
		G4int *	nparpt,
		G3VolTableEntry *	vte,
		G3VolTableEntry *	mvte,
		const char	routine[]
	)

Definition at line 181 of file G3NegVolPars.cc.

References FALSE, G3CalcParamsFn(), G3VolTableEntry::GetNpar(), G3VolTableEntry::GetRpar(), G3VolTableEntry::GetShape(), and TRUE.

Referenced by G4CreateCloneVTE(), and G4ProcessDaughters().

{
  G4bool NegPresent = FALSE;

  // retrieve parameters 

  // the volume
  G4String shape = vte->GetShape();
  G4double* rpar = vte->GetRpar();
  G4int npar = vte->GetNpar();  
  if (npar ==0) {
    // no solid parameters are defined in vte
    npar = *nparpt;
    rpar = pars;
  }
  else {  
    // solid parameters are already defined in vte
    // pars[], nparpt are ignored
    // TO DO: check if g3 ignores them too or resets
    // vte parameters according to this new ones !!
  }  
      
  // mother
  G4String shapem = mvte->GetShape();
  G4double* rparm = mvte->GetRpar();

  if (strcmp(routine,"GSPOS") == 0 || strcmp(routine,"GSVOLU") == 0) {
    NegPresent = G3CalcParamsFn(rpar,npar,rparm,shape,shapem);
  }
  if (strcmp(routine,"GSDVN") == 0) {
    // just set the flag. The parametrization function figures out
    // what to do.
    for (G4int i=0;i<npar;i++) {
      if (rpar[i] < 0) {
        NegPresent = TRUE;
      }
    }
  }
  return NegPresent;
}

void G4CloneDaughters	(	G3VolTableEntry *	vte,
		G3VolTableEntry *	vteClone
	)

Definition at line 127 of file G4gsposp.cc.

References G3VolTableEntry::AddClone(), G3VolTableEntry::AddDaughter(), G3VolTableEntry::AddG3Pos(), G3VolTableEntry::AddMother(), G4String::append(), G3Vol, G3VolTableEntry::GetDaughter(), G3VolTableEntry::GetDivision(), G3VolTableEntry::GetG3PosCopy(), G3VolTableEntry::GetMasterClone(), G3VolTableEntry::GetName(), G3VolTableEntry::GetNmed(), G3VolTableEntry::GetNoClones(), G3VolTableEntry::GetNoDaughters(), G3VolTableEntry::GetNpar(), G3VolTableEntry::GetRpar(), G3VolTableEntry::GetShape(), gSeparator, G3VolTableEntry::HasNegPars(), G3VolTableEntry::NPCopies(), G3VolTable::PutVTE(), G3VolTableEntry::SetDivision(), and G3Division::UpdateVTE().

Referenced by G4CreateCloneVTE().

{
  G4int nofDaughters = vte->GetNoDaughters();
  if (nofDaughters>0)
    for (G4int id=0; id<nofDaughters; id++) {     
      G3VolTableEntry* dvte = vte->GetDaughter(id);

      if (dvte->HasNegPars() || dvte->GetDivision()){
        // create new dvteClone with Position/Division
    // and set it to vteClone       

        // get master of dvte
        G3VolTableEntry* dvteMaster = dvte->GetMasterClone();

        // generate vteClone name
        G4int cloneNo = dvteMaster->GetNoClones();
        char index[5]; sprintf(index,"%d",cloneNo);
        G4String newName = dvteMaster->GetName();
        newName.append(gSeparator); newName = newName + index;
        
        // create dvteClone
        G4String  dvteShape = dvte->GetShape();
    G4double* dvteRpar  = dvte->GetRpar();
    G4int     dvteNpar  = dvte->GetNpar();
    G4int     dvteNmed  = dvte->GetNmed();
    G4bool   hasNegPars = dvte->HasNegPars();
        G3VolTableEntry* dvteClone
          = new G3VolTableEntry(newName, dvteShape, dvteRpar, dvteNpar,
                             dvteNmed, 0, hasNegPars);
                 
        // let dvte master and vol table know about it
        G3Vol.PutVTE(dvteClone);
        dvteMaster->AddClone(dvteClone);

        // set mother daughter
        vteClone->AddDaughter(dvteClone);
        dvteClone->AddMother(vteClone);
    
        // copy positions
        G4int nofPositions = dvte->NPCopies();
    for (G4int ip=0; ip<nofPositions; ip++)
      dvteClone->AddG3Pos(dvte->GetG3PosCopy(ip));
      
        // copy division
    G3Division* dvteDivision = dvte->GetDivision();
    if (dvteDivision) {          
      G3Division* dvteCloneDivision
        = new G3Division(dvteClone, vteClone, *dvteDivision);
          dvteClone->SetDivision(dvteCloneDivision);
          dvteCloneDivision->UpdateVTE();
    }  
                                
    // clone daughters recursively
    G4CloneDaughters(dvte, dvteClone);
      } 
      else {     
        // set dvte to vteClone
        vteClone->AddDaughter(dvte);
        dvte->AddMother(vteClone);
      } 
    }
}

void G4CreateCloneVTE	(	G3VolTableEntry *	vte,
		G3VolTableEntry *	mvte,
		G4double	pars[],
		G4int	npar,
		G4int	num,
		G4double	x,
		G4double	y,
		G4double	z,
		G4int	irot,
		G4String	vonly
	)

Definition at line 193 of file G4gsposp.cc.

References G3VolTableEntry::AddClone(), G3VolTableEntry::AddDaughter(), G3VolTableEntry::AddG3Pos(), G3VolTableEntry::AddMother(), G4String::append(), python.hepunit::cm, G3NegVolPars(), G3toG4MakeSolid(), G3Vol, G4CloneDaughters(), G4ProcessDaughters(), G3VolTableEntry::GetClone(), G3VolTableEntry::GetName(), G3VolTableEntry::GetNmed(), G3VolTableEntry::GetNoClones(), G3VolTableEntry::GetNpar(), G3VolTableEntry::GetRpar(), G3VolTableEntry::GetShape(), gSeparator, G3VolTable::PutVTE(), G3VolTableEntry::SetHasNegPars(), G3VolTableEntry::SetName(), and G3VolTableEntry::SetSolid().

Referenced by G4gspos(), and G4gsposp().

{
   // create a G3Pos
   G4ThreeVector* offset = new G4ThreeVector(x*cm, y*cm, z*cm);
   G3Pos* aG3Pos = new G3Pos(mvte->GetName(), num, offset, irot, vonly);
            
   // loop over all mothers
   for (G4int i=0; i<mvte->GetNoClones(); i++) {
                    // mvte was retrieved from its "master" name
                    // -> there is no need to call GetMasterClone()
      G3VolTableEntry* mvteClone = mvte->GetClone(i);
        
      G4String tmpName = "TRY";
      G4String vteShape = vte->GetShape();
      G3VolTableEntry* vteClone
        = new G3VolTableEntry(tmpName, vteShape, pars, npar, vte->GetNmed(),
                               0, true);
          
      // negative parameters will be updated only 
      // for vteClone, pars are unchanged
      G4double* clonePars = vteClone->GetRpar();
      G4int     cloneNpar = vteClone->GetNpar();
      G4bool negpars
        = G3NegVolPars(clonePars, &cloneNpar, vteClone, mvteClone, "GSPOS");
      vteClone->SetHasNegPars(negpars);

      G3VolTableEntry* vteSameClone = 0;
      G4VSolid* solid = 0;
      if (!negpars) {
        // check if vteClone with the same parameters exist
        for (G4int ic=0; ic<vte->GetNoClones(); ic++) {
          G3VolTableEntry* checkClone = vte->GetClone(ic);
      G4int checkNpar = checkClone->GetNpar();
      G4double* checkPars = checkClone->GetRpar();
      
          G4bool isSame;
          if (checkNpar != cloneNpar) 
        isSame = false;
      else {  
        isSame = true;
        for (G4int ip=0; ip<cloneNpar; ip++) 
          if (checkPars[ip] != clonePars[ip]) {
            isSame = false;
        break;  
          }
      } 
      if (isSame) { vteSameClone = checkClone; break; }
        }
       
        if (vteSameClone) {
          delete vteClone;
      
          // add aG3Pos to the vteClone  
          vteSameClone->AddG3Pos(aG3Pos);
          mvteClone->AddDaughter(vteSameClone);  
          vteSameClone->AddMother(mvteClone);
        }
    else {
          // create the solid
          G4bool hasNegPars;
          G4bool deferred;
          G4bool okAxis[3];
          G4String vteName = vte->GetName();
          G4String cloneShape = vteClone->GetShape();
          solid = G3toG4MakeSolid(vteName, cloneShape, clonePars, cloneNpar,
                                  hasNegPars, deferred, okAxis);
        }                 
      }
   
      if ( negpars || !(vteSameClone)) {
        // generate vteClone name     
        G4int cloneNo = vte->GetNoClones();
        char index[5]; sprintf(index,"%d",cloneNo);
        G4String newName = vte->GetName();
        newName.append(gSeparator); newName = newName + index;
        
        // update vteClone
        vteClone->SetName(newName);
        vteClone->SetSolid(solid);
        vteClone->SetHasNegPars(negpars);
                                
        // let vte and vol table know about it
        G3Vol.PutVTE(vteClone);
        vte->AddClone(vteClone);
          
        // add aG3Pos to the vteClone  
        vteClone->AddG3Pos(aG3Pos);
        mvteClone->AddDaughter(vteClone);
        vteClone->AddMother(mvteClone);
           
        // copy all daughters
        G4CloneDaughters(vte, vteClone);

        // retrieve daughters parameters
        if (!negpars) G4ProcessDaughters(vteClone);
      }
  }
}

void G4gsposp	(	G4String	vname,
		G4int	num,
		G4String	vmoth,
		G4double	x,
		G4double	y,
		G4double	z,
		G4int	irot,
		G4String	vonly,
		G4double	pars[],
		G4int	npar
	)

Definition at line 297 of file G4gsposp.cc.

References FatalException, G3Vol, G4CreateCloneVTE(), G4Exception(), and G3VolTable::GetVTE().

Referenced by PG4gsposp().

{
  // find VTEs
  G3VolTableEntry* vte = G3Vol.GetVTE(vname);
  G3VolTableEntry* mvte = G3Vol.GetVTE(vmoth);

  if (vte == 0) {
    G4String err_message1 = "G4gsposp: '" + vname + "' has no VolTableEntry";
    G4Exception("G4psposp()", "G3toG40021", FatalException, err_message1);
    return;
  } 
  if (mvte == 0) {
    G4String err_message2 = "G4gsposp: '" + vmoth + "' has no VolTableEntry";
    G4Exception("G4psposp()", "G3toG40022", FatalException, err_message2);
    return;
  } 
  else { 
    // a new vte clone copy is created for each mother (clone copy)  
    // and its parameters are derived from it if possible
    
    G4CreateCloneVTE(vte, mvte, pars, npar, num, x, y, z, irot, vonly);
  }
}

void G4ProcessDaughters

(

G3VolTableEntry *

vte

)

Definition at line 66 of file G4gsposp.cc.

References FatalException, G3NegVolPars(), G3toG4MakeSolid(), G4cerr, G4endl, G4Exception(), G3VolTableEntry::GetDaughter(), G3VolTableEntry::GetDivision(), G3VolTableEntry::GetName(), G3VolTableEntry::GetNoDaughters(), G3VolTableEntry::GetNpar(), G3VolTableEntry::GetRpar(), G3VolTableEntry::GetShape(), G3VolTableEntry::HasNegPars(), G3VolTableEntry::SetHasNegPars(), G3VolTableEntry::SetNRpar(), G3VolTableEntry::SetSolid(), and G3Division::UpdateVTE().

Referenced by G4CreateCloneVTE().

{
  if (vte->HasNegPars()) {
    G4cerr << " Warning:" << G4endl;
    G4cerr << " G4ProcessDaughters: Ignored (vte has negative parameters)." 
           << G4endl;
  }  
  else {  
    for (G4int i=0; i<vte->GetNoDaughters(); i++) {
   
      G3VolTableEntry* dvte = vte->GetDaughter(i);

      if (dvte->HasNegPars()) {
        if (dvte->GetDivision()) {
           // call division method for creating solid and updating
           // dvte parameters
           dvte->GetDivision()->UpdateVTE();
        }
        else {
          // update negative parameters
          G4double* pars = dvte->GetRpar();
          G4int     npar = dvte->GetNpar();
          G4bool negpars 
        = G3NegVolPars(pars,&npar, dvte, vte, "GSPOS");

          if (negpars) {
            G4String text = "G3NegVolPars still returns negative parameters!";
            G4Exception("G4ProcessDaughters()", "G3toG40019",
                        FatalException, text);
            return;
      }  

          // create solid
          G4bool hasNegPars;
          G4bool deferred;   
          G4bool okAxis[3];
          G4VSolid* solid
            = G3toG4MakeSolid(dvte->GetName(), dvte->GetShape(), pars, npar, 
                          hasNegPars, deferred, okAxis);  
          if (hasNegPars) {
            G4String text = "G3toG4MakeSolid still returns negative parameters!";
            G4Exception("G4ProcessDaughters()", "G3toG40020",
                        FatalException, text);
            return;
      }  

          // update dvte              
          dvte->SetNRpar(npar, pars);
          dvte->SetSolid(solid);
          dvte->SetHasNegPars(hasNegPars);
        }

        // process daughters
    G4ProcessDaughters(dvte);  
      }     
    }
  }     
}

void PG4gsposp

(

G4String *

tokens

)

Definition at line 42 of file G4gsposp.cc.

References G3fillParams(), G4gsposp(), Ipar, PTgsposp, Rpar, Spar, test::x, and z.

Referenced by G3CLEval().

                                {
  // fill the parameter containers
  G3fillParams(tokens,PTgsposp);
  
  // interpret the parameters
  G4String name = Spar[0];
  G4String moth = Spar[1];
  G4String only = Spar[2];
  G4int num = Ipar[0];
  G4int irot = Ipar[1];
  G4int npar = Ipar[2];
  // all parameters are passed to G4gsxxx methods
  // in G3 default units         
  //G4double x = Rpar[0]*cm;
  //G4double y = Rpar[1]*cm;
  //G4double z = Rpar[2]*cm;
  G4double x = Rpar[0];
  G4double y = Rpar[1];
  G4double z = Rpar[2];
  G4double *pars = &Rpar[3];
  
  G4gsposp(name, num, moth, x, y, z, irot, only, pars, npar);
}