Ignore:
Timestamp:
Dec 22, 2010, 3:52:27 PM (14 years ago)
Author:
garnier
Message:

geant4 tag 9.4

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/persistency/ascii/src/G4tgbGeometryDumper.cc

    r1337 r1347  
    2525//
    2626//
    27 // $Id: G4tgbGeometryDumper.cc,v 1.12 2009/11/19 13:29:04 arce Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4tgbGeometryDumper.cc,v 1.15 2010/11/02 11:13:05 gcosmo Exp $
     28// GEANT4 tag $Name: geant4-09-04-ref-00 $
    2929//
    3030//
    … …  
    8181//------------------------------------------------------------------------
    8282G4tgbGeometryDumper::G4tgbGeometryDumper()
    83 {
    84 
    85   theRotationNumber = 0;
     83  : theFile(0), theRotationNumber(0)
     84{
    8685}
    8786
    … …  
    649648  } else if (solidType == "REFLECTEDSOLID") {
    650649    G4ReflectedSolid* solidrefl = dynamic_cast<G4ReflectedSolid*>(solid);
     650    if (!solidrefl)
     651    {
     652      G4Exception("G4tgbGeometryDumper::DumpSolid()",
     653                  "InvalidType", FatalException, "Invalid reflected solid!");
     654      return solidName;
     655    }
    651656    G4VSolid* solidori = solidrefl->GetConstituentMovedSolid();
    652657    DumpSolid( solidori );
    … …  
    669674{
    670675  G4BooleanSolid * bso = dynamic_cast < G4BooleanSolid * > (so);
     676  if (!bso)  { return; }
    671677  G4VSolid* solid0 = bso->GetConstituentSolid( 0 );
    672678  G4VSolid* solid1 = bso->GetConstituentSolid( 1 );
    … …  
    676682  {
    677683    solid1Disp = dynamic_cast<G4DisplacedSolid*>(solid1);
    678     solid1 = solid1Disp->GetConstituentMovedSolid();
     684    if (solid1Disp)  { solid1 = solid1Disp->GetConstituentMovedSolid(); }
    679685  }
    680686  DumpSolid( solid0 );
    … …  
    736742  if (solidType == "BOX")  {
    737743    const G4Box * sb = dynamic_cast < const G4Box*>(so);
    738     params.push_back( sb->GetXHalfLength() );
    739     params.push_back( sb->GetYHalfLength() );
    740     params.push_back( sb->GetZHalfLength() );
    741 
     744    if (sb) {
     745      params.push_back( sb->GetXHalfLength() );
     746      params.push_back( sb->GetYHalfLength() );
     747      params.push_back( sb->GetZHalfLength() );
     748    }
    742749  } else if (solidType == "TUBS") {
    743750    const G4Tubs * tu = dynamic_cast < const G4Tubs * > (so);
    744     params.push_back( tu->GetInnerRadius()   );
    745     params.push_back( tu->GetOuterRadius()   );
    746     params.push_back( tu->GetZHalfLength()   );
    747     params.push_back( tu->GetStartPhiAngle()/deg );
    748     params.push_back( tu->GetDeltaPhiAngle()/deg );
    749    
     751    if (tu) {
     752      params.push_back( tu->GetInnerRadius()   );
     753      params.push_back( tu->GetOuterRadius()   );
     754      params.push_back( tu->GetZHalfLength()   );
     755      params.push_back( tu->GetStartPhiAngle()/deg );
     756      params.push_back( tu->GetDeltaPhiAngle()/deg );
     757    }
    750758  } else if (solidType == "TRAP") {
    751759    const G4Trap * trp = dynamic_cast < const G4Trap * > (so);
    752     G4ThreeVector symAxis(trp->GetSymAxis());
    753     G4double theta, phi;
    754     theta = symAxis.theta()/deg;
    755     phi = symAxis.phi()/deg;
    756     params.push_back( trp->GetZHalfLength() );
    757     params.push_back( theta );
    758     params.push_back( phi);
    759     params.push_back( trp->GetYHalfLength1() );
    760     params.push_back( trp->GetXHalfLength1() );
    761     params.push_back( trp->GetXHalfLength2() );   
    762     params.push_back( std::atan(trp->GetTanAlpha1())/deg );
    763     params.push_back( trp->GetYHalfLength2()    );
    764     params.push_back( trp->GetXHalfLength3()    );
    765     params.push_back( trp->GetXHalfLength4()    );   
    766     params.push_back( std::atan(trp->GetTanAlpha2())/deg );
    767 
     760    if (trp) {
     761      G4ThreeVector symAxis(trp->GetSymAxis());
     762      G4double theta = symAxis.theta()/deg;
     763      G4double phi = symAxis.phi()/deg;
     764      params.push_back( trp->GetZHalfLength() );
     765      params.push_back( theta );
     766      params.push_back( phi);
     767      params.push_back( trp->GetYHalfLength1() );
     768      params.push_back( trp->GetXHalfLength1() );
     769      params.push_back( trp->GetXHalfLength2() );   
     770      params.push_back( std::atan(trp->GetTanAlpha1())/deg );
     771      params.push_back( trp->GetYHalfLength2()    );
     772      params.push_back( trp->GetXHalfLength3()    );
     773      params.push_back( trp->GetXHalfLength4()    );   
     774      params.push_back( std::atan(trp->GetTanAlpha2())/deg );
     775    }
    768776  } else if (solidType == "TRD") {
    769777    const G4Trd * tr = dynamic_cast < const G4Trd * > (so);
    770     params.push_back( tr->GetXHalfLength1() );
    771     params.push_back( tr->GetXHalfLength2() );
    772     params.push_back( tr->GetYHalfLength1() );
    773     params.push_back( tr->GetYHalfLength2() );
    774     params.push_back( tr->GetZHalfLength());
    775 
     778    if (tr) {
     779      params.push_back( tr->GetXHalfLength1() );
     780      params.push_back( tr->GetXHalfLength2() );
     781      params.push_back( tr->GetYHalfLength1() );
     782      params.push_back( tr->GetYHalfLength2() );
     783      params.push_back( tr->GetZHalfLength());
     784    }
    776785  } else if (solidType == "PARA") {
    777786    const G4Para * para = dynamic_cast < const G4Para * > (so);
    778     double phi;
    779     if(para->GetSymAxis().z()!=1.0)
    780       { phi = std::atan(para->GetSymAxis().y()/para->GetSymAxis().x()); }
    781     else
    782       { phi = 0; }
    783     params.push_back( para->GetXHalfLength());
    784     params.push_back(  para->GetYHalfLength());
    785     params.push_back( para->GetZHalfLength());
    786     params.push_back( std::atan(para->GetTanAlpha())/deg);
    787     params.push_back( std::acos(para->GetSymAxis().z())/deg);
    788     params.push_back( phi/deg);
    789    
     787    if (para) {
     788      G4double phi = 0.;
     789      if(para->GetSymAxis().z()!=1.0)
     790        { phi = std::atan(para->GetSymAxis().y()/para->GetSymAxis().x()); }
     791      params.push_back( para->GetXHalfLength());
     792      params.push_back(  para->GetYHalfLength());
     793      params.push_back( para->GetZHalfLength());
     794      params.push_back( std::atan(para->GetTanAlpha())/deg);
     795      params.push_back( std::acos(para->GetSymAxis().z())/deg);
     796      params.push_back( phi/deg);
     797    }
    790798  } else if (solidType == "CONS") {
    791799    const G4Cons * cn = dynamic_cast < const G4Cons * > (so);
    792     params.push_back( cn->GetInnerRadiusMinusZ() );
    793     params.push_back( cn->GetOuterRadiusMinusZ() );
    794     params.push_back( cn->GetInnerRadiusPlusZ()  );   
    795     params.push_back( cn->GetOuterRadiusPlusZ()  );
    796     params.push_back( cn->GetZHalfLength() );
    797     params.push_back( cn->GetStartPhiAngle()/deg  );
    798     params.push_back( cn->GetDeltaPhiAngle()/deg  );
    799 
     800    if (cn) {
     801      params.push_back( cn->GetInnerRadiusMinusZ() );
     802      params.push_back( cn->GetOuterRadiusMinusZ() );
     803      params.push_back( cn->GetInnerRadiusPlusZ()  );   
     804      params.push_back( cn->GetOuterRadiusPlusZ()  );
     805      params.push_back( cn->GetZHalfLength() );
     806      params.push_back( cn->GetStartPhiAngle()/deg  );
     807      params.push_back( cn->GetDeltaPhiAngle()/deg  );
     808    }
    800809  } else if (solidType == "SPHERE") {
    801810    const G4Sphere * sphere = dynamic_cast < const G4Sphere * > (so);
    802     params.push_back( sphere->GetInnerRadius());
    803     params.push_back( sphere->GetOuterRadius());
    804     params.push_back( sphere->GetStartPhiAngle()/deg);
    805     params.push_back( sphere->GetDeltaPhiAngle()/deg);
    806     params.push_back( sphere->GetStartThetaAngle()/deg);
    807     params.push_back( sphere->GetDeltaThetaAngle()/deg);
    808 
     811    if (sphere) {
     812      params.push_back( sphere->GetInnerRadius());
     813      params.push_back( sphere->GetOuterRadius());
     814      params.push_back( sphere->GetStartPhiAngle()/deg);
     815      params.push_back( sphere->GetDeltaPhiAngle()/deg);
     816      params.push_back( sphere->GetStartThetaAngle()/deg);
     817      params.push_back( sphere->GetDeltaThetaAngle()/deg);
     818    }
    809819  } else if (solidType == "ORB") {
    810820    const G4Orb * orb = dynamic_cast < const G4Orb * > (so);
    811     params.push_back( orb->GetRadius());
    812    
     821    if (orb) {
     822      params.push_back( orb->GetRadius());
     823    }
    813824  } else if (solidType == "TORUS") {
    814825    const G4Torus * torus = dynamic_cast < const G4Torus * > (so);
    815     params.push_back( torus->GetRmin());
    816     params.push_back( torus->GetRmax());
    817     params.push_back( torus->GetRtor());
    818     params.push_back( torus->GetSPhi()/deg);
    819     params.push_back( torus->GetDPhi()/deg);
    820  
     826    if (torus) {
     827      params.push_back( torus->GetRmin());
     828      params.push_back( torus->GetRmax());
     829      params.push_back( torus->GetRtor());
     830      params.push_back( torus->GetSPhi()/deg);
     831      params.push_back( torus->GetDPhi()/deg);
     832    }
    821833  } else if (solidType == "POLYCONE") {
    822834    //--- Dump RZ corners, as original parameters will not be present
    823835    //    if it was build from RZ corners
    824836    const G4Polycone * pc = dynamic_cast < const G4Polycone * > (so);
     837    if (pc) {
     838      G4double angphi = pc->GetStartPhi()/deg;
     839      if( angphi > 180*deg )  { angphi -= 360*deg; }
     840      G4int ncor = pc->GetNumRZCorner();
     841      params.push_back( angphi );
     842      params.push_back( pc->GetOriginalParameters()->Opening_angle/deg );
     843      params.push_back( ncor );
    825844   
    826     G4double angphi = pc->GetStartPhi()/deg;
    827     if( angphi > 180*deg )  { angphi -= 360*deg; }
    828     G4int ncor = pc->GetNumRZCorner();
    829     params.push_back( angphi );
    830     params.push_back( pc->GetOriginalParameters()->Opening_angle/deg );
    831     params.push_back( ncor );
    832    
    833     for( G4int ii = 0; ii < ncor; ii++ )
    834     {
    835       params.push_back( pc->GetCorner(ii).r );
    836       params.push_back( pc->GetCorner(ii).z );
    837     }
    838    
    839    
     845      for( G4int ii = 0; ii < ncor; ii++ )
     846      {
     847        params.push_back( pc->GetCorner(ii).r );
     848        params.push_back( pc->GetCorner(ii).z );
     849      }
     850    }
    840851  } else if (solidType == "POLYHEDRA") {
    841852    //--- Dump RZ corners, as original parameters will not be present
    842853    //    if it was build from RZ corners
    843854    const G4Polyhedra * ph = (dynamic_cast < const G4Polyhedra * > (so));
     855    if (ph) {
     856      G4double angphi = ph->GetStartPhi()/deg;
     857      if( angphi > 180*deg ) angphi -= 360*deg;
     858
     859      G4int ncor = ph->GetNumRZCorner();
    844860   
    845     G4double angphi = ph->GetStartPhi()/deg;
    846     if( angphi > 180*deg ) angphi -= 360*deg;
    847 
    848     G4int ncor = ph->GetNumRZCorner();
    849    
    850     params.push_back( angphi );
    851     params.push_back( ph->GetOriginalParameters()->Opening_angle/deg );
    852     params.push_back( ph->GetNumSide() );
    853     params.push_back( ncor );
    854 
    855     for( G4int ii = 0; ii < ncor; ii++ )
    856     {
    857        params.push_back( ph->GetCorner(ii).r );
    858        params.push_back( ph->GetCorner(ii).z );
    859     }
    860 
     861      params.push_back( angphi );
     862      params.push_back( ph->GetOriginalParameters()->Opening_angle/deg );
     863      params.push_back( ph->GetNumSide() );
     864      params.push_back( ncor );
     865
     866      for( G4int ii = 0; ii < ncor; ii++ )
     867      {
     868         params.push_back( ph->GetCorner(ii).r );
     869         params.push_back( ph->GetCorner(ii).z );
     870      }
     871    }
    861872  } else if (solidType == "ELLIPTICALTUBE") {
    862873    const G4EllipticalTube * eltu =
    863874          dynamic_cast < const G4EllipticalTube * > (so);
    864     params.push_back( eltu->GetDx());
    865     params.push_back( eltu->GetDy());
    866     params.push_back( eltu->GetDz());
    867 
     875    if (eltu) {
     876      params.push_back( eltu->GetDx());
     877      params.push_back( eltu->GetDy());
     878      params.push_back( eltu->GetDz());
     879    }
    868880  } else if (solidType == "ELLIPSOID" ){
    869881    const G4Ellipsoid* dso = dynamic_cast < const G4Ellipsoid * > (so);
    870     params.push_back( dso->GetSemiAxisMax(0)  );
    871     params.push_back( dso->GetSemiAxisMax(1)  );
    872     params.push_back( dso->GetSemiAxisMax(2)  );
    873     params.push_back( dso->GetZBottomCut()   );
    874     params.push_back( dso->GetZTopCut() );
    875 
     882    if (dso) {
     883      params.push_back( dso->GetSemiAxisMax(0)  );
     884      params.push_back( dso->GetSemiAxisMax(1)  );
     885      params.push_back( dso->GetSemiAxisMax(2)  );
     886      params.push_back( dso->GetZBottomCut()   );
     887      params.push_back( dso->GetZTopCut() );
     888    }
    876889  } else if (solidType == "ELLIPTICAL_CONE") {
    877890    const G4EllipticalCone * elco =
    878891          dynamic_cast < const G4EllipticalCone * > (so);
    879     params.push_back( elco-> GetSemiAxisX() );
    880     params.push_back( elco-> GetSemiAxisY() );
    881     params.push_back( elco-> GetZMax() );
    882     params.push_back( elco-> GetZTopCut() );
    883 
     892    if (elco) {
     893      params.push_back( elco-> GetSemiAxisX() );
     894      params.push_back( elco-> GetSemiAxisY() );
     895      params.push_back( elco-> GetZMax() );
     896      params.push_back( elco-> GetZTopCut() );
     897    }
    884898  } else if (solidType == "HYPE") {
    885899    const G4Hype* hype = dynamic_cast < const G4Hype * > (so);
    886     params.push_back( hype->GetInnerRadius());
    887     params.push_back( hype->GetOuterRadius());
    888     params.push_back( hype->GetInnerStereo()/deg);
    889     params.push_back( hype->GetOuterStereo()/deg);
    890     params.push_back( 2*hype->GetZHalfLength());
    891 
     900    if (hype) {
     901      params.push_back( hype->GetInnerRadius());
     902      params.push_back( hype->GetOuterRadius());
     903      params.push_back( hype->GetInnerStereo()/deg);
     904      params.push_back( hype->GetOuterStereo()/deg);
     905      params.push_back( 2*hype->GetZHalfLength());
     906    }
    892907//  } else if( solidType == "TET" ) {
    893908
    894909  } else if( solidType == "TWISTEDBOX" ) {
    895910    const G4TwistedBox* tbox = dynamic_cast < const G4TwistedBox * > (so);
    896     params.push_back( tbox->GetPhiTwist()/deg );
    897     params.push_back( tbox->GetXHalfLength() );
    898     params.push_back( tbox->GetYHalfLength() );
    899     params.push_back( tbox->GetZHalfLength() );
    900 
     911    if (tbox) {
     912      params.push_back( tbox->GetPhiTwist()/deg );
     913      params.push_back( tbox->GetXHalfLength() );
     914      params.push_back( tbox->GetYHalfLength() );
     915      params.push_back( tbox->GetZHalfLength() );
     916    }
    901917  } else if( solidType == "TWISTEDTRAP" ) {
    902918    const G4TwistedTrap * ttrap = dynamic_cast < const G4TwistedTrap * > (so);
    903     params.push_back( ttrap->GetPhiTwist()/deg );
    904     params.push_back( ttrap->GetZHalfLength() );
    905     params.push_back( ttrap->GetPolarAngleTheta()/deg );
    906     params.push_back( ttrap->GetAzimuthalAnglePhi()/deg );
    907     params.push_back( ttrap->GetY1HalfLength() );
    908     params.push_back( ttrap->GetX1HalfLength() );
    909     params.push_back( ttrap->GetX2HalfLength() );   
    910     params.push_back( ttrap->GetY2HalfLength()    );
    911     params.push_back( ttrap->GetX3HalfLength()    );
    912     params.push_back( ttrap->GetX4HalfLength()    );   
    913     params.push_back( ttrap->GetTiltAngleAlpha()/deg );
    914    
     919    if (ttrap) {
     920      params.push_back( ttrap->GetPhiTwist()/deg );
     921      params.push_back( ttrap->GetZHalfLength() );
     922      params.push_back( ttrap->GetPolarAngleTheta()/deg );
     923      params.push_back( ttrap->GetAzimuthalAnglePhi()/deg );
     924      params.push_back( ttrap->GetY1HalfLength() );
     925      params.push_back( ttrap->GetX1HalfLength() );
     926      params.push_back( ttrap->GetX2HalfLength() );   
     927      params.push_back( ttrap->GetY2HalfLength()    );
     928      params.push_back( ttrap->GetX3HalfLength()    );
     929      params.push_back( ttrap->GetX4HalfLength()    );   
     930      params.push_back( ttrap->GetTiltAngleAlpha()/deg );
     931    }
    915932  } else if( solidType == "TWISTEDTRD" ) {
    916933    const G4TwistedTrd * ttrd = dynamic_cast < const G4TwistedTrd * > (so);
    917     params.push_back( ttrd->GetX1HalfLength());
    918     params.push_back( ttrd->GetX2HalfLength() );
    919     params.push_back( ttrd->GetY1HalfLength() );
    920     params.push_back( ttrd->GetY2HalfLength() );
    921     params.push_back( ttrd->GetZHalfLength() );
    922     params.push_back( ttrd->GetPhiTwist()/deg );
    923  
     934    if (ttrd) {
     935      params.push_back( ttrd->GetX1HalfLength());
     936      params.push_back( ttrd->GetX2HalfLength() );
     937      params.push_back( ttrd->GetY1HalfLength() );
     938      params.push_back( ttrd->GetY2HalfLength() );
     939      params.push_back( ttrd->GetZHalfLength() );
     940      params.push_back( ttrd->GetPhiTwist()/deg );
     941    }
    924942  } else if( solidType == "TWISTEDTUBS" ) {
    925943    const G4TwistedTubs * ttub = dynamic_cast < const G4TwistedTubs * > (so);
    926     params.push_back( ttub->GetInnerRadius()   );
    927     params.push_back( ttub->GetOuterRadius()   );
    928     params.push_back( ttub->GetZHalfLength()   );
    929     params.push_back( ttub->GetDPhi()/deg );
    930     params.push_back( ttub->GetPhiTwist()/deg );
    931 
     944    if (ttub) {
     945      params.push_back( ttub->GetInnerRadius()   );
     946      params.push_back( ttub->GetOuterRadius()   );
     947      params.push_back( ttub->GetZHalfLength()   );
     948      params.push_back( ttub->GetDPhi()/deg );
     949      params.push_back( ttub->GetPhiTwist()/deg );
     950    }
    932951  }
    933952  else
    … …  
    945964G4String G4tgbGeometryDumper::DumpRotationMatrix( G4RotationMatrix* rotm )
    946965{
     966  if (!rotm)  { rotm = new G4RotationMatrix(); }
     967
    947968  G4double de = MatDeterminant(rotm);
    948  
    949969  G4String rotName = LookForExistingRotation( rotm );
    950970  if( rotName != "" )  { return rotName; }
    951 
    952   if (!rotm)  { rotm = new G4RotationMatrix(); }
    953971
    954972  G4ThreeVector v(1.,1.,1.);
Note: See TracChangeset for help on using the changeset viewer.