G3Volume Class Reference

#include <G3Volume.h>

Inheritance diagram for G3Volume:

Public Member Functions
	G3Volume ()
	G3Volume (const char *name)
virtual	~G3Volume ()
virtual void	Draw (Option_t *option=0)
virtual void	DrawSpec ()
virtual void	SetParam (Int_t i, Float_t param)
virtual Float_t	GetParam (Int_t i)
virtual void	SetIdVolume (Int_t id)
virtual void	SetIdCopy (Int_t id)
virtual void	SetIdMedium (Int_t id)
virtual void	SetIdMaterial (Int_t id)
virtual Int_t	GetIdVolume () const
virtual Int_t	GetIdCopy () const
virtual Int_t	Medium () const
virtual Int_t	Material () const
virtual void	AddCopy ()
virtual void	SetItem (TObject *item)
virtual void	SetPosition (Float_t x, Float_t y, Float_t z)
virtual TArrayF	Position (Int_t i) const
virtual void	SetRotMatrix (Int_t irot)
virtual Int_t	RotMatrix () const
virtual void	SetShape (Int_t shape)
virtual Int_t	Shape () const
virtual void	SetParameters (Int_t np, Float_t *param)
virtual Int_t	NParam () const
virtual void	Parameters (Int_t i, TArrayF &param) const
virtual TList *	Copies () const
virtual void	AddCopy (G3Volume *volume)
virtual G3Volume *	MakeCopy (Int_t i)
virtual Int_t	NCopies () const
virtual Bool_t	Posp () const
virtual void	SetPosp (Bool_t flag)
virtual void	CreateTShape (char *nameV, TMaterial *mat)
virtual void	SetDivision (Int_t ndiv, Int_t axis, Float_t start, Float_t step)
virtual void	Division (Int_t &ndiv, Int_t &axis, Float_t &start, Float_t &step) const
virtual Int_t	Axis ()
virtual Int_t	Ndiv ()
virtual Float_t	Step ()
virtual Float_t	StartC ()
virtual TObject *	GetItem ()
	G3Volume (const G3Volume &)

Private Member Functions
G3Volume &	operator= (const G3Volume &)
	current item More...

Private Attributes
TArrayF	fPosition
TArrayF	fParameters
TList *	fCopies
Bool_t	fPosp
Int_t	fNCopies
Int_t	fRotMatrix
Int_t	fNParam
Int_t	fAxis
Int_t	fNdiv
Float_t	fStep
Float_t	fStartC
Int_t	fShape
Float_t	fTheta
Float_t	fPhi
Float_t	fPsi
Float_t	fU
Float_t	fV
Float_t	fUscale
Float_t	fVscale
Bool_t	fHide
Bool_t	fShadow
Int_t	fFill
Int_t	fSeen
Bool_t	fClip
Float_t	fClipXmin
Float_t	fClipXmax
Float_t	fClipYmin
Float_t	fClipYmax
Float_t	fClipZmin
Float_t	fClipZmax
Int_t	fIdVolume
Int_t	fIdMedium
Int_t	fIdMaterial
Int_t	fIdCopy
TObject *	fItem

Detailed Description

Definition at line 18 of file G3Volume.h.

Constructor & Destructor Documentation

G3Volume::G3Volume ( )

inline

Definition at line 21 of file G3Volume.h.

{;}

G3Volume::G3Volume

(

const char *

name

)

virtual G3Volume::~G3Volume ( )

inlinevirtual

Definition at line 23 of file G3Volume.h.

{;}

G3Volume::G3Volume

(

const G3Volume &

volume

)

