00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031 #include "globals.hh"
00032 #include "G3VolTableEntry.hh"
00033 #include "G3VolTable.hh"
00034 #include "G3RotTable.hh"
00035 #include "G4LogicalVolume.hh"
00036 #include "G4SubtractionSolid.hh"
00037 #include "G3Pos.hh"
00038 #include "G3toG4.hh"
00039
00040 G3VolTableEntry::G3VolTableEntry(G4String& vname, G4String& shape,
00041 G4double* rpar, G4int npar, G4int nmed,
00042 G4VSolid* solid, G4bool hasNegPars)
00043 : fVname(vname), fShape(shape), fRpar(0), fNpar(npar), fNmed(nmed),
00044 fSolid(solid), fLV(0), fHasNegPars(hasNegPars), fHasMANY(false),
00045 fDivision(0)
00046 {
00047 if (npar>0 && rpar!=0) {
00048 fRpar = new G4double[npar];
00049 for (G4int i=0; i<npar; i++) fRpar[i] = rpar[i];
00050 }
00051 fClones.push_back(this);
00052 }
00053
00054 G3VolTableEntry::~G3VolTableEntry(){
00055 if (fRpar!=0) delete [] fRpar;
00056 delete fDivision;
00057 }
00058
00059 inline G4bool
00060 G3VolTableEntry::operator == ( const G3VolTableEntry& lv) const {
00061 return (this==&lv) ? true : false;
00062 }
00063
00064 void
00065 G3VolTableEntry::AddG3Pos(G3Pos* aG3Pos){
00066
00067
00068 G3Vol.CountG3Pos();
00069 fG3Pos.push_back(aG3Pos);
00070
00071
00072 G4String vonly = aG3Pos->GetOnly();
00073 if (vonly == "MANY") SetHasMANY(true);
00074 }
00075
00076 void
00077 G3VolTableEntry::AddDaughter(G3VolTableEntry* aDaughter){
00078 if (FindDaughter(aDaughter->GetName()) == 0) {
00079 fDaughters.push_back(aDaughter);
00080 }
00081 }
00082
00083 void
00084 G3VolTableEntry::AddMother(G3VolTableEntry* itsMother){
00085 if (FindMother(itsMother->GetName()) == 0) {
00086 fMothers.push_back(itsMother);
00087 }
00088 }
00089
00090 void
00091 G3VolTableEntry::AddClone(G3VolTableEntry* itsClone){
00092 if (FindClone(itsClone->GetName()) == 0) {
00093 fClones.push_back(itsClone);
00094 }
00095 }
00096
00097 void
00098 G3VolTableEntry::AddOverlap(G3VolTableEntry* overlap){
00099 fOverlaps.push_back(overlap);
00100 }
00101
00102 void
00103 G3VolTableEntry::ReplaceDaughter(G3VolTableEntry* vteOld,
00104 G3VolTableEntry* vteNew)
00105 {
00106 G4int index = -1;
00107 for (G4int i=0; i<GetNoDaughters(); i++){
00108 if (fDaughters[i]->GetName() == vteOld->GetName()) index = i;
00109 }
00110 if (index<0) {
00111 G4String err_message = "Old daughter " + vteOld->GetName()
00112 + " does not exist.";
00113 G4Exception("G3VolTableEntry::ReplaceDaughter()", "G3toG40007",
00114 FatalException, err_message);
00115 return;
00116 }
00117 fDaughters[index] = vteNew;
00118 }
00119
00120 void
00121 G3VolTableEntry::ReplaceMother(G3VolTableEntry* vteOld,
00122 G3VolTableEntry* vteNew)
00123 {
00124 G4int index = -1;
00125 for (G4int i=0; i<GetNoMothers(); i++){
00126 if (fMothers[i]->GetName() == vteOld->GetName()) index = i;
00127 }
00128 if (index<0) {
00129 G4String err_message = "Old mother " + vteOld->GetName()
00130 + " does not exist.";
00131 G4Exception("G3VolTableEntry::ReplaceMother()", "G3toG40008",
00132 FatalException, err_message);
00133 return;
00134 }
00135 fMothers[index] = vteNew;
00136 }
00137
00138 G3VolTableEntry*
00139 G3VolTableEntry::FindDaughter(const G4String& Dname){
00140 for (G4int idau=0; idau<GetNoDaughters(); idau++){
00141 if (GetDaughter(idau)->GetName() == Dname) return GetDaughter(idau);
00142 }
00143 return 0;
00144 }
00145
00146 G3VolTableEntry*
00147 G3VolTableEntry::FindMother(const G4String& Mname){
00148 for (G4int i=0; i<GetNoMothers(); i++){
00149 G3VolTableEntry* mvte = GetMother(i);
00150 if (mvte->GetName() == Mname) return mvte;
00151 }
00152 return 0;
00153 }
00154
00155 G3VolTableEntry*
00156 G3VolTableEntry::FindClone(const G4String& Cname){
00157 for (G4int i=0; i<GetNoClones(); i++){
00158 G3VolTableEntry* cvte = GetClone(i);
00159 if (cvte->GetName() == Cname) return cvte;
00160 }
00161 return 0;
00162 }
00163
00164 void G3VolTableEntry::PrintSolidInfo() {
00165
00166
00167 G4cout << "VTE: " << fVname << " " << this << G4endl;
00168 G4cout << "Solid: " << fSolid << G4endl;
00169 G4cout << "Parameters (npar = " << fNpar << ") fRpar: ";
00170 for (G4int i=0; i<fNpar; i++) G4cout << fRpar[i] << " ";
00171 G4cout << G4endl;
00172 G4cout << "HasNegPars: " << fHasNegPars << G4endl;
00173 G4cout << "HasMANY: " << fHasMANY << G4endl;
00174 G4cout << "================================= " << G4endl;
00175 }
00176
00177 void
00178 G3VolTableEntry::SetName(G4String name){
00179 fVname = name;
00180 }
00181
00182 void
00183 G3VolTableEntry::SetLV(G4LogicalVolume* lv){
00184 fLV = lv;
00185 }
00186
00187 void
00188 G3VolTableEntry::SetSolid(G4VSolid* solid){
00189 fSolid = solid;
00190 }
00191
00192 void G3VolTableEntry::SetNmed(G4int nmed) {
00193 fNmed = nmed;
00194 }
00195
00196 void G3VolTableEntry::SetNRpar(G4int npar, G4double* rpar) {
00197 if (npar != fNpar) {
00198 fNpar = npar;
00199 delete [] fRpar;
00200 fRpar = new G4double[fNpar];
00201 }
00202 for (G4int i=0; i<fNpar; i++) fRpar[i] = rpar[i];
00203 }
00204
00205 void G3VolTableEntry::SetHasNegPars(G4bool hasNegPars) {
00206 fHasNegPars = hasNegPars;
00207 }
00208
00209 void G3VolTableEntry::SetHasMANY(G4bool hasMANY) {
00210 fHasMANY = hasMANY;
00211 }
00212
00213 void G3VolTableEntry::ClearG3PosCopy(G4int copy) {
00214 if (fG3Pos.size()>0 && copy>=0 && copy<G4int(fG3Pos.size())) {
00215 std::vector<G3Pos*>::iterator it=fG3Pos.begin();
00216 for(G4int j=0;j<copy;j++) it++;
00217 if(it!=fG3Pos.end()) {
00218 fG3Pos.erase(it);
00219 }
00220 }
00221 }
00222
00223 void G3VolTableEntry::ClearDivision() {
00224 delete fDivision;
00225 fDivision = 0;
00226 }
00227
00228 G4String
00229 G3VolTableEntry::GetName() {
00230 return fVname;
00231 }
00232
00233 G4String
00234 G3VolTableEntry::GetShape() {
00235 return fShape;
00236 }
00237
00238 G4int
00239 G3VolTableEntry::GetNmed() {
00240 return fNmed;
00241 }
00242
00243 G4int
00244 G3VolTableEntry::GetNpar() {
00245 return fNpar;
00246 }
00247
00248 G4double*
00249 G3VolTableEntry::GetRpar() {
00250 return fRpar;
00251 }
00252
00253 G4int
00254 G3VolTableEntry::NPCopies() {
00255 return fG3Pos.size();
00256 }
00257
00258 G3Pos*
00259 G3VolTableEntry::GetG3PosCopy(G4int copy) {
00260 if (fG3Pos.size()>0 && copy>=0)
00261 return fG3Pos[copy];
00262 else
00263 return 0;
00264 }
00265
00266 G4bool
00267 G3VolTableEntry::HasNegPars(){
00268 return fHasNegPars;
00269 }
00270
00271 G4bool
00272 G3VolTableEntry::HasMANY(){
00273 return fHasMANY;
00274 }
00275
00276 G4VSolid*
00277 G3VolTableEntry::GetSolid() {
00278 return fSolid;
00279 }
00280
00281 G4LogicalVolume*
00282 G3VolTableEntry::GetLV() {
00283 return fLV;
00284 }
00285
00286 G4int
00287 G3VolTableEntry::GetNoDaughters() {
00288 return fDaughters.size();
00289 }
00290
00291 G4int
00292 G3VolTableEntry::GetNoMothers() {
00293 return fMothers.size();
00294 }
00295
00296 G4int
00297 G3VolTableEntry::GetNoClones() {
00298 return fClones.size();
00299 }
00300
00301 G4int
00302 G3VolTableEntry::GetNoOverlaps() {
00303 return fOverlaps.size();
00304 }
00305
00306 G3VolTableEntry*
00307 G3VolTableEntry::GetDaughter(G4int i) {
00308 if (i<G4int(fDaughters.size()) && i>=0)
00309 return fDaughters[i];
00310 else
00311 return 0;
00312 }
00313
00314 G3VolTableEntry*
00315 G3VolTableEntry::GetMother(G4int i){
00316 if (i<G4int(fMothers.size()) && i>=0)
00317 return fMothers[i];
00318 else
00319 return 0;
00320 }
00321
00322
00323 G3VolTableEntry*
00324 G3VolTableEntry::GetMother(){
00325 if (fMothers.size()>0)
00326 return fMothers[0];
00327 else
00328 return 0;
00329 }
00330
00331 G3VolTableEntry*
00332 G3VolTableEntry::GetClone(G4int i){
00333 if (i<G4int(fClones.size()) && i>=0)
00334 return fClones[i];
00335 else
00336 return 0;
00337 }
00338
00339 G3VolTableEntry*
00340 G3VolTableEntry::GetMasterClone(){
00341 G3VolTableEntry* master;
00342 G4String name = fVname;
00343 if (name.contains(gSeparator)) {
00344 name = name(0, name.first(gSeparator));
00345 master = G3Vol.GetVTE(name);
00346 }
00347 else
00348 master = this;
00349
00350 return master;
00351 }
00352
00353 std::vector<G3VolTableEntry*>*
00354 G3VolTableEntry::GetOverlaps(){
00355 return &fOverlaps;
00356 }