lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 6.2.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 10:56:29 +02:00
parent 1d812b78b1
commit e083ffb441
1415 changed files with 111223 additions and 21207 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/visualization/HepRep/src/DefaultHepRep.cc
+13 -21
View File
@@ -8,10 +8,10 @@ DefaultHepRep::DefaultHepRep() {
}
DefaultHepRep::~DefaultHepRep() {
for (vector<HepRepTypeTree*>::iterator i1 = typeTrees.begin(); i1 != typeTrees.end(); i1++) {
for (set<HepRepTypeTree*>::iterator i1 = typeTrees.begin(); i1 != typeTrees.end(); i1++) {
delete (*i1);
}
for (vector<HepRepInstanceTree*>::iterator i2 = instanceTrees.begin(); i2 != instanceTrees.end(); i2++) {
for (set<HepRepInstanceTree*>::iterator i2 = instanceTrees.begin(); i2 != instanceTrees.end(); i2++) {
delete (*i2);
}
}
@@ -21,18 +21,16 @@ HepRep* DefaultHepRep::copy(HepRepSelectFilter*) {
return NULL;
}
vector<string>* DefaultHepRep::getLayerOrder() {
return &layers;
vector<string> DefaultHepRep::getLayerOrder() {
return layers;
}
bool DefaultHepRep::addLayer(string layer) {
void DefaultHepRep::addLayer(string layer) {
layers.push_back(layer);
return true;
}
bool DefaultHepRep::addTypeTree(HepRepTypeTree* typeTree) {
typeTrees.push_back(typeTree);
return true;
void DefaultHepRep::addTypeTree(HepRepTypeTree* typeTree) {
typeTrees.insert(typeTree);
}
void DefaultHepRep::removeTypeTree(HepRepTypeTree*) {
@@ -44,18 +42,12 @@ HepRepTypeTree* DefaultHepRep::getTypeTree(string, string) {
return NULL;
}
vector<HepRepTypeTree*>* DefaultHepRep::getTypeTrees() {
return &typeTrees;
set<HepRepTypeTree*> DefaultHepRep::getTypeTrees() {
return typeTrees;
}
HepRepType* DefaultHepRep::getType(string) {
cerr << "DefaultHepRep::getType(string) not implemented." << endl;
return NULL;
}
bool DefaultHepRep::addInstanceTree(HepRepInstanceTree* instanceTree) {
instanceTrees.push_back(instanceTree);
return true;
void DefaultHepRep::addInstanceTree(HepRepInstanceTree* instanceTree) {
instanceTrees.insert(instanceTree);
}
void DefaultHepRep::overlayInstanceTree(HepRepInstanceTree *) {
@@ -94,7 +86,7 @@ string DefaultHepRep::checkForException() {
return NULL;
}
vector<HepRepInstanceTree*>* DefaultHepRep::getInstanceTrees() {
return &instanceTrees;
set<HepRepInstanceTree*> DefaultHepRep::getInstanceTrees() {
return instanceTrees;
}
source/visualization/HepRep/src/DefaultHepRepAttribute.cc
+19 -22
View File
@@ -16,56 +16,53 @@ DefaultHepRepAttribute::~DefaultHepRepAttribute() {
for (map<string, HepRepAttValue*>::iterator i = attValues.begin(); i != attValues.end(); i++) {
delete (*i).second;
}
attList.clear();
}
vector<HepRepAttValue*>* DefaultHepRepAttribute::getAttValuesFromNode() {
attList.clear();
set<HepRepAttValue*> DefaultHepRepAttribute::getAttValuesFromNode() {
set<HepRepAttValue*> attSet;
for (map<string, HepRepAttValue*>::iterator i = attValues.begin(); i != attValues.end(); i++) {
if ((*i).first != "layer") attList.push_back((*i).second);
if ((*i).first != "layer") attSet.insert((*i).second);
}
return &attList;
return attSet;
}
bool DefaultHepRepAttribute::addAttValue(HepRepAttValue* hepRepAttValue) {
void DefaultHepRepAttribute::addAttValue(HepRepAttValue* hepRepAttValue) {
string lowerCaseName = hepRepAttValue->getLowerCaseName();
if (attValues[lowerCaseName] != NULL) delete attValues[lowerCaseName];
attValues[lowerCaseName] = hepRepAttValue;
return true;
}
bool DefaultHepRepAttribute::addAttValue(string key, char *value, int showLabel) {
return addAttValue(key, (std::string)value, showLabel);
void DefaultHepRepAttribute::addAttValue(string key, char *value, int showLabel) {
addAttValue(key, (std::string)value, showLabel);
}
bool DefaultHepRepAttribute::addAttValue(string key, string value, int showLabel) {
return addAttValue(new DefaultHepRepAttValue(key, value, showLabel));
void DefaultHepRepAttribute::addAttValue(string key, string value, int showLabel) {
addAttValue(new DefaultHepRepAttValue(key, value, showLabel));
}
bool DefaultHepRepAttribute::addAttValue(string key, int value, int showLabel) {
return addAttValue(new DefaultHepRepAttValue(key, value, showLabel));
void DefaultHepRepAttribute::addAttValue(string key, int value, int showLabel) {
addAttValue(new DefaultHepRepAttValue(key, value, showLabel));
}
bool DefaultHepRepAttribute::addAttValue(string key, double value, int showLabel) {
return addAttValue(new DefaultHepRepAttValue(key, value, showLabel));
void DefaultHepRepAttribute::addAttValue(string key, double value, int showLabel) {
addAttValue(new DefaultHepRepAttValue(key, value, showLabel));
}
bool DefaultHepRepAttribute::addAttValue(string key, bool value, int showLabel) {
return addAttValue(new DefaultHepRepAttValue(key, value, showLabel));
void DefaultHepRepAttribute::addAttValue(string key, bool value, int showLabel) {
addAttValue(new DefaultHepRepAttValue(key, value, showLabel));
}
bool DefaultHepRepAttribute::addAttValue(string key, vector<double> value, int showLabel) {
return addAttValue(new DefaultHepRepAttValue(key, value, showLabel));
void DefaultHepRepAttribute::addAttValue(string key, vector<double> value, int showLabel) {
addAttValue(new DefaultHepRepAttValue(key, value, showLabel));
}
bool DefaultHepRepAttribute::addAttValue(string key, double red, double green, double blue, double alpha, int showLabel) {
void DefaultHepRepAttribute::addAttValue(string key, double red, double green, double blue, double alpha, int showLabel) {
vector<double> color;
color.push_back(red);
color.push_back(green);
color.push_back(blue);
color.push_back(alpha);
return addAttValue(new DefaultHepRepAttValue(key, color, showLabel));
addAttValue(new DefaultHepRepAttValue(key, color, showLabel));
}
HepRepAttValue* DefaultHepRepAttribute::getAttValueFromNode(string name) {
source/visualization/HepRep/src/DefaultHepRepDefinition.cc
+9 -10
View File
@@ -13,29 +13,28 @@ DefaultHepRepDefinition::DefaultHepRepDefinition()
}
DefaultHepRepDefinition::~DefaultHepRepDefinition() {
vector<HepRepAttDef *>* list = getAttDefsFromNode();
for (vector<HepRepAttDef*>::iterator i1 = list->begin(); i1 != list->end(); i1++) {
set<HepRepAttDef *> list = getAttDefsFromNode();
for (set<HepRepAttDef*>::iterator i1 = list.begin(); i1 != list.end(); i1++) {
delete (*i1);
}
}
vector<HepRepAttDef *>* DefaultHepRepDefinition::getAttDefsFromNode() {
attList.clear();
set<HepRepAttDef *> DefaultHepRepDefinition::getAttDefsFromNode() {
set<HepRepAttDef*> attSet;
for (map<string, HepRepAttDef*>::iterator i = attDefs.begin(); i != attDefs.end(); i++) {
attList.push_back((*i).second);
attSet.insert((*i).second);
}
return &attList;
return attSet;
}
bool DefaultHepRepDefinition::addAttDef(HepRepAttDef* hepRepAttDef) {
void DefaultHepRepDefinition::addAttDef(HepRepAttDef* hepRepAttDef) {
string lowerCaseName = hepRepAttDef->getLowerCaseName();
if (attDefs[lowerCaseName] != NULL) delete attDefs[lowerCaseName];
attDefs[lowerCaseName] = hepRepAttDef;
return true;
}
bool DefaultHepRepDefinition::addAttDef(string name, string desc, string type, string extra) {
return addAttDef(new DefaultHepRepAttDef(name, desc, type, extra));
void DefaultHepRepDefinition::addAttDef(string name, string desc, string type, string extra) {
addAttDef(new DefaultHepRepAttDef(name, desc, type, extra));
}
HepRepAttDef* DefaultHepRepDefinition::getAttDefFromNode(string name) {
source/visualization/HepRep/src/DefaultHepRepFactory.cc
+4
View File
@@ -67,6 +67,10 @@ HepRepType* DefaultHepRepFactory::createHepRepType (HepRepType* parent, string n
return new DefaultHepRepType(parent, name);
}
HepRepType* DefaultHepRepFactory::createHepRepType (HepRepTypeTree* parent, string name) {
return new DefaultHepRepType(parent, name);
}
HepRepTypeTree* DefaultHepRepFactory::createHepRepTypeTree (HepRepTreeID* treeID) {
return new DefaultHepRepTypeTree(treeID);
}
source/visualization/HepRep/src/DefaultHepRepInstance.cc
+17 -15
View File
@@ -10,14 +10,14 @@ DefaultHepRepInstance::DefaultHepRepInstance(HepRepInstance* instance, HepRepTyp
: DefaultHepRepAttribute(), parent(instance), type(heprepType) {
if (type == NULL) cerr << "HepRepInstance cannot be created without a HepRepType." << endl;
((HepRepInstance*)parent)->addInstance(this);
parent->addInstance(this);
}
DefaultHepRepInstance::DefaultHepRepInstance(HepRepInstanceTree* instanceTree, HepRepType* heprepType)
: DefaultHepRepAttribute(), parent(instanceTree), type(heprepType) {
: DefaultHepRepAttribute(), parent(NULL), type(heprepType) {
if (type == NULL) cerr << "HepRepInstance cannot be created without a HepRepType." << endl;
((HepRepInstanceTree*)parent)->addInstance(this);
instanceTree->addInstance(this);
}
DefaultHepRepInstance::~DefaultHepRepInstance() {
@@ -35,13 +35,13 @@ void DefaultHepRepInstance::overlay(HepRepInstance *) {
cerr << "DefaultHepRepInstance::overlay(HepRepInstance * instance) not implemented." << endl;
}
HepRepInstance* DefaultHepRepInstance::copy(HepRep*, HepRepInstance*, HepRepSelectFilter*) {
cerr << "DefaultHepRepInstance::copy(HepRep*, HepRepInstance*, HepRepSelectFilter*) not implemented." << endl;
HepRepInstance* DefaultHepRepInstance::copy(HepRepTypeTree*, HepRepInstance*, HepRepSelectFilter*) {
cerr << "DefaultHepRepInstance::copy(HepRepTypeTree*, HepRepInstance*, HepRepSelectFilter*) not implemented." << endl;
return NULL;
}
HepRepInstance* DefaultHepRepInstance::copy(HepRep*, HepRepInstanceTree*, HepRepSelectFilter*) {
cerr << "DefaultHepRepInstance::copy(HepRep*, HepRepInstanceTree*, HepRepSelectFilter*) not implemented." << endl;
HepRepInstance* DefaultHepRepInstance::copy(HepRepTypeTree*, HepRepInstanceTree*, HepRepSelectFilter*) {
cerr << "DefaultHepRepInstance::copy(HepRepTypeTree*, HepRepInstanceTree*, HepRepSelectFilter*) not implemented." << endl;
return NULL;
}
@@ -49,26 +49,28 @@ HepRepType* DefaultHepRepInstance::getType() {
return type;
}
bool DefaultHepRepInstance::addPoint(HepRepPoint* point) {
void DefaultHepRepInstance::addPoint(HepRepPoint* point) {
points.push_back(point);
return true;
}
vector<HepRepPoint*>* DefaultHepRepInstance::getPoints() {
return &points;
vector<HepRepPoint*> DefaultHepRepInstance::getPoints() {
return points;
}
bool DefaultHepRepInstance::addInstance(HepRepInstance* instance) {
HepRepInstance* DefaultHepRepInstance::getSuperInstance() {
return parent;
}
void DefaultHepRepInstance::addInstance(HepRepInstance* instance) {
instances.push_back(instance);
return true;
}
void DefaultHepRepInstance::removeInstance(HepRepInstance*) {
cerr << "DefaultHepRepInstance::removeInstance(HepRepInstance*) not implemented." << endl;
}
vector<HepRepInstance*>* DefaultHepRepInstance::getInstances() {
return &instances;
vector<HepRepInstance*> DefaultHepRepInstance::getInstances() {
return instances;
}
HepRepAttValue* DefaultHepRepInstance::getAttValue(string name) {
source/visualization/HepRep/src/DefaultHepRepInstanceTree.cc
+9 -15
View File
@@ -19,38 +19,32 @@ void DefaultHepRepInstanceTree::overlay(HepRepInstanceTree *) {
cerr << "DefaultHepRepInstanceTree::overlay(HepRepInstanceTree * instanceTree) not implemented." << endl;
}
HepRepTreeID* DefaultHepRepInstanceTree::copy() {
return DefaultHepRepTreeID::copy();
}
HepRepInstanceTree* DefaultHepRepInstanceTree::copy(HepRep*, HepRepSelectFilter*) {
cerr << "DefaultHepRepInstanceTree::copy(HepRep*, HepRepSelectFilter*) not implemented." << endl;
HepRepInstanceTree* DefaultHepRepInstanceTree::copy(HepRepTypeTree*, HepRepSelectFilter*) {
cerr << "DefaultHepRepInstanceTree::copy(HepRepTypeTree*, HepRepSelectFilter*) not implemented." << endl;
return NULL;
}
bool DefaultHepRepInstanceTree::addInstance(HepRepInstance* instance) {
void DefaultHepRepInstanceTree::addInstance(HepRepInstance* instance) {
instances.push_back(instance);
return true;
}
void DefaultHepRepInstanceTree::removeInstance(HepRepInstance*) {
cerr << "DefaultHepRepInstanceTree::removeInstance(HepRepInstance*) not implemented." << endl;
}
vector<HepRepInstance*>* DefaultHepRepInstanceTree::getInstances() {
return &instances;
vector<HepRepInstance*> DefaultHepRepInstanceTree::getInstances() {
return instances;
}
bool DefaultHepRepInstanceTree::addInstanceTree(HepRepTreeID* treeID) {
instanceTrees.push_back(treeID);
return true;
void DefaultHepRepInstanceTree::addInstanceTree(HepRepTreeID* treeID) {
instanceTrees.insert(treeID);
}
HepRepTreeID* DefaultHepRepInstanceTree::getTypeTree() {
return typeTree;
}
vector<HepRepTreeID*>* DefaultHepRepInstanceTree::getInstanceTrees() {
return &instanceTrees;
set<HepRepTreeID*> DefaultHepRepInstanceTree::getInstanceTrees() {
return instanceTrees;
}
source/visualization/HepRep/src/DefaultHepRepTreeID.cc
-5
View File
@@ -28,8 +28,3 @@ string DefaultHepRepTreeID::getName() {
string DefaultHepRepTreeID::getVersion() {
return version;
}
HepRepTreeID* DefaultHepRepTreeID::copy() {
return new DefaultHepRepTreeID(name, version, qualifier);
}
source/visualization/HepRep/src/DefaultHepRepType.cc
+15 -8
View File
@@ -15,8 +15,16 @@ DefaultHepRepType::DefaultHepRepType(HepRepType* parentType, string typeName)
}
}
DefaultHepRepType::DefaultHepRepType(HepRepTypeTree* parentTypeTree, string typeName)
: DefaultHepRepDefinition(), parent(NULL), name(typeName) {
this->description = "No Description";
this->infoURL = "No Info URL";
parentTypeTree->addType(this);
}
DefaultHepRepType::~DefaultHepRepType() {
for (vector<HepRepType*>::iterator i1 = types.begin(); i1 != types.end(); i1++) {
for (set<HepRepType*>::iterator i1 = types.begin(); i1 != types.end(); i1++) {
delete (*i1);
}
}
@@ -56,8 +64,8 @@ HepRepAttValue* DefaultHepRepType::getAttValue(string attName) {
return value;
}
HepRepType* DefaultHepRepType::copy(HepRep*, HepRepType*) {
cerr << "DefaultHepRepType::copy(HepRep*, HepRepType*) not implemented." << endl;
HepRepType* DefaultHepRepType::copy(HepRepType*) {
cerr << "DefaultHepRepType::copy(HepRepType*) not implemented." << endl;
return NULL;
}
@@ -85,12 +93,11 @@ void DefaultHepRepType::setInfoURL(string info) {
this->infoURL = info;
}
bool DefaultHepRepType::addType(HepRepType* type) {
types.push_back(type);
return true;
void DefaultHepRepType::addType(HepRepType* type) {
types.insert(type);
}
vector<HepRepType*>* DefaultHepRepType::getTypes() {
return &types;
set<HepRepType*> DefaultHepRepType::getTypes() {
return types;
}
source/visualization/HepRep/src/DefaultHepRepTypeTree.cc
+11 -12
View File
@@ -12,26 +12,25 @@ DefaultHepRepTypeTree::DefaultHepRepTypeTree(HepRepTreeID* typeTree)
}
DefaultHepRepTypeTree::~DefaultHepRepTypeTree() {
for (vector<HepRepType*>::iterator i1 = types.begin(); i1 != types.end(); i1++) {
for (set<HepRepType*>::iterator i1 = types.begin(); i1 != types.end(); i1++) {
delete (*i1);
}
}
HepRepTreeID* DefaultHepRepTypeTree::copy() {
return DefaultHepRepTreeID::copy();
}
HepRepTypeTree* DefaultHepRepTypeTree::copy(HepRep*) {
cerr << "DefaultHepRepTypeTree::copy(HepRep*) not implemented." << endl;
HepRepTypeTree* DefaultHepRepTypeTree::copy() {
cerr << "DefaultHepRepTypeTree::copy() not implemented." << endl;
return NULL;
}
bool DefaultHepRepTypeTree::addType(HepRepType* type) {
types.push_back(type);
return true;
void DefaultHepRepTypeTree::addType(HepRepType* type) {
types.insert(type);
}
vector<HepRepType*>* DefaultHepRepTypeTree::getTypes() {
return &types;
set<HepRepType*> DefaultHepRepTypeTree::getTypes() {
return types;
}
HepRepType* DefaultHepRepTypeTree::getType(string /*typeName*/) {
cerr << "DefaultHepRepTypeTree::getType(string) not implemented." << endl;
return NULL;
}
source/visualization/HepRep/src/G4HepRep.cc
+3 -3
View File
@@ -20,8 +20,8 @@
// * statement, and all its terms. *
// ********************************************************************
//
// $Id: G4HepRep.cc,v 1.20 2003/12/11 21:55:55 duns Exp $
// GEANT4 tag $Name: geant4-06-00-patch-01 $
// $Id: G4HepRep.cc,v 1.21 2004/05/27 05:55:20 duns Exp $
// GEANT4 tag $Name: geant4-06-02 $
//
/**
@@ -71,7 +71,7 @@ G4VViewer* G4HepRep::CreateViewer (G4VSceneHandler& scene, const G4String& name)
cout << "G4HepRep::CreateViewer: Cannot create more than one G4HepRepViewer" << endl;
return NULL;
}
viewer = new G4HepRepViewer ((G4HepRepSceneHandler&)scene, name);
viewer = new G4HepRepViewer ((G4HepRepSceneHandler&)scene, *messenger, name);
return viewer;
}
source/visualization/HepRep/src/G4HepRepFileSceneHandler.cc
+6 -2
View File
@@ -20,8 +20,8 @@
// * statement, and all its terms. *
// ********************************************************************
//
// $Id: G4HepRepFileSceneHandler.cc,v 1.18 2004/03/15 08:00:22 perl Exp $
// GEANT4 tag $Name: geant4-06-01 $
// $Id: G4HepRepFileSceneHandler.cc,v 1.19 2004/05/28 04:59:54 perl Exp $
// GEANT4 tag $Name: geant4-06-02 $
//
//
// Joseph Perl 27th January 2002
@@ -674,6 +674,8 @@ void G4HepRepFileSceneHandler::AddHepRepInstance(const char* primName,
// Additional attributes.
hepRepXMLWriter->addAttValue("Layer",hepRepXMLWriter->typeDepth);
hepRepXMLWriter->addAttValue("LVol", fpCurrentLV->GetName());
hepRepXMLWriter->addAttValue("Region", fpCurrentLV->GetRegion()->GetName());
hepRepXMLWriter->addAttValue("RootRegion", fpCurrentLV->IsRootRegion());
hepRepXMLWriter->addAttValue("Solid", fpCurrentLV->GetSolid()->GetName());
hepRepXMLWriter->addAttValue("EType", fpCurrentLV->GetSolid()->GetEntityType());
hepRepXMLWriter->addAttValue("Material", fpCurrentLV->GetMaterial()->GetName());
@@ -731,6 +733,8 @@ void G4HepRepFileSceneHandler::CheckFileOpen() {
fileCounter++;
hepRepXMLWriter->addAttDef("LVol", "Logical Volume", "Physics","");
hepRepXMLWriter->addAttDef("Region", "Cuts Region", "Physics","");
hepRepXMLWriter->addAttDef("RootRegion", "Root Region", "Physics","");
hepRepXMLWriter->addAttDef("Solid", "Solid Name", "Physics","");
hepRepXMLWriter->addAttDef("EType", "Entity Type", "Physics","");
hepRepXMLWriter->addAttDef("Material", "Material Name", "Physics","");
source/visualization/HepRep/src/G4HepRepMessenger.cc
+22 -9
View File
@@ -20,8 +20,8 @@
// * statement, and all its terms. *
// ********************************************************************
//
// $Id: G4HepRepMessenger.cc,v 1.4 2003/12/11 21:55:55 duns Exp $
// GEANT4 tag $Name: geant4-06-00-patch-01 $
// $Id: G4HepRepMessenger.cc,v 1.6 2004/05/27 05:55:20 duns Exp $
// GEANT4 tag $Name: geant4-06-02 $
//
#include "G4HepRepMessenger.hh"
@@ -39,35 +39,42 @@ G4HepRepMessenger::G4HepRepMessenger() :
setEventNumberSuffixCommand->SetDefaultValue("");
setEventNumberSuffixCommand->AvailableForStates(G4State_Idle);
/*
appendGeometryCommand = new G4UIcmdWithABool("/vis/heprep/appendGeometry", this);
appendGeometryCommand->SetGuidance("Appends copy of geometry to every event.");
appendGeometryCommand->SetParameterName("flag",false);
appendGeometryCommand->SetDefaultValue(true);
appendGeometryCommand->AvailableForStates(G4State_Idle);
*/
addPointAttributesCommand = new G4UIcmdWithABool("/vis/heprep/addPointAttributes", this);
addPointAttributesCommand->SetGuidance("Adds point attributes to the points of trajectories.");
addPointAttributesCommand->SetParameterName("flag",false);
addPointAttributesCommand->SetDefaultValue(false);
addPointAttributesCommand->AvailableForStates(G4State_Idle);
setCoordinateSystemCommand = new G4UIcmdWithAString("/vis/heprep/setCoordinateSystem", this);
setCoordinateSystemCommand->SetGuidance("Sets the prefered Coordinate System (e.g. \"xyz\" or \"zxy\".");
setCoordinateSystemCommand->SetParameterName("coordinateSystem",false);
setCoordinateSystemCommand->SetDefaultValue("xyz");
setCoordinateSystemCommand->AvailableForStates(G4State_Idle);
}
G4HepRepMessenger::~G4HepRepMessenger() {
delete setEventNumberSuffixCommand;
// delete appendGeometryCommand;
delete appendGeometryCommand;
delete addPointAttributesCommand;
delete heprepDirectory;
delete setCoordinateSystemCommand;
}
G4String G4HepRepMessenger::GetCurrentValue(G4UIcommand * command) {
if (command==setEventNumberSuffixCommand) {
return suffix;
// } else if (command==appendGeometryCommand) {
// return appendGeometryCommand->ConvertToString(geometry);
} else if (command==appendGeometryCommand) {
return appendGeometryCommand->ConvertToString(geometry);
} else if (command==addPointAttributesCommand) {
return addPointAttributesCommand->ConvertToString(pointAttributes);
} else if (command==setCoordinateSystemCommand) {
return coordinateSystem;
} else {
return "";
}
@@ -76,10 +83,12 @@ G4String G4HepRepMessenger::GetCurrentValue(G4UIcommand * command) {
void G4HepRepMessenger::SetNewValue(G4UIcommand * command, G4String newValue) {
if (command==setEventNumberSuffixCommand) {
suffix = newValue;
// } else if (command==appendGeometryCommand) {
// geometry = appendGeometryCommand->GetNewBoolValue(newValue);
} else if (command==appendGeometryCommand) {
geometry = appendGeometryCommand->GetNewBoolValue(newValue);
} else if (command==addPointAttributesCommand) {
pointAttributes = addPointAttributesCommand->GetNewBoolValue(newValue);
} else if (command==setCoordinateSystemCommand) {
coordinateSystem = newValue;
}
}
@@ -94,3 +103,7 @@ G4bool G4HepRepMessenger::appendGeometry() {
G4bool G4HepRepMessenger::addPointAttributes() {
return pointAttributes;
}
G4String G4HepRepMessenger::getCoordinateSystem() {
return coordinateSystem;
}
source/visualization/HepRep/src/G4HepRepSceneHandler.cc
+136 -39
View File
@@ -20,8 +20,8 @@
// * statement, and all its terms. *
// ********************************************************************
//
// $Id: G4HepRepSceneHandler.cc,v 1.70 2004/02/05 18:41:49 duns Exp $
// GEANT4 tag $Name: geant4-06-00-patch-01 $
// $Id: G4HepRepSceneHandler.cc,v 1.76 2004/05/28 04:59:54 perl Exp $
// GEANT4 tag $Name: geant4-06-02 $
//
/**
@@ -43,6 +43,8 @@
#include "HEPREP/HepRep.h"
//G4
#include "G4Vector3D.hh"
#include "G4RunManagerKernel.hh"
#include "G4Types.hh"
#include "G4Point3D.hh"
#include "G4Normal3D.hh"
@@ -78,6 +80,7 @@ using namespace std;
G4int G4HepRepSceneHandler::sceneCount = 0;
//#define LDEBUG 1
//#define SDEBUG 1
//#define PDEBUG 1
@@ -100,10 +103,11 @@ G4HepRepSceneHandler::G4HepRepSceneHandler (G4VGraphicsSystem& system, G4HepRepM
currentDepth (0),
currentPV (0),
currentLV (0),
_heprep (NULL)
_heprep (NULL),
_heprepGeometry (NULL)
{
#ifdef SDEBUG
#ifdef LDEBUG
cout << "G4HepRepSceneHandler::G4HepRepSceneHandler: " << system << endl;
#endif
@@ -121,7 +125,7 @@ G4HepRepSceneHandler::G4HepRepSceneHandler (G4VGraphicsSystem& system, G4HepRepM
G4HepRepSceneHandler::~G4HepRepSceneHandler () {
#ifdef SDEBUG
#ifdef LDEBUG
cout << "G4HepRepSceneHandler::~G4HepRepSceneHandler() " << endl;
#endif
close();
@@ -137,7 +141,7 @@ void G4HepRepSceneHandler::open(G4String name) {
if (writer != NULL) return;
if (name == "stdout") {
#ifdef SDEBUG
#ifdef LDEBUG
cout << "G4HepRepSceneHandler::Open() stdout" << endl;
#endif
writer = factory->createHepRepWriter(&cout, false, false);
@@ -150,7 +154,7 @@ void G4HepRepSceneHandler::open(G4String name) {
eventNumber = 0;
eventNumberWidth = 0;
} else if (name == "stderr") {
#ifdef SDEBUG
#ifdef LDEBUG
cout << "G4HepRepSceneHandler::Open() stderr" << endl;
#endif
writer = factory->createHepRepWriter(&cerr, false, false);
@@ -163,7 +167,7 @@ void G4HepRepSceneHandler::open(G4String name) {
eventNumber = 0;
eventNumberWidth = 0;
} else {
#ifdef SDEBUG
#ifdef LDEBUG
cout << "G4HepRepSceneHandler::Open() " << name << endl;
#endif
if (eventNumberWidth < 0) {
@@ -231,13 +235,14 @@ void G4HepRepSceneHandler::open(G4String name) {
void G4HepRepSceneHandler::openHepRep() {
#ifdef SDEBUG
#ifdef LDEBUG
cout << "G4HepRepSceneHandler::OpenHepRep() " << endl;
#endif
if (_heprep != NULL) return;
// all done on demand, once pointers are set to NULL
_heprepGeometry = NULL;
_geometryInstanceTree = NULL;
_geometryRootInstance = NULL;
_geometryInstance.clear();
@@ -262,7 +267,7 @@ void G4HepRepSceneHandler::openHepRep() {
bool G4HepRepSceneHandler::closeHepRep(bool final) {
if (_heprep == NULL) return true;
#ifdef SDEBUG
#ifdef LDEBUG
cout << "G4HepRepSceneHandler::CloseHepRep() start" << endl;
#endif
@@ -278,10 +283,21 @@ bool G4HepRepSceneHandler::closeHepRep(bool final) {
// using DrawView() called from /vis/viewer/flush)
if (_eventInstanceTree != NULL) {
GetCurrentViewer()->DrawView();
// couple geometry to event if geometry was written
if ((_geometryInstanceTree != NULL)) {
getEventInstanceTree()->addInstanceTree(getGeometryInstanceTree());
// couple geometry
if (messenger.appendGeometry()) {
// couple geometry to event if geometry was written
if ((_geometryInstanceTree != NULL)) {
getEventInstanceTree()->addInstanceTree(getGeometryInstanceTree());
}
} else {
char name[128];
if (writeMultipleFiles) {
sprintf(name, "%s%s%s#%s", baseName.c_str(), "-geometry", extension.c_str(), "G4GeometryData");
} else {
sprintf(name, "%s%s#%s", "geometry", ".heprep", "G4GeometryData");
}
getEventInstanceTree()->addInstanceTree(factory->createHepRepTreeID(name, "1.0"));
}
}
@@ -296,16 +312,31 @@ bool G4HepRepSceneHandler::closeHepRep(bool final) {
// Give this HepRep all of the layer order info for both geometry and event,
// since these will both end up in a single HepRep.
if (_geometryRootType != NULL) _heprep->addLayer(geometryLayer);
if (_eventType != NULL) _heprep->addLayer(eventLayer);
if (_calHitType != NULL) _heprep->addLayer(calHitLayer);
if (_trajectoryType != NULL) _heprep->addLayer(trajectoryLayer);
if (_hitType != NULL) _heprep->addLayer(hitLayer);
writeLayers(_heprepGeometry);
writeLayers(_heprep);
// open heprep file
if (writer == NULL) {
open((GetScene() == NULL) ? G4String("G4HepRepOutput.heprep.zip") : GetScene()->GetName());
}
// write out separate geometry
if (!messenger.appendGeometry() && (_heprepGeometry != NULL)) {
if (writeMultipleFiles) {
char fileName[128];
sprintf(fileName, "%s%s%s", baseName.c_str(), "-geometry", extension.c_str());
openFile(G4String(fileName));
}
if (!writeMultipleFiles) writer->addProperty("RecordLoop.ignore", "geometry.heprep");
writer->write(_heprepGeometry, G4String("geometry.heprep"));
delete _heprepGeometry;
_heprepGeometry = NULL;
if (writeMultipleFiles) closeFile();
}
if (writeMultipleFiles) {
// NOTE: does not work on Solaris 5.2 and Linux 2.95.2
@@ -346,16 +377,19 @@ bool G4HepRepSceneHandler::closeHepRep(bool final) {
void G4HepRepSceneHandler::close() {
#ifdef SDEBUG
#ifdef LDEBUG
cout << "G4HepRepSceneHandler::Close() " << endl;
#endif
if (writer == NULL) return;
if (!writeMultipleFiles) {
closeHepRep(true);
closeFile();
}
G4HepRepViewer* viewer = dynamic_cast<G4HepRepViewer*>(GetCurrentViewer());
viewer->reset();
}
void G4HepRepSceneHandler::openFile(G4String name) {
@@ -372,6 +406,14 @@ void G4HepRepSceneHandler::closeFile() {
out = NULL;
}
void G4HepRepSceneHandler::writeLayers(HepRep* heprep) {
if (heprep == NULL) return;
heprep->addLayer(geometryLayer);
heprep->addLayer(eventLayer);
heprep->addLayer(calHitLayer);
heprep->addLayer(trajectoryLayer);
heprep->addLayer(hitLayer);
}
void G4HepRepSceneHandler::EstablishSpecials(G4PhysicalVolumeModel& model) {
#ifdef SDEBUG
@@ -937,6 +979,43 @@ bool G4HepRepSceneHandler::isEventData () {
return !currentPV || fReadyForTransients;
}
void G4HepRepSceneHandler::addTopLevelAttributes(HepRepType* type) {
// Some non-standard attributes
type->addAttDef( "Generator", "Generator of the file", "General", "");
type->addAttValue("Generator", G4String("Geant4"));
type->addAttDef( "GeneratorVersion", "Version of the Generator", "General", "");
type->addAttValue("GeneratorVersion", G4RunManagerKernel::GetRunManagerKernel()->GetVersionString());
type->addAttDef( "CoordinateSystem", "Coordinate System", "Draw", "");
type->addAttValue("CoordinateSystem", messenger.getCoordinateSystem());
const G4ViewParameters parameters = GetCurrentViewer()->GetViewParameters();
const G4Vector3D& viewPointDirection = parameters.GetViewpointDirection();
type->addAttDef( "ViewTheta", "Theta of initial suggested viewpoint", "Draw", "rad");
type->addAttValue("ViewTheta", viewPointDirection.theta());
type->addAttDef( "ViewPhi", "Phi of initial suggested viewpoint", "Draw", "rad");
type->addAttValue("ViewPhi", viewPointDirection.phi());
type->addAttDef( "ViewScale", "Scale of initial suggested viewpoint", "Draw", "");
type->addAttValue("ViewScale", parameters.GetZoomFactor());
// FIXME, no way to set these
type->addAttDef( "ViewTranslateX", "Translate in X of initial suggested viewpoint", "Draw", "");
type->addAttValue("ViewTranslateX", 0.0);
type->addAttDef( "ViewTranslateY", "Translate in Y of initial suggested viewpoint", "Draw", "");
type->addAttValue("ViewTranslateY", 0.0);
type->addAttDef( "ViewTranslateZ", "Translate in Z of initial suggested viewpoint", "Draw", "");
type->addAttValue("ViewTranslateZ", 0.0);
type->addAttDef( "PointUnit", "Length", "Physics", "");
type->addAttValue("PointUnit", G4String("m"));
}
HepRep* G4HepRepSceneHandler::getHepRep() {
if (_heprep == NULL) {
// Create the HepRep that holds the Trees.
@@ -945,11 +1024,23 @@ HepRep* G4HepRepSceneHandler::getHepRep() {
return _heprep;
}
HepRep* G4HepRepSceneHandler::getHepRepGeometry() {
if (_heprepGeometry == NULL) {
// Create the HepRep that holds the Trees.
_heprepGeometry = factory->createHepRep();
}
return _heprepGeometry;
}
HepRepInstanceTree* G4HepRepSceneHandler::getGeometryInstanceTree() {
if (_geometryInstanceTree == NULL) {
// Create the Geometry InstanceTree.
_geometryInstanceTree = factory->createHepRepInstanceTree("G4GeometryData", "1.0", getGeometryTypeTree());
getHepRep()->addInstanceTree(_geometryInstanceTree);
if (messenger.appendGeometry()) {
getHepRep()->addInstanceTree(_geometryInstanceTree);
} else {
getHepRepGeometry()->addInstanceTree(_geometryInstanceTree);
}
}
return _geometryInstanceTree;
}
@@ -965,12 +1056,14 @@ HepRepInstance* G4HepRepSceneHandler::getGeometryRootInstance() {
HepRepInstance* G4HepRepSceneHandler::getGeometryInstance(G4LogicalVolume* volume, int depth) {
HepRepInstance* instance = getGeometryInstance(volume->GetName(), depth);
setAttribute(instance, "LVol", volume->GetName());
setAttribute(instance, "Solid", volume->GetSolid()->GetName());
setAttribute(instance, "EType", volume->GetSolid()->GetEntityType());
setAttribute(instance, "Material", volume->GetMaterial()->GetName());
setAttribute(instance, "Density", volume->GetMaterial()->GetDensity());
setAttribute(instance, "Radlen", volume->GetMaterial()->GetRadlen());
setAttribute(instance, "LVol", volume->GetName());
setAttribute(instance, "Region", volume->GetRegion()->GetName());
setAttribute(instance, "RootRegion", volume->IsRootRegion());
setAttribute(instance, "Solid", volume->GetSolid()->GetName());
setAttribute(instance, "EType", volume->GetSolid()->GetEntityType());
setAttribute(instance, "Material", volume->GetMaterial()->GetName());
setAttribute(instance, "Density", volume->GetMaterial()->GetDensity());
setAttribute(instance, "Radlen", volume->GetMaterial()->GetRadlen());
G4String state = materialState[volume->GetMaterial()->GetState()];
setAttribute(instance, "State", state);
@@ -1004,7 +1097,11 @@ HepRepTypeTree* G4HepRepSceneHandler::getGeometryTypeTree() {
// Create the Geometry TypeTree.
HepRepTreeID* geometryTreeID = factory->createHepRepTreeID("G4GeometryTypes", "1.0");
_geometryTypeTree = factory->createHepRepTypeTree(geometryTreeID);
getHepRep()->addTypeTree(_geometryTypeTree);
if (messenger.appendGeometry()) {
getHepRep()->addTypeTree(_geometryTypeTree);
} else {
getHepRepGeometry()->addTypeTree(_geometryTypeTree);
}
}
return _geometryTypeTree;
}
@@ -1012,12 +1109,16 @@ HepRepTypeTree* G4HepRepSceneHandler::getGeometryTypeTree() {
HepRepType* G4HepRepSceneHandler::getGeometryRootType() {
if (_geometryRootType == NULL) {
// Create the top level Geometry Type.
_geometryRootType = factory->createHepRepType(NULL, rootVolumeName);
_geometryRootType = factory->createHepRepType(getGeometryTypeTree(), rootVolumeName);
_geometryRootType->addAttValue("Layer", geometryLayer);
// Add attdefs used by all geometry types.
_geometryRootType->addAttDef ("LVol", "Logical Volume", "Physics","");
_geometryRootType->addAttValue("LVol", G4String(""));
_geometryRootType->addAttDef ("Region", "Cuts Region", "Physics","");
_geometryRootType->addAttValue("Region", G4String(""));
_geometryRootType->addAttDef ("RootRegion", "Root Region", "Physics","");
_geometryRootType->addAttValue("RootRegion", false);
_geometryRootType->addAttDef ("Solid", "Solid Name", "Physics","");
_geometryRootType->addAttValue("Solid", G4String(""));
_geometryRootType->addAttDef ("EType", "Entity Type", "Physics","");
@@ -1042,9 +1143,9 @@ HepRepType* G4HepRepSceneHandler::getGeometryRootType() {
_geometryRootType->addAttValue("MarkSizeMultiplier", 4.0);
_geometryRootType->addAttValue("LineWidthMultiplier", 1.0);
getGeometryTypeTree()->addType(_geometryRootType);
addTopLevelAttributes(_geometryRootType);
_geometryType["/"+_geometryRootType->getName()] = _geometryRootType;
}
return _geometryRootType;
@@ -1129,7 +1230,7 @@ HepRepTypeTree* G4HepRepSceneHandler::getEventTypeTree() {
HepRepType* G4HepRepSceneHandler::getEventType() {
if (_eventType == NULL) {
// Create the top level Event Type.
_eventType = factory->createHepRepType(NULL, "Event");
_eventType = factory->createHepRepType(getEventTypeTree(), "Event");
_eventType->addAttValue("Layer", eventLayer);
// add defaults for Events
@@ -1144,11 +1245,7 @@ HepRepType* G4HepRepSceneHandler::getEventType() {
_eventType->addAttValue("MarkSizeMultiplier", 4.0);
_eventType->addAttValue("LineWidthMultiplier", 1.0);
// Some non-standard attributes
_eventType->addAttDef("PointUnit", "Length", "Physics", "");
_eventType->addAttValue("PointUnit", G4String("m"));
getEventTypeTree()->addType(_eventType);
addTopLevelAttributes(_eventType);
}
return _eventType;
source/visualization/HepRep/src/G4HepRepViewer.cc
+10 -5
View File
@@ -20,8 +20,8 @@
// * statement, and all its terms. *
// ********************************************************************
//
// $Id: G4HepRepViewer.cc,v 1.22 2003/12/11 21:55:55 duns Exp $
// GEANT4 tag $Name: geant4-06-00-patch-01 $
// $Id: G4HepRepViewer.cc,v 1.25 2004/05/27 05:59:08 duns Exp $
// GEANT4 tag $Name: geant4-06-02 $
//
/**
@@ -43,9 +43,10 @@
using namespace HEPREP;
using namespace std;
G4HepRepViewer::G4HepRepViewer (G4VSceneHandler& sceneHandler, const G4String& name)
G4HepRepViewer::G4HepRepViewer (G4VSceneHandler& sceneHandler, G4HepRepMessenger& heprepMessenger, const G4String& name)
: G4VViewer (sceneHandler, sceneHandler.IncrementViewCount(), name),
geometryIncluded(false) {
geometryIncluded(false),
messenger(heprepMessenger) {
#ifdef SDEBUG
cout << "G4HepRepViewer::G4HepRepViewer " << name << endl;
@@ -106,7 +107,7 @@ void G4HepRepViewer::ShowView () {
G4HepRepSceneHandler* sceneHandler = dynamic_cast<G4HepRepSceneHandler*>(GetSceneHandler());
if (sceneHandler->closeHepRep()) {
sceneHandler->openHepRep();
geometryIncluded = false;
if (messenger.appendGeometry()) geometryIncluded = false;
}
}
@@ -116,3 +117,7 @@ void G4HepRepViewer::FinishView () {
#endif
G4VViewer::FinishView();
}
void G4HepRepViewer::reset() {
geometryIncluded = false;
}
source/visualization/HepRep/src/XMLHepRepWriter.cc
+37 -24
View File
@@ -37,9 +37,22 @@ XMLHepRepWriter::~XMLHepRepWriter() {
delete xml;
}
bool XMLHepRepWriter::addProperty(std::string key, std::string value) {
properties[key] = value;
return true;
}
bool XMLHepRepWriter::close() {
xml->closeDoc(true);
if (zip != NULL) {
zip->putNextEntry(ZipCDirEntry("heprep.properties"));
map<string, string>::iterator i = properties.begin();
while (i != properties.end()) {
*zip << (*i).first << "=" << (*i).second << endl;
i++;
}
zip->closeEntry();
zip->finish();
zip->close();
}
@@ -58,15 +71,15 @@ bool XMLHepRepWriter::write(HepRep* heprep, string name) {
xml->openDoc();
xml->setAttribute("xmlns", "http://java.freehep.org/schemas/heprep/2.0");
xml->setAttribute("xmlns", "xsi", "http://www.w3.org/2001/XMLSchema-instance");
xml->setAttribute("xsi", "schemaLocation", "HepRep.xsd");
xml->setAttribute("xsi", "schemaLocation", "http://java.freehep.org/schemas/heprep/2.0 http://java.freehep.org/schemas/heprep/2.0/HepRep.xsd");
xml->openTag(nameSpace, "heprep");
write(heprep->getLayerOrder());
vector<HepRepTypeTree*>* typeTreeList = heprep->getTypeTrees();
for (vector<HepRepTypeTree*>::iterator i1=typeTreeList->begin(); i1 != typeTreeList->end(); i1++) {
set<HepRepTypeTree*> typeTreeSet = heprep->getTypeTrees();
for (set<HepRepTypeTree*>::iterator i1=typeTreeSet.begin(); i1 != typeTreeSet.end(); i1++) {
write(*i1);
}
vector<HepRepInstanceTree*>* instanceTreeList = heprep->getInstanceTrees();
for (vector<HepRepInstanceTree*>::iterator i2=instanceTreeList->begin(); i2 != instanceTreeList->end(); i2++) {
set<HepRepInstanceTree*> instanceTreeSet = heprep->getInstanceTrees();
for (set<HepRepInstanceTree*>::iterator i2=instanceTreeSet.begin(); i2 != instanceTreeSet.end(); i2++) {
write(*i2);
}
xml->closeTag();
@@ -78,10 +91,10 @@ bool XMLHepRepWriter::write(HepRep* heprep, string name) {
return true;
}
bool XMLHepRepWriter::write(vector<string> *layers) {
bool XMLHepRepWriter::write(vector<string> layers) {
string layerOrder = "";
bool comma = false;
for (vector<string>::iterator i=layers->begin(); i != layers->end(); i++) {
for (vector<string>::iterator i=layers.begin(); i != layers.end(); i++) {
if (comma) {
layerOrder.append(", ");
}
@@ -98,8 +111,8 @@ bool XMLHepRepWriter::write(HepRepTypeTree* typeTree) {
xml->setAttribute("version", typeTree->getVersion());
xml->openTag(nameSpace, "typetree");
vector<HepRepType*>* list = typeTree->getTypes();
for (vector<HepRepType*>::iterator i=list->begin(); i != list->end(); i++) {
set<HepRepType*> types = typeTree->getTypes();
for (set<HepRepType*>::iterator i=types.begin(); i != types.end(); i++) {
write(*i);
}
xml->closeTag();
@@ -112,8 +125,8 @@ bool XMLHepRepWriter::write(HepRepType* type) {
write((HepRepDefinition*)type);
write((HepRepAttribute*)type);
vector<HepRepType*>* list = type->getTypes();
for (vector<HepRepType*>::iterator i=list->begin(); i != list->end(); i++) {
set<HepRepType*> types = type->getTypes();
for (set<HepRepType*>::iterator i=types.begin(); i != types.end(); i++) {
write(*i);
}
xml->closeTag();
@@ -142,14 +155,14 @@ bool XMLHepRepWriter::write(HepRepInstanceTree* instanceTree) {
xml->setAttribute("typetreeversion", instanceTree->getTypeTree()->getVersion());
xml->openTag(nameSpace, "instancetree");
// refs
vector<HepRepTreeID*>* instanceTreeList = instanceTree->getInstanceTrees();
for (vector<HepRepTreeID*>::iterator i1=instanceTreeList->begin(); i1 != instanceTreeList->end(); i1++) {
set<HepRepTreeID*> instanceTreeSet = instanceTree->getInstanceTrees();
for (set<HepRepTreeID*>::iterator i1=instanceTreeSet.begin(); i1 != instanceTreeSet.end(); i1++) {
write(*i1);
}
// instances
vector<HepRepInstance*>* instanceList = instanceTree->getInstances();
for (vector<HepRepInstance*>::iterator i2=instanceList->begin(); i2 != instanceList->end(); i2++) {
vector<HepRepInstance*> instanceList = instanceTree->getInstances();
for (vector<HepRepInstance*>::iterator i2=instanceList.begin(); i2 != instanceList.end(); i2++) {
write(*i2);
}
xml->closeTag();
@@ -162,13 +175,13 @@ bool XMLHepRepWriter::write(HepRepInstance* instance) {
xml->openTag(nameSpace, "instance");
write((HepRepAttribute*)instance);
vector<HepRepPoint*>* pointList = instance->getPoints();
for (vector<HepRepPoint*>::iterator i1=pointList->begin(); i1 != pointList->end(); i1++) {
vector<HepRepPoint*> pointList = instance->getPoints();
for (vector<HepRepPoint*>::iterator i1=pointList.begin(); i1 != pointList.end(); i1++) {
write(*i1);
}
vector<HepRepInstance*>* instanceList = instance->getInstances();
for (vector<HepRepInstance*>::iterator i2=instanceList->begin(); i2 != instanceList->end(); i2++) {
vector<HepRepInstance*> instanceList = instance->getInstances();
for (vector<HepRepInstance*>::iterator i2=instanceList.begin(); i2 != instanceList.end(); i2++) {
write(*i2);
}
xml->closeTag();
@@ -179,7 +192,7 @@ bool XMLHepRepWriter::write(HepRepPoint* point) {
xml->setAttribute("x", point->getX());
xml->setAttribute("y", point->getY());
xml->setAttribute("z", point->getZ());
if (point->getAttValuesFromNode()->size() != 0) {
if (point->getAttValuesFromNode().size() != 0) {
xml->openTag(nameSpace, "point");
write((HepRepAttribute*)point);
xml->closeTag();
@@ -195,16 +208,16 @@ bool XMLHepRepWriter::write(HepRepAttribute* attribute) {
HepRepAttValue* layerAtt = attribute->getAttValueFromNode("layer");
if (layerAtt != NULL) write(layerAtt);
vector<HepRepAttValue*>* list = attribute->getAttValuesFromNode();
for (vector<HepRepAttValue*>::iterator i=list->begin(); i != list->end(); i++) {
set<HepRepAttValue*> attSet = attribute->getAttValuesFromNode();
for (set<HepRepAttValue*>::iterator i=attSet.begin(); i != attSet.end(); i++) {
write(*i);
}
return true;
}
bool XMLHepRepWriter::write(HepRepDefinition* definition) {
vector<HepRepAttDef*>* list = definition->getAttDefsFromNode();
for (vector<HepRepAttDef*>::iterator i=list->begin(); i != list->end(); i++) {
set<HepRepAttDef*> list = definition->getAttDefsFromNode();
for (set<HepRepAttDef*>::iterator i=list.begin(); i != list.end(); i++) {
write(*i);
}
return true;