Definition at line 94 of file G3Volume.cxx.

    : TNamed(volume)
{
// Constructor

    fTheta  = 30;
    fPhi    = 30;
    fPsi    = 0;
    fU      = 10;
    fV      = 10;
    fUscale = 0.01;
    fVscale = 0.01;
    fHide=0;
    fShadow=0;
    fFill=1;
    fSeen=1;
    fClip=0;
    fClipXmin=0.;
    fClipXmax=2000.;
    fClipYmin=0.;
    fClipYmax=2000.;
    fClipZmin=0.;
    fClipZmax=2000.;
    fAxis = -1;
//
    fIdVolume   = volume.GetIdVolume();
    fIdCopy     = volume.GetIdCopy();
    fIdMedium   = volume.Medium();
    fIdMaterial = volume.Material();
    fPosition   = volume.Position(0);
    fShape      = volume.Shape();
    fRotMatrix  = volume.RotMatrix();
    TArrayF par;
    volume.Parameters(0, fParameters);
    fNCopies    = volume.NCopies();
    fPosp       = volume.Posp();
    
    fNParam     = volume.NParam();
    fCopies     = volume.Copies();
    fRotMatrix  = volume.RotMatrix();
    volume.Division(fNdiv, fAxis, fStartC, fStep);
    
}

Member Function Documentation

virtual void G3Volume::AddCopy ( )

inlinevirtual

Definition at line 49 of file G3Volume.h.

{fIdCopy ++;}

void G3Volume::AddCopy ( G3Volume *  volume )

virtual

Definition at line 307 of file G3Volume.cxx.

{
    volume->SetIdMaterial(Material());
    fCopies->Add(volume);
    fNCopies++;
}

virtual Int_t G3Volume::Axis ( )

inlinevirtual

Definition at line 73 of file G3Volume.h.

{return fAxis;}

virtual TList* G3Volume::Copies ( ) const

inlinevirtual

Definition at line 63 of file G3Volume.h.

{return fCopies;}

void G3Volume::CreateTShape ( char *  nameV, TMaterial *  mat  )

virtual

Definition at line 373 of file G3Volume.cxx.

