Ignore:
Timestamp:
Jan 5, 2011, 12:19:12 PM (14 years ago)
Author:
garnier
Message:

update

Location:
trunk/source/visualization/modeling/src
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/visualization/modeling/src/CVS/Entries

    r1346 r1348  
    1 /G4AttFilterUtils.cc/1.4/Wed Dec 13 15:50:06 2006//Tgeant4-09-04-ref-00
    2 /G4AxesModel.cc/1.6/Thu Jun 29 21:32:38 2006//Tgeant4-09-04-ref-00
    3 /G4BoundingSphereScene.cc/1.11/Thu Jun 29 21:32:40 2006//Tgeant4-09-04-ref-00
    4 /G4DigiFilterFactories.cc/1.1/Sun May 30 11:24:30 2010//Tgeant4-09-04-ref-00
    5 /G4DigiModel.cc/1.1/Sun May 30 11:24:30 2010//Tgeant4-09-04-ref-00
    6 /G4FlavoredParallelWorldModel.cc/1.7/Thu Jun 29 21:32:42 2006//Tgeant4-09-04-ref-00
    7 /G4HitFilterFactories.cc/1.2/Sun May 30 11:24:03 2010//Tgeant4-09-04-ref-00
    8 /G4HitsModel.cc/1.18/Tue Nov 14 14:42:08 2006//Tgeant4-09-04-ref-00
    9 /G4LogicalVolumeModel.cc/1.14/Wed Nov  1 10:28:42 2006//Tgeant4-09-04-ref-00
    10 /G4ModelingParameters.cc/1.16/Tue May 11 11:13:35 2010//Tgeant4-09-04-ref-00
    11 /G4NullModel.cc/1.9/Thu Jun 29 21:32:50 2006//Tgeant4-09-04-ref-00
    12 /G4PSHitsModel.cc/1.4/Wed Nov  4 12:44:39 2009//Tgeant4-09-04-ref-00
    13 /G4PhysicalVolumeMassScene.cc/1.7/Mon Nov  6 09:24:13 2006//Tgeant4-09-04-ref-00
    14 /G4PhysicalVolumeModel.cc/1.68/Fri Nov  5 15:19:29 2010//Tgeant4-09-04-ref-00
    15 /G4PhysicalVolumeSearchScene.cc/1.14/Sun Jul 27 10:49:24 2008//Tgeant4-09-04-ref-00
    16 /G4ScaleModel.cc/1.4/Thu Jun 29 21:32:58 2006//Tgeant4-09-04-ref-00
    17 /G4TextModel.cc/1.7/Thu Jun 29 21:33:00 2006//Tgeant4-09-04-ref-00
    18 /G4TrajectoriesModel.cc/1.25/Tue May 11 11:21:52 2010//Tgeant4-09-04-ref-00
    19 /G4TrajectoryChargeFilter.cc/1.4/Fri Aug 25 19:44:14 2006//Tgeant4-09-04-ref-00
    20 /G4TrajectoryDrawByAttribute.cc/1.5/Fri May 28 02:00:59 2010//Tgeant4-09-04-ref-00
    21 /G4TrajectoryDrawByCharge.cc/1.10/Fri May 28 02:00:59 2010//Tgeant4-09-04-ref-00
    22 /G4TrajectoryDrawByOriginVolume.cc/1.6/Fri May 28 02:00:59 2010//Tgeant4-09-04-ref-00
    23 /G4TrajectoryDrawByParticleID.cc/1.11/Tue Jun  1 21:17:41 2010//Tgeant4-09-04-ref-00
    24 /G4TrajectoryDrawerUtils.cc/1.15/dummy timestamp from new-entry//Tgeant4-09-04-ref-00
    25 /G4TrajectoryFilterFactories.cc/1.5/Tue Sep 12 18:53:03 2006//Tgeant4-09-04-ref-00
    26 /G4TrajectoryGenericDrawer.cc/1.3/Tue May 11 11:31:31 2010//Tgeant4-09-04-ref-00
    27 /G4TrajectoryModelFactories.cc/1.7/Tue Sep 12 18:53:03 2006//Tgeant4-09-04-ref-00
    28 /G4TrajectoryOriginVolumeFilter.cc/1.3/Fri Aug 25 19:44:14 2006//Tgeant4-09-04-ref-00
    29 /G4TrajectoryParticleFilter.cc/1.3/Fri Aug 25 19:44:14 2006//Tgeant4-09-04-ref-00
    30 /G4VModel.cc/1.14/Wed Nov  1 10:33:00 2006//Tgeant4-09-04-ref-00
    31 /G4VTrajectoryModel.cc/1.3/Thu Jun 29 21:33:26 2006//Tgeant4-09-04-ref-00
    32 /G4VisTrajContext.cc/1.6/Tue Feb 24 12:00:56 2009//Tgeant4-09-04-ref-00
     1/G4AttFilterUtils.cc/1.4/Wed Dec 13 15:50:06 2006//
     2/G4AxesModel.cc/1.6/Thu Jun 29 21:32:38 2006//
     3/G4BoundingSphereScene.cc/1.11/Thu Jun 29 21:32:40 2006//
     4/G4DigiFilterFactories.cc/1.1/Sun May 30 11:24:30 2010//
     5/G4DigiModel.cc/1.1/Sun May 30 11:24:30 2010//
     6/G4FlavoredParallelWorldModel.cc/1.7/Thu Jun 29 21:32:42 2006//
     7/G4HitFilterFactories.cc/1.2/Sun May 30 11:24:03 2010//
     8/G4HitsModel.cc/1.18/Tue Nov 14 14:42:08 2006//
     9/G4LogicalVolumeModel.cc/1.14/Wed Nov  1 10:28:42 2006//
     10/G4ModelingParameters.cc/1.16/Tue May 11 11:13:35 2010//
     11/G4NullModel.cc/1.9/Thu Jun 29 21:32:50 2006//
     12/G4PSHitsModel.cc/1.4/Wed Nov  4 12:44:39 2009//
     13/G4PhysicalVolumeMassScene.cc/1.7/Mon Nov  6 09:24:13 2006//
     14/G4PhysicalVolumeModel.cc/1.68/Fri Nov  5 15:19:29 2010//
     15/G4PhysicalVolumeSearchScene.cc/1.14/Sun Jul 27 10:49:24 2008//
     16/G4ScaleModel.cc/1.4/Thu Jun 29 21:32:58 2006//
     17/G4TextModel.cc/1.7/Thu Jun 29 21:33:00 2006//
     18/G4TrajectoriesModel.cc/1.25/Tue May 11 11:21:52 2010//
     19/G4TrajectoryChargeFilter.cc/1.4/Fri Aug 25 19:44:14 2006//
     20/G4TrajectoryDrawByAttribute.cc/1.6/Mon Jan  3 14:39:15 2011//
     21/G4TrajectoryDrawByCharge.cc/1.10/Fri May 28 02:00:59 2010//
     22/G4TrajectoryDrawByOriginVolume.cc/1.6/Fri May 28 02:00:59 2010//
     23/G4TrajectoryDrawByParticleID.cc/1.11/Tue Jun  1 21:17:41 2010//
     24/G4TrajectoryDrawerUtils.cc/1.16/Result of merge//
     25/G4TrajectoryFilterFactories.cc/1.5/Tue Sep 12 18:53:03 2006//
     26/G4TrajectoryGenericDrawer.cc/1.3/Tue May 11 11:31:31 2010//
     27/G4TrajectoryModelFactories.cc/1.7/Tue Sep 12 18:53:03 2006//
     28/G4TrajectoryOriginVolumeFilter.cc/1.3/Fri Aug 25 19:44:14 2006//
     29/G4TrajectoryParticleFilter.cc/1.3/Fri Aug 25 19:44:14 2006//
     30/G4VModel.cc/1.14/Wed Nov  1 10:33:00 2006//
     31/G4VTrajectoryModel.cc/1.3/Thu Jun 29 21:33:26 2006//
     32/G4VisTrajContext.cc/1.6/Tue Feb 24 12:00:56 2009//
    3333D

  • trunk/source/visualization/modeling/src/G4TrajectoryDrawByAttribute.cc

    r1346 r1348  
    2424// ********************************************************************
    2525//
    26 // $Id: G4TrajectoryDrawByAttribute.cc,v 1.5 2010/05/28 02:00:59 allison Exp $
     26// $Id: G4TrajectoryDrawByAttribute.cc,v 1.6 2010/12/11 16:41:11 allison Exp $
    2727// GEANT4 tag $Name:  $
    2828//
    … …  
    9797    // Expect definition to exist   
    9898    if (!G4AttUtils::ExtractAttDef(object, fAttName, attDef)) {
    99       std::ostringstream o;
    100       o <<"Unable to extract attribute definition named "<<fAttName;
    101       G4Exception
    102         ("G4TrajectoryDrawByAttribute::Draw", "InvalidAttributeDefinition", FatalErrorInArgument, o.str().c_str());
     99      static G4bool warnedUnableToExtract = false;
     100      if (!warnedUnableToExtract) {
     101        std::ostringstream o;
     102        o <<"Unable to extract attribute definition named "<<fAttName;
     103        G4Exception
     104          ("G4TrajectoryDrawByAttribute::Draw", "InvalidAttributeDefinition", JustWarning, o.str().c_str());
     105        G4cout << "Available attributes:\n"
     106               << object.GetAttDefs();
     107        warnedUnableToExtract = true;
     108      }
     109      return;
    103110    }
    104111   
    … …  
    127134  // Expect value to exist
    128135  if (!G4AttUtils::ExtractAttValue(object, fAttName, attVal)) {
     136    static G4bool warnedUnableToExtract = false;
     137    if (!warnedUnableToExtract) {
    129138      std::ostringstream o;
    130139      o <<"Unable to extract attribute value named "<<fAttName;
    131140      G4Exception
    132         ("G4TrajectoryDrawByAttribute::Draw", "InvalidAttributeValue", FatalErrorInArgument, o.str().c_str());
     141        ("G4TrajectoryDrawByAttribute::Draw", "InvalidAttributeValue", JustWarning, o.str().c_str());
     142        G4cout << "Available attributes:\n"
     143               << object.GetAttDefs();
     144      warnedUnableToExtract = true;
     145    }
     146      return;
    133147  }
    134148 

  • trunk/source/visualization/modeling/src/G4TrajectoryDrawerUtils.cc

    r1346 r1348  
    2424// ********************************************************************
    2525//
    26 // $Id: G4TrajectoryDrawerUtils.cc,v 1.15 2010/11/14 22:13:55 allison Exp $
     26// $Id: G4TrajectoryDrawerUtils.cc,v 1.16 2010/12/11 16:40:16 allison Exp $
    2727// GEANT4 tag $Name:  $
    2828//
    … …  
    4444namespace G4TrajectoryDrawerUtils {
    4545
    46 
    47   void GetPoints(const G4VTrajectory& traj,
    48                  G4Polyline& trajectoryLine,
    49                  G4Polymarker& auxiliaryPoints,
    50                  G4Polymarker& stepPoints)
    51   {
     46  enum TimesValidity {InvalidTimes, ValidTimes};
     47
     48  TimesValidity GetPointsAndTimes
     49  (const G4VTrajectory& traj,
     50   const G4VisTrajContext& context,
     51   G4Polyline& trajectoryLine,
     52   G4Polymarker& auxiliaryPoints,
     53   G4Polymarker& stepPoints,
     54   std::vector<G4double>& trajectoryLineTimes,
     55   std::vector<G4double>& auxiliaryPointTimes,
     56   std::vector<G4double>& stepPointTimes)
     57  {
     58    TimesValidity validity = InvalidTimes;
     59    if (context.GetTimeSliceInterval()) validity = ValidTimes;
     60
     61    // Memory for last trajectory point position for auxiliary point
     62    // time interpolation algorithm.  There are no auxiliary points
     63    // for the first trajectory point, so its initial value is
     64    // immaterial.
     65    G4ThreeVector lastTrajectoryPointPosition;
     66
    5267    // Keep positions.  Don't store unless first or different.
    5368    std::vector<G4ThreeVector> positions;
    … …  
    6277      if (positions.size() == 0 ||
    6378          trajectoryPointPosition != positions[positions.size()-1]) {
     79
     80        // Pre- and Post-Point times from the trajectory point...
     81        G4double trajectoryPointPreTime = -std::numeric_limits<double>::max();
     82        G4double trajectoryPointPostTime = std::numeric_limits<double>::max();
     83
     84        if (context.GetTimeSliceInterval() && validity == ValidTimes) {
     85
     86          std::vector<G4AttValue>* trajectoryPointAttValues =
     87            aTrajectoryPoint->CreateAttValues();
     88          if (!trajectoryPointAttValues) {
     89            static G4bool warnedNoAttValues = false;
     90            if (!warnedNoAttValues) {
     91              G4cout <<
     92  "*************************************************************************"
     93  "\n*  WARNING: G4TrajectoryDrawerUtils::GetPointsAndTimes: no att values."
     94  "\n*************************************************************************"
     95                     << G4endl;
     96              warnedNoAttValues = true;
     97            }
     98            validity = InvalidTimes;
     99          } else {
     100            G4bool foundPreTime = false, foundPostTime = false;
     101            for (std::vector<G4AttValue>::iterator i =
     102                   trajectoryPointAttValues->begin();
     103                 i != trajectoryPointAttValues->end(); ++i) {
     104              if (i->GetName() == "PreT") {
     105                trajectoryPointPreTime =
     106                  G4UIcommand::ConvertToDimensionedDouble(i->GetValue());
     107                foundPreTime = true;
     108              }
     109              if (i->GetName() == "PostT") {
     110                trajectoryPointPostTime =
     111                  G4UIcommand::ConvertToDimensionedDouble(i->GetValue());
     112                foundPostTime = true;
     113              }
     114            }
     115            if (!foundPreTime || !foundPostTime) {
     116              static G4bool warnedTimesNotFound = false;
     117              if (!warnedTimesNotFound) {
     118                G4cout <<
     119  "*************************************************************************"
     120  "\n*  WARNING: G4TrajectoryDrawerUtils::GetPointsAndTimes: times not found."
     121  "\n*************************************************************************"
     122                       << G4endl;
     123                warnedTimesNotFound = true;
     124              }
     125              validity = InvalidTimes;
     126            }
     127          }
     128        }
    64129
    65130        const std::vector<G4ThreeVector>* auxiliaries
    … …  
    74139              trajectoryLine.push_back(auxPointPosition);
    75140              auxiliaryPoints.push_back(auxPointPosition);
     141              if (validity == ValidTimes) {
     142                // Interpolate time for auxiliary points...
     143                const G4ThreeVector& auxPointPosition = (*auxiliaries)[iAux];
     144                G4double s1 =
     145                  (auxPointPosition - lastTrajectoryPointPosition).mag();
     146                G4double s2 =
     147                  (trajectoryPointPosition - auxPointPosition).mag();
     148                G4double t = trajectoryPointPreTime +
     149                  (trajectoryPointPostTime - trajectoryPointPreTime) *
     150                  (s1 / (s1 + s2));
     151                trajectoryLineTimes.push_back(t);
     152                auxiliaryPointTimes.push_back(t);
     153              }
    76154            }
    77155          }
    … …  
    81159        trajectoryLine.push_back(trajectoryPointPosition);
    82160        stepPoints.push_back(trajectoryPointPosition);
    83       }
    84     }   
     161        if (validity == ValidTimes) {
     162          trajectoryLineTimes.push_back(trajectoryPointPostTime);
     163          stepPointTimes.push_back(trajectoryPointPostTime);
     164        }
     165        lastTrajectoryPointPosition = trajectoryPointPosition;
     166      }
     167    }
     168    return validity;   
    85169  }
    86170
    … …  
    476560    if (!context.GetDrawLine() && !context.GetDrawAuxPts() && !context.GetDrawStepPts()) return;
    477561   
    478     // Get points to draw
     562    // Get points and times (times are returned only if time-slicing
     563    // is requested).
    479564    G4Polyline trajectoryLine;
    480565    G4Polymarker stepPoints;
    481566    G4Polymarker auxiliaryPoints;
    482    
    483     GetPoints(traj, trajectoryLine, auxiliaryPoints, stepPoints);
    484    
    485     if (context.GetTimeSliceInterval()) {
    486 
    487       // Get corresponding track time information, if any
    488       std::vector<G4double> trajectoryLineTimes;
    489       std::vector<G4double> stepPointTimes;
    490       std::vector<G4double> auxiliaryPointTimes;
    491  
    492       GetTimes(traj, trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
    493 
    494       // Check validity
    495       if (trajectoryLineTimes.size() != trajectoryLine.size() ||
    496           stepPointTimes.size() != stepPoints.size() ||
    497           auxiliaryPointTimes.size() != auxiliaryPoints.size()) {
    498 
    499         // Revert to drawing without time information...
    500         DrawWithoutTime(context, trajectoryLine, auxiliaryPoints, stepPoints);
    501       } else {
    502 
    503         SliceLine(context.GetTimeSliceInterval(),
    504                   trajectoryLine, trajectoryLineTimes);
    505 
    506         DrawWithTime(context,
    507                      trajectoryLine, auxiliaryPoints, stepPoints,
    508                      trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
    509       }
     567    std::vector<G4double> trajectoryLineTimes;
     568    std::vector<G4double> stepPointTimes;
     569    std::vector<G4double> auxiliaryPointTimes;
     570
     571    TimesValidity validity = GetPointsAndTimes
     572      (traj, context,
     573       trajectoryLine, auxiliaryPoints, stepPoints,
     574       trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
     575   
     576    if (validity == ValidTimes) {
     577
     578      SliceLine(context.GetTimeSliceInterval(),
     579                trajectoryLine, trajectoryLineTimes);
     580
     581      DrawWithTime(context,
     582                   trajectoryLine, auxiliaryPoints, stepPoints,
     583                   trajectoryLineTimes, auxiliaryPointTimes, stepPointTimes);
    510584
    511585    } else {
Note: See TracChangeset for help on using the changeset viewer.