G4ModelingParameters.cc

Go to the documentation of this file.
00001 //
00002 // ********************************************************************
00003 // * License and Disclaimer                                           *
00004 // *                                                                  *
00005 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
00006 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
00007 // * conditions of the Geant4 Software License,  included in the file *
00008 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
00009 // * include a list of copyright holders.                             *
00010 // *                                                                  *
00011 // * Neither the authors of this software system, nor their employing *
00012 // * institutes,nor the agencies providing financial support for this *
00013 // * work  make  any representation or  warranty, express or implied, *
00014 // * regarding  this  software system or assume any liability for its *
00015 // * use.  Please see the license in the file  LICENSE  and URL above *
00016 // * for the full disclaimer and the limitation of liability.         *
00017 // *                                                                  *
00018 // * This  code  implementation is the result of  the  scientific and *
00019 // * technical work of the GEANT4 collaboration.                      *
00020 // * By using,  copying,  modifying or  distributing the software (or *
00021 // * any work based  on the software)  you  agree  to acknowledge its *
00022 // * use  in  resulting  scientific  publications,  and indicate your *
00023 // * acceptance of all terms of the Geant4 Software license.          *
00024 // ********************************************************************
00025 //
00026 //
00027 // $Id$
00028 //
00029 // 
00030 // John Allison  31st December 1997.
00031 // Parameters associated with the modeling of GEANT4 objects.
00032 
00033 #include "G4ModelingParameters.hh"
00034 
00035 #include "G4ios.hh"
00036 #include "G4VisAttributes.hh"
00037 #include "G4ExceptionSeverity.hh"
00038 #include "G4SystemOfUnits.hh"
00039 #include "G4VSolid.hh"
00040 #include "G4VPhysicalVolume.hh"
00041 #include "G4PhysicalVolumeModel.hh"
00042 
00043 G4ModelingParameters::G4ModelingParameters ():
00044   fWarning               (true),
00045   fpDefaultVisAttributes (0),
00046   fDrawingStyle          (wf),
00047   fCulling               (false),
00048   fCullInvisible         (false),
00049   fDensityCulling        (false),
00050   fVisibleDensity        (0.01 * g / cm3),
00051   fCullCovered           (false),
00052   fExplodeFactor         (1.),
00053   fNoOfSides             (24),
00054   fpSectionSolid         (0),
00055   fpCutawaySolid         (0),
00056   fpEvent                (0)
00057 {}
00058 
00059 G4ModelingParameters::G4ModelingParameters
00060 (const G4VisAttributes* pDefaultVisAttributes,
00061  G4ModelingParameters::DrawingStyle drawingStyle,
00062  G4bool isCulling,
00063  G4bool isCullingInvisible,
00064  G4bool isDensityCulling,
00065  G4double visibleDensity,
00066  G4bool isCullingCovered,
00067  G4int noOfSides
00068  ):
00069   fWarning        (true),
00070   fpDefaultVisAttributes (pDefaultVisAttributes),
00071   fDrawingStyle   (drawingStyle),
00072   fCulling        (isCulling),
00073   fCullInvisible  (isCullingInvisible),
00074   fDensityCulling (isDensityCulling),
00075   fVisibleDensity (visibleDensity),
00076   fCullCovered    (isCullingCovered),
00077   fExplodeFactor  (1.),
00078   fNoOfSides      (noOfSides),
00079   fpSectionSolid  (0),
00080   fpCutawaySolid  (0),
00081   fpEvent         (0)
00082 {}
00083 
00084 G4ModelingParameters::~G4ModelingParameters ()
00085 {
00086   delete fpSectionSolid;
00087   delete fpCutawaySolid;
00088 }
00089 
00090 G4ModelingParameters::VisAttributesModifier::VisAttributesModifier
00091 (const G4VisAttributes& visAtts,
00092  G4ModelingParameters::VisAttributesSignifier signifier,
00093  const std::vector<G4PhysicalVolumeModel::G4PhysicalVolumeNodeID>& path):
00094 fVisAtts(visAtts), fSignifier(signifier)
00095 {
00096   typedef G4PhysicalVolumeModel::G4PhysicalVolumeNodeID PVNodeID;
00097   typedef std::vector<PVNodeID> PVPath;
00098   typedef PVPath::const_iterator PVPathConstIterator;
00099   PVPathConstIterator i;
00100   for (i = path.begin();
00101        i != path.end();
00102        ++i) {
00103     fPVNameCopyNoPath.push_back
00104     (PVNameCopyNo
00105      (i->GetPhysicalVolume()->GetName(),
00106       i->GetCopyNo()));
00107   }
00108 }
00109 
00110 void G4ModelingParameters::SetVisibleDensity (G4double visibleDensity) {
00111   const G4double reasonableMaximum = 10.0 * g / cm3;
00112   if (visibleDensity < 0 && fWarning) {
00113     G4cout << "G4ModelingParameters::SetVisibleDensity: attempt to set negative "
00114       "density - ignored." << G4endl;
00115   }
00116   else {
00117     if (fVisibleDensity > reasonableMaximum && fWarning) {
00118       G4cout << "G4ModelingParameters::SetVisibleDensity: density > "
00119            << reasonableMaximum
00120            << " g / cm3 - did you mean this?"
00121            << G4endl;
00122     }
00123     fVisibleDensity = visibleDensity;
00124   }
00125 }
00126 
00127 G4int G4ModelingParameters::SetNoOfSides (G4int nSides) {
00128   const G4int  nSidesMin = 12;
00129   if (nSides < nSidesMin) {
00130     nSides = nSidesMin;
00131     if (fWarning)
00132       G4cout << "G4ModelingParameters::SetNoOfSides: attempt to set the"
00133         "\nnumber of sides per circle < " << nSidesMin
00134              << "; forced to" << nSides << G4endl;
00135   }
00136   fNoOfSides = nSides;
00137   return fNoOfSides;
00138 }
00139 
00140 void G4ModelingParameters::SetSectionSolid
00141 (G4VSolid* pSectionSolid) {
00142   delete fpSectionSolid;
00143   fpSectionSolid = pSectionSolid;
00144 }
00145 
00146 void G4ModelingParameters::SetCutawaySolid
00147 (G4VSolid* pCutawaySolid) {
00148   delete fpCutawaySolid;
00149   fpCutawaySolid = pCutawaySolid;
00150 }
00151 
00152 std::ostream& operator << (std::ostream& os, const G4ModelingParameters& mp)
00153 {
00154   os << "Modeling parameters (warning ";
00155   if (mp.fWarning) os << "true";
00156   else os << "false";
00157   os << "):";
00158 
00159   const G4VisAttributes* va = mp.fpDefaultVisAttributes;
00160   os << "\n  Default vis. attributes: ";
00161   if (va) os << *va;
00162   else os << "none";
00163 
00164   os << "\n  Current requested drawing style: ";
00165   switch (mp.fDrawingStyle) {
00166   case G4ModelingParameters::wf:
00167     os << "wireframe"; break;
00168   case G4ModelingParameters::hlr:
00169     os << "hidden line removal (hlr)"; break;
00170   case G4ModelingParameters::hsr:
00171     os << "surface (hsr)"; break;
00172   case G4ModelingParameters::hlhsr:
00173     os << "surface and edges (hlhsr)"; break;
00174   default: os << "unrecognised"; break;
00175   }
00176 
00177   os << "\n  Culling: ";
00178   if (mp.fCulling) os << "on";
00179   else            os << "off";
00180 
00181   os << "\n  Culling invisible objects: ";
00182   if (mp.fCullInvisible) os << "on";
00183   else                  os << "off";
00184 
00185   os << "\n  Density culling: ";
00186   if (mp.fDensityCulling) {
00187     os << "on - invisible if density less than "
00188        << mp.fVisibleDensity / (1. * g / cm3) << " g cm^-3";
00189   }
00190   else os << "off";
00191 
00192   os << "\n  Culling daughters covered by opaque mothers: ";
00193   if (mp.fCullCovered) os << "on";
00194   else                os << "off";
00195 
00196   os << "\n  Explode factor: " << mp.fExplodeFactor
00197      << " about centre: " << mp.fExplodeCentre;
00198 
00199   os << "\n  No. of sides used in circle polygon approximation: "
00200      << mp.fNoOfSides;
00201 
00202   os << "\n  Section (DCUT) shape (G4VSolid) pointer: ";
00203   if (!mp.fpSectionSolid) os << "non-";
00204   os << "null";
00205 
00206   os << "\n  Cutaway (DCUT) shape (G4VSolid) pointer: ";
00207   if (!mp.fpCutawaySolid) os << "non-";
00208   os << "null";
00209 
00210   os << "\n  Event pointer: " << mp.fpEvent;
00211 
00212   os << "\n  Vis attributes modifiers: ";
00213   const std::vector<G4ModelingParameters::VisAttributesModifier>& vams =
00214     mp.fVisAttributesModifiers;
00215   if (vams.empty()) {
00216     os << "None";
00217   } else {
00218     os << vams;
00219   }
00220   
00221   return os;
00222 }
00223 
00224 G4bool G4ModelingParameters::operator !=
00225 (const G4ModelingParameters& mp) const {
00226 
00227   if (
00228       (fWarning                != mp.fWarning)                ||
00229       (*fpDefaultVisAttributes != *mp.fpDefaultVisAttributes) ||
00230       (fCulling                != mp.fCulling)                ||
00231       (fCullInvisible          != mp.fCullInvisible)          ||
00232       (fDensityCulling         != mp.fDensityCulling)         ||
00233       (fCullCovered            != mp.fCullCovered)            ||
00234       (fExplodeFactor          != mp.fExplodeFactor)          ||
00235       (fExplodeCentre          != mp.fExplodeCentre)          ||
00236       (fNoOfSides              != mp.fNoOfSides)              ||
00237       (fpSectionSolid          != mp.fpSectionSolid)     ||
00238       (fpCutawaySolid          != mp.fpCutawaySolid)     ||
00239       (fpEvent                 != mp.fpEvent)
00240       )
00241     return true;
00242 
00243   if (fDensityCulling &&
00244       (fVisibleDensity != mp.fVisibleDensity)) return true;
00245 
00246   if (VAMSNotEqual(fVisAttributesModifiers, mp.fVisAttributesModifiers))
00247     return true;
00248 
00249   return false;
00250 }
00251 
00252 G4bool G4ModelingParameters::PVNameCopyNoPathNotEqual
00253 (const G4ModelingParameters::PVNameCopyNoPath& path1,
00254  const G4ModelingParameters::PVNameCopyNoPath& path2)
00255 {
00256   if (path1.size() != path2.size()) return true;
00257   if (path1.empty()) return false;
00258   PVNameCopyNoPathConstIterator i1, i2;
00259   for (i1 = path1.begin(), i2 = path2.begin();
00260        i1 != path1.end();
00261        ++i1, ++i2) {
00262     if (i1->GetName() != i2->GetName()) return true;
00263     if (i1->GetCopyNo() != i2->GetCopyNo()) return true;
00264   }
00265   return false;
00266 }
00267 
00268 G4bool G4ModelingParameters::VAMSNotEqual
00269 (const std::vector<G4ModelingParameters::VisAttributesModifier>& vams1,
00270  const std::vector<G4ModelingParameters::VisAttributesModifier>& vams2)
00271 {
00272   if (vams1.size() != vams2.size()) return true;
00273   if (vams1.empty()) return false;
00274   std::vector<VisAttributesModifier>::const_iterator i1, i2;
00275   for (i1 = vams1.begin(), i2 = vams2.begin();
00276        i1 != vams1.end();
00277        ++i1, ++i2) {
00278     const PVNameCopyNoPath& vam1Path = i1->GetPVNameCopyNoPath();
00279     const PVNameCopyNoPath& vam2Path = i2->GetPVNameCopyNoPath();
00280     if (PVNameCopyNoPathNotEqual(vam1Path,vam2Path)) return true;
00281     if (i1->GetVisAttributesSignifier() != i2->GetVisAttributesSignifier())
00282       return true;
00283     const G4VisAttributes& vam1VisAtts = i1->GetVisAttributes();
00284     const G4VisAttributes& vam2VisAtts = i2->GetVisAttributes();
00285     const G4Colour& c1 = vam1VisAtts.GetColour();
00286     const G4Colour& c2 = vam2VisAtts.GetColour();
00287     switch (i1->GetVisAttributesSignifier()) {
00288       case G4ModelingParameters::VASVisibility:
00289         if (vam1VisAtts.IsVisible() != vam2VisAtts.IsVisible())
00290           return true;
00291         break;
00292       case G4ModelingParameters::VASDaughtersInvisible:
00293         if (vam1VisAtts.IsDaughtersInvisible() !=
00294             vam2VisAtts.IsDaughtersInvisible())
00295           return true;
00296         break;
00297       case G4ModelingParameters::VASColour:
00298         if (c1 != c2)
00299           return true;
00300         break;
00301       case G4ModelingParameters::VASLineStyle:
00302         if (vam1VisAtts.GetLineStyle() != vam2VisAtts.GetLineStyle())
00303           return true;
00304         break;
00305       case G4ModelingParameters::VASLineWidth:
00306         if (vam1VisAtts.GetLineWidth() != vam2VisAtts.GetLineWidth())
00307           return true;
00308         break;
00309       case G4ModelingParameters::VASForceWireframe:
00310         if (vam1VisAtts.GetForcedDrawingStyle() !=
00311             vam2VisAtts.GetForcedDrawingStyle())
00312           return true;
00313         break;
00314       case G4ModelingParameters::VASForceSolid:
00315         if (vam1VisAtts.GetForcedDrawingStyle() !=
00316             vam2VisAtts.GetForcedDrawingStyle())
00317           return true;
00318         break;
00319       case G4ModelingParameters::VASForceAuxEdgeVisible:
00320         if (vam1VisAtts.IsForceAuxEdgeVisible() !=
00321             vam2VisAtts.IsForceAuxEdgeVisible())
00322           return true;
00323         break;
00324       case G4ModelingParameters::VASForceLineSegmentsPerCircle:
00325         if (vam1VisAtts.GetForcedLineSegmentsPerCircle() !=
00326             vam2VisAtts.GetForcedLineSegmentsPerCircle())
00327           return true;
00328         break;
00329     }
00330   }
00331   return false;
00332 }
00333 
00334 std::ostream& operator <<
00335 (std::ostream& os, const G4ModelingParameters::PVNameCopyNoPath& path)
00336 {
00337 //  os << "Touchable path: physical-volume-name:copy-number pairs:\n  ";
00338   G4ModelingParameters::PVNameCopyNoPathConstIterator i;
00339   for (i = path.begin(); i != path.end(); ++i) {
00340     if (i != path.begin()) {
00341       os << ", ";
00342     }
00343     os << i->GetName() << ':' << i->GetCopyNo();
00344   }
00345   return os;
00346 }
00347 
00348 std::ostream& operator <<
00349 (std::ostream& os,
00350  const std::vector<G4ModelingParameters::VisAttributesModifier>& vams)
00351 {
00352   std::vector<G4ModelingParameters::VisAttributesModifier>::const_iterator
00353     iModifier;
00354   for (iModifier = vams.begin();
00355        iModifier != vams.end();
00356        ++iModifier) {
00357     const G4ModelingParameters::PVNameCopyNoPath& vamPath =
00358       iModifier->GetPVNameCopyNoPath();
00359     os << '\n' << vamPath;
00360     const G4VisAttributes& vamVisAtts = iModifier->GetVisAttributes();
00361     const G4Colour& c = vamVisAtts.GetColour();
00362     switch (iModifier->GetVisAttributesSignifier()) {
00363       case G4ModelingParameters::VASVisibility:
00364         os << " visibility ";
00365         if (vamVisAtts.IsVisible()) {
00366           os << "true";
00367         } else {
00368           os << "false";
00369         }
00370         break;
00371       case G4ModelingParameters::VASDaughtersInvisible:
00372         os << " daughtersInvisible ";
00373         if (vamVisAtts.IsDaughtersInvisible()) {
00374           os << "true";
00375         } else {
00376           os << "false";
00377         }
00378         break;
00379       case G4ModelingParameters::VASColour:
00380         os << " colour " << c;
00381         break;
00382       case G4ModelingParameters::VASLineStyle:
00383         os << " lineStyle ";
00384         switch (vamVisAtts.GetLineStyle()) {
00385           case G4VisAttributes::unbroken:
00386             os << "unbroken";
00387             break;
00388           case G4VisAttributes::dashed:
00389             os << "dashed";
00390             break;
00391           case G4VisAttributes::dotted:
00392             os << "dotted";
00393         }
00394         break;
00395       case G4ModelingParameters::VASLineWidth:
00396         os << " lineWidth "
00397         << vamVisAtts.GetLineWidth();
00398         break;
00399       case G4ModelingParameters::VASForceWireframe:
00400         if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::wireframe) {
00401           os << " forceWireframe ";
00402           if (vamVisAtts.IsForceDrawingStyle()) {
00403             os << "true";
00404           } else {
00405             os << "false";
00406           }
00407         }
00408         break;
00409       case G4ModelingParameters::VASForceSolid:
00410         if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::solid) {
00411           os << " forceSolid ";
00412           if (vamVisAtts.IsForceDrawingStyle()) {
00413             os << "true";
00414           } else {
00415             os << "false";
00416           }
00417         }
00418         break;
00419       case G4ModelingParameters::VASForceAuxEdgeVisible:
00420         os << " forceAuxEdgeVisible ";
00421         if (vamVisAtts.IsForceAuxEdgeVisible()) {
00422           os << "true";
00423         } else {
00424           os << "false";
00425         }
00426         break;
00427       case G4ModelingParameters::VASForceLineSegmentsPerCircle:
00428         os << " lineSegmentsPerCircle "
00429         << vamVisAtts.GetForcedLineSegmentsPerCircle();
00430         break;
00431     }
00432   }
00433 
00434   return os;
00435 }
00436 

Generated on Mon May 27 17:48:52 2013 for Geant4 by  doxygen 1.4.7