{
//
// Create a root volume from G3 volume
//
    Int_t   ip;
    
    Float_t kRadDeg = 180./TMath::Pi();
    Float_t theta, phi, alpha1, alpha2;
    Float_t p1, p2;
    
    TShape* nShape=0;
    const char* tmp = mat->GetName();
    char nameM[21];
    strncpy(nameM, tmp, 20);
    nameM[20]='\0';
    switch(fShape)
    {
    case 1:
// BOX
        nShape = new TBRIK(nameV,"BRIK",nameM,fParameters[0], fParameters[1], fParameters[2]);
        break;
        
    case 2:
// TRD1   
        nShape = new TTRD1(nameV, "TRD1", nameM, fParameters[0], fParameters[1], fParameters[2],
                           fParameters[3]);
        break;
        
    case 3:
// TRD2
        nShape = new TTRD2(nameV, "TRD2", nameM, fParameters[0], fParameters[1], fParameters[2], 
                           fParameters[3], fParameters[4]);
        break;
        
    case 4:
// TRAP
        p1     = fParameters[1];
        p2     = fParameters[2];
        
        theta  = TMath::ATan(TMath::Sqrt(p1*p1+p2*p2))*kRadDeg;
        phi    = TMath::ATan2(p2,p1)*kRadDeg;
        alpha1 = fParameters[6 ]*kRadDeg;
        alpha2 = fParameters[10]*kRadDeg;

        if (theta < 0.) theta+=180.;
        
        nShape =  new TTRAP(nameV, "TRAP", nameM, fParameters[0], 
                            theta, phi,
                            fParameters[3], fParameters[4], fParameters[5], 
                            alpha1, 
                            fParameters[7], fParameters[8], fParameters[9], 
                            alpha2);
        break;
        
    case 5:
// TUBE
        nShape =  new TTUBE(nameV,"TUBE",nameM,fParameters[0], fParameters[1], fParameters[2]);
        break;
        
    case 6:
// TUBS
        nShape =  new TTUBS(nameV,"TUBS",nameM,fParameters[0], fParameters[1], fParameters[2], 
                            fParameters[3], fParameters[4]);
        break;
        
    case 7:
// CONE
        nShape =  new TCONE(nameV, "CONE", nameM, fParameters[0], fParameters[1], fParameters[2], 
                            fParameters[3], fParameters[4]);
        break;
        
    case 8:
        
// CONS
        nShape =  new TCONS(nameV, "CONS", nameM, fParameters[0], fParameters[1], fParameters[2], 
                            fParameters[3], fParameters[4], fParameters[5], fParameters[6]);
        break;
        
    case 9:
// SPHE
        
        nShape =  new TSPHE(nameV, "SPHE", nameM, fParameters[0], fParameters[1], fParameters[2], 
                            fParameters[3], fParameters[4], fParameters[5]);
        break;
        
    case 10:
// PARA
        alpha1 = fParameters[3]*kRadDeg;
        p1     = fParameters[4];
        p2     = fParameters[5];
        theta  = TMath::ATan(TMath::Sqrt(p1*p1+p2*p2))*kRadDeg;
        phi    = TMath::ATan2(p2,p1)*kRadDeg;

        nShape =  new TPARA(nameV, "PARA", nameM, fParameters[0], fParameters[1], fParameters[2], 
                                    alpha1, theta, phi);
        break;
        
    case 11:
// PGON
        nShape =  new TPGON(nameV, "PGON", nameM, fParameters[0], fParameters[1], Int_t(fParameters[2]), 
                            Int_t(fParameters[3]));
        for (ip=0; ip<Int_t(fParameters[3]); ip++) {
            ((TPGON*) nShape)->DefineSection(ip, fParameters[4+3*ip], fParameters[4+3*ip+1], 
                                             fParameters[4+3*ip+2]);
        }
        break;
        
    case 12:
// PCON
        nShape = new TPCON(nameV, "PCON", nameM, fParameters[0], fParameters[1], Int_t(fParameters[2]));
        for (ip=0; ip<Int_t(fParameters[2]); ip++) {
            ((TPCON*) nShape)->DefineSection(ip, fParameters[3+3*ip], fParameters[3+3*ip+1], 
                                             fParameters[3+3*ip+2]);
        }
        break;
        
    case 13:
// ELTU  
        nShape = new TELTU(nameV,"ELTU",nameM,fParameters[0], fParameters[1], fParameters[2]);
        break;
        
    case 14:
// HYPE
        nShape = new THYPE(nameV,"HYPE",nameM,fParameters[0], fParameters[1], fParameters[2], 
                           fParameters[3]);
        break;
        
    case 15:
// GTRA
        nShape = new TGTRA(nameV, "GTRA", nameM, fParameters[0], fParameters[1], fParameters[2], 
                           fParameters[3], fParameters[4], fParameters[5], fParameters[6], 
                           fParameters[7], fParameters[8], fParameters[9], fParameters[10], 
                           fParameters[11]);
        break;
        
    case 16:
// CTUB
        nShape = new TCTUB(nameV, "CTUB", nameM, fParameters[0], fParameters[1], fParameters[2], 
                           fParameters[3], fParameters[4], fParameters[5], fParameters[6], 
                           fParameters[7], fParameters[8], fParameters[9], fParameters[10]);
        break;
    default:
        break;
    }
    if (nShape) {
        Float_t density = mat->GetDensity();
        if (density < 0.01) {
            nShape->SetVisibility(0);
        } else {
            nShape->SetVisibility(1);
        }
        
        Int_t color = Int_t(density/20.*100.);
        nShape->SetLineColor(color);
    }
}

void G3Volume::Division ( Int_t &  ndiv, Int_t &  axis, Float_t &  start, Float_t &  step  ) const

virtual

Definition at line 539 of file G3Volume.cxx.

{
    ndiv  = fNdiv;
    axis  = fAxis;
    start = fStartC;
    step  = fStep;
}

void G3Volume::Draw ( Option_t *  option = 0 )

virtual

Definition at line 141 of file G3Volume.cxx.

{
// Wraps the geant Gdraw
    gMC->Gsatt(fName,"seen", fSeen);
    
    if (fHide) {
        gMC->Gdopt("hide", "on");
    } else {
        gMC->Gdopt("hide", "off");
    }

    if (fShadow) {
        gMC->Gdopt("shad", "on");
        gMC->Gsatt("*", "fill", fFill);
    } else {
        gMC->Gdopt("shad", "off");
    }

        gMC->SetClipBox(".");
    if (fClip) {
        gMC->SetClipBox("*", fClipXmin, fClipXmax, 
                        fClipYmin, fClipYmax, fClipZmin, fClipZmax);
    } else {
        gMC->SetClipBox(".");
    }
    

    gMC->Gdraw(fName, fTheta, fPhi, fPsi, fU, fV, fUscale, fVscale);
}

void G3Volume::DrawSpec ( )

virtual

Definition at line 171 of file G3Volume.cxx.

{
// Wraps the Geant DrawSpec
    gMC->Gsatt(fName,"seen", fSeen);
    
    if (fHide) {
        gMC->Gdopt("hide", "on");
    } else {
        gMC->Gdopt("hide", "off");
    }

    if (fShadow) {
        gMC->Gdopt("shad", "on");
        gMC->Gsatt("*", "fill", fFill);
    } else {
        gMC->Gdopt("shad", "off");
    }

    gMC->SetClipBox(".");
    if (fClip) {
        gMC->SetClipBox("*", fClipXmin, fClipXmax, fClipYmin, fClipYmax, fClipZmin, fClipZmax);
    } else {
        gMC->SetClipBox(".");
    }
    

    ((TGeant3*) gMC)->DrawOneSpec(fName);
}

virtual Int_t G3Volume::GetIdCopy ( ) const

inlinevirtual

Definition at line 43 of file G3Volume.h.

{return fIdCopy;}

virtual Int_t G3Volume::GetIdVolume ( ) const

inlinevirtual

Definition at line 41 of file G3Volume.h.

{return fIdVolume;}

virtual TObject* G3Volume::GetItem ( )

inlinevirtual

Definition at line 80 of file G3Volume.h.

{return fItem;}

Float_t G3Volume::GetParam ( Int_t  i )

virtual

Definition at line 261 of file G3Volume.cxx.

{
// Get drawing parameters
    switch (ip) {
    case kTheta:
        return fTheta;
    case kPhi:
        return fPhi;
    case kPsi:
        return fPsi;
    case kU:
        return fU;
    case kV:
        return fV;
    case kUscale:
        return fUscale;
    case kVscale:
        return fVscale;
    case kHide:
        return Float_t(fHide);
    case kShadow:
        return Float_t(fShadow);
    case kFill:
        return Float_t(fFill);
    case kSeen:
        return Float_t(fSeen);
    case kClip:
        return Float_t(fClip);
    case kClipXmin:
        return fClipXmin;
    case kClipXmax:
        return fClipXmax;
    case kClipYmin:
        return fClipYmin;
    case kClipYmax:
        return fClipYmax;
    case kClipZmin:
        return fClipZmin;
    case kClipZmax:
        return fClipZmax;
    default:
        return 0.;
    }
    return 0.;
}

G3Volume * G3Volume::MakeCopy ( Int_t  i )

virtual

Definition at line 314 of file G3Volume.cxx.

{
    return (G3Volume*) fCopies->At(i);
}

virtual Int_t G3Volume::Material ( ) const

inlinevirtual

Definition at line 47 of file G3Volume.h.

{return fIdMaterial;}

virtual Int_t G3Volume::Medium ( ) const

inlinevirtual

Definition at line 45 of file G3Volume.h.

{return fIdMedium;}

virtual Int_t G3Volume::NCopies ( ) const

inlinevirtual

Definition at line 67 of file G3Volume.h.

{return fNCopies;}

virtual Int_t G3Volume::Ndiv ( )

inlinevirtual

Definition at line 74 of file G3Volume.h.

{return fNdiv;}

virtual Int_t G3Volume::NParam ( ) const

inlinevirtual

Definition at line 61 of file G3Volume.h.

{return fNParam;}

G3Volume& G3Volume::operator= ( const G3Volume &  )

inlineprivate

current item

Definition at line 122 of file G3Volume.h.

{return *this;}

void G3Volume::Parameters ( Int_t  i, TArrayF &  param  ) const

virtual

Definition at line 354 of file G3Volume.cxx.

{
//
// Get parameters for volume copy i 
//
    TArrayF p;
    if (i==0) {
        p = fParameters;
    } else {
        ((G3Volume*) (fCopies->At(i-1)))->Parameters(0, p);
    }
    Int_t np = fNParam;
    param.Set(np);
    for (Int_t j=0; j<np; j++) {
        param[j] = p.At(j);
    }
}

TArrayF G3Volume::Position ( Int_t  i ) const

virtual

Definition at line 320 of file G3Volume.cxx.

{
//
// Get position for volume copy i 
//
    if (i==0) {
        return fPosition;
    } else {
        return ((G3Volume*) fCopies->At(i-1))->Position(0);
    }
}

virtual Bool_t G3Volume::Posp ( ) const

inlinevirtual

Definition at line 68 of file G3Volume.h.

{return fPosp;}

virtual Int_t G3Volume::RotMatrix ( ) const

inlinevirtual

Definition at line 57 of file G3Volume.h.

{return fRotMatrix;}

void G3Volume::SetDivision ( Int_t  ndiv, Int_t  axis, Float_t  start, Float_t  step  )

virtual

Definition at line 531 of file G3Volume.cxx.

{
    fNdiv   = ndiv;
    fAxis   = axis;
    fStartC = start;
    fStep   = step;
}

virtual void G3Volume::SetIdCopy ( Int_t  id )

inlinevirtual

Definition at line 35 of file G3Volume.h.

{fIdCopy = id;}

virtual void G3Volume::SetIdMaterial ( Int_t  id )

inlinevirtual

Definition at line 39 of file G3Volume.h.

{fIdMaterial = id;}

virtual void G3Volume::SetIdMedium ( Int_t  id )

inlinevirtual

Definition at line 37 of file G3Volume.h.

{fIdMedium = id;}

virtual void G3Volume::SetIdVolume ( Int_t  id )

inlinevirtual

Definition at line 33 of file G3Volume.h.

{fIdVolume = id;}

virtual void G3Volume::SetItem ( TObject *  item )

inlinevirtual

Definition at line 51 of file G3Volume.h.

{fItem = item;}

void G3Volume::SetParam ( Int_t  i, Float_t  param  )

virtual

Definition at line 200 of file G3Volume.cxx.

{
// Set drawing parameters
    switch (ip) {
    case kTheta:
        fTheta=param;
        break;
    case kPhi:
        fPhi=param;
        break;
    case kPsi:
        fPsi=param;
        break;
    case kU:
        fU=param;
        break;
    case kV:
        fV=param;
        break;
    case kUscale:
        fUscale=param;
        break;
    case kVscale:
        fVscale=param;
        break;
    case kHide:
        fHide=Int_t(param);
        break;
    case kShadow:
        fShadow=Int_t(param);
        break;
    case kFill:
        fFill=Int_t(param);
        break;
    case kSeen:
        fSeen=Int_t(param);
        break;
    case kClip:
        fClip=Int_t(param);
        break;
    case kClipXmin:
        fClipXmin=param;
        break;
    case kClipXmax:
        fClipXmax=param;
        break;
    case kClipYmin:
        fClipYmin=param;
        break;
    case kClipYmax:
        fClipYmax=param;
        break;
    case kClipZmin:
        fClipZmin=param;
        break;
    case kClipZmax:
        fClipZmax=param;
        break;
    }
}

void G3Volume::SetParameters ( Int_t  np, Float_t *  param  )

virtual

Definition at line 343 of file G3Volume.cxx.

{
//
// Set parameters 
//
    fParameters.Set(np);
    for (Int_t j=0; j<np; j++) fParameters[j]=param[j];
    fNParam = np;
}

void G3Volume::SetPosition ( Float_t  x, Float_t  y, Float_t  z  )

virtual

Definition at line 332 of file G3Volume.cxx.

{
//
// Set position
//
  fPosition[0] = x;
  fPosition[1] = y;
  fPosition[2] = z;
}

virtual void G3Volume::SetPosp ( Bool_t  flag )

inlinevirtual

Definition at line 69 of file G3Volume.h.

{fPosp = flag;}

virtual void G3Volume::SetRotMatrix ( Int_t  irot )

inlinevirtual

Definition at line 56 of file G3Volume.h.

{fRotMatrix = irot;}

virtual void G3Volume::SetShape ( Int_t  shape )

inlinevirtual

Definition at line 58 of file G3Volume.h.

{fShape = shape;}

virtual Int_t G3Volume::Shape ( ) const

inlinevirtual

Definition at line 59 of file G3Volume.h.

{return fShape;}

virtual Float_t G3Volume::StartC ( )

inlinevirtual

Definition at line 76 of file G3Volume.h.

{return fStartC;}

virtual Float_t G3Volume::Step ( void  )

inlinevirtual

Definition at line 75 of file G3Volume.h.

{return fStep;}

Member Data Documentation

Int_t G3Volume::fAxis

private

Definition at line 94 of file G3Volume.h.

Bool_t G3Volume::fClip

private

Definition at line 110 of file G3Volume.h.

Float_t G3Volume::fClipXmax

private

Definition at line 112 of file G3Volume.h.

Float_t G3Volume::fClipXmin

private

Definition at line 111 of file G3Volume.h.

Float_t G3Volume::fClipYmax

private

Definition at line 114 of file G3Volume.h.

Float_t G3Volume::fClipYmin

private

Definition at line 113 of file G3Volume.h.

Float_t G3Volume::fClipZmax

private

Definition at line 116 of file G3Volume.h.

Float_t G3Volume::fClipZmin

private

Definition at line 115 of file G3Volume.h.

TList* G3Volume::fCopies

private

Definition at line 89 of file G3Volume.h.

Int_t G3Volume::fFill

private

Definition at line 108 of file G3Volume.h.

Bool_t G3Volume::fHide

private

Definition at line 106 of file G3Volume.h.

Int_t G3Volume::fIdCopy

private

Definition at line 120 of file G3Volume.h.

Int_t G3Volume::fIdMaterial

private

Definition at line 119 of file G3Volume.h.

Int_t G3Volume::fIdMedium

private

Definition at line 118 of file G3Volume.h.

Int_t G3Volume::fIdVolume

private

Definition at line 117 of file G3Volume.h.

TObject* G3Volume::fItem

private

Definition at line 121 of file G3Volume.h.

Int_t G3Volume::fNCopies

private

Definition at line 91 of file G3Volume.h.

Int_t G3Volume::fNdiv

private

Definition at line 95 of file G3Volume.h.

Int_t G3Volume::fNParam

private

Definition at line 93 of file G3Volume.h.

TArrayF G3Volume::fParameters

private

Definition at line 88 of file G3Volume.h.

Float_t G3Volume::fPhi

private

Definition at line 100 of file G3Volume.h.

TArrayF G3Volume::fPosition

private

Definition at line 87 of file G3Volume.h.

Bool_t G3Volume::fPosp

private

Definition at line 90 of file G3Volume.h.

Float_t G3Volume::fPsi

private

Definition at line 101 of file G3Volume.h.

Int_t G3Volume::fRotMatrix

private

Definition at line 92 of file G3Volume.h.

Int_t G3Volume::fSeen

private

Definition at line 109 of file G3Volume.h.

Bool_t G3Volume::fShadow

private

Definition at line 107 of file G3Volume.h.

Int_t G3Volume::fShape

private

Definition at line 98 of file G3Volume.h.

Float_t G3Volume::fStartC

private

Definition at line 97 of file G3Volume.h.

Float_t G3Volume::fStep

private

Definition at line 96 of file G3Volume.h.

Float_t G3Volume::fTheta

private

Definition at line 99 of file G3Volume.h.

Float_t G3Volume::fU

private

Definition at line 102 of file G3Volume.h.

Float_t G3Volume::fUscale

private

Definition at line 104 of file G3Volume.h.

Float_t G3Volume::fV

private

Definition at line 103 of file G3Volume.h.

Float_t G3Volume::fVscale

private

Definition at line 105 of file G3Volume.h.

---

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

• larreco/larreco/Genfit/TGeant3/G3Volume.h
• larreco/larreco/Genfit/TGeant3/G3Volume.cxx