g4sim: src/SimpleGeometryParameter.cc Source File

00001 //Description: In charge of SimpleGeometryParameter
00002 //Author: Wu Chen(wuchen@mail.ihep.ac.cn)
00003 //Created: 17 Oct, 2012
00004 //Modified: 11, Jan, 2013
00005 //          Support G4Hype, G4TwistedTube
00006 //Comment: The units are "mm"(default) and "rad". 
00007 //Comment: fVerboseLevel: 0:   Just Warning Messages and Error Messages
00008 //                        >=5: All informations
00009 //---------------------------------------------------------------------------//
00010 
00011 #include <iostream>
00012 #include <fstream>
00013 #include <string>
00014 #include <iomanip>
00015 
00016 #include "myglobals.hh"
00017 
00018 #include "SimpleGeometryParameterMessenger.hh"
00019 #include "MyVGeometryParameter.hh"
00020 
00021 #include "SimpleGeometryParameter.hh"
00022 
00023 SimpleGeometryParameter::SimpleGeometryParameter(G4String name, G4String opt )
00024         : MyVGeometryParameter(name, "S") // Use a not-empty opt to stop inherited class from creating new GeometryParameterMessenger
00025 {
00026         if ( opt == "" ){
00027                 SimpleGeometryParameterMessenger *pointer = new SimpleGeometryParameterMessenger(this, name);
00028                 //              std::cout<<"======>In SimpleGeometryParameter, new SimpleGeometryParameterMessenger at ("<<(void*)pointer<<")!"<<std::endl;
00029                 set_GeometryParameterMessenger(pointer);
00030         }
00031 }
00032 
00033 SimpleGeometryParameter::~SimpleGeometryParameter(){
00034         printf("~SimpleGeometryParameter");
00035 }
00036 
00037 //---------------------------InitFromFile---------------------------------
00038 //will be called in SimpleGeometrySvc::SetSimpleGeometry
00039 void SimpleGeometryParameter::InitFromFile( G4String file_name ){
00040 
00041         set_filename(file_name);
00042 
00043         //Remember to preset first!
00044         Preset();
00045 
00046         std::ifstream fin_card(file_name);
00047         if(!fin_card){
00048                 G4String content = "SimpleGeometryParameter::InitFromFile(), cannot find output card \"" + file_name + "\"";
00049                 DEBUG(content);
00050         }
00051         G4String s_card;
00052         while(getline(fin_card,s_card)){
00053                 //eleminate useless lines
00054                 if ( ISEMPTY(s_card) ) continue;
00055                 int status = GetValue(s_card);
00056                 if( status > 0 ){
00057                         G4String content = "SimpleGeometryParameter: unknown line:" + s_card + "\n  in file " + file_name + "! Will ignore this line!";
00058                         DEBUG(content,0);
00059                 }
00060         }
00061         fin_card.close();
00062         if (CheckInfo()){
00063                 DEBUG("SimpleGeometryParameter::InitFromFile(), insufficient simple solid info");
00064         }
00065         Calculate();
00066 }
00067 
00068 void SimpleGeometryParameter::Calculate(){
00069 //      std::cout<<"In SimpleGeometryParameter::Calculate"<<std::endl; // to be deleted
00070         MyVGeometryParameter::Calculate();
00071         for ( int VolId = 0; VolId < VolNo; VolId++ ){
00072                 std::vector<G4ThreeVector> tPos; tPos.clear();
00073                 std::vector<G4double> tEphi; tEphi.clear();
00074                 std::vector<G4double> tEtheta; tEtheta.clear();
00075                 std::vector<G4double> tEpsi; tEpsi.clear();
00076                 if (!SolidBoolean[VolId]){
00077                         for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00078                                 tEphi.push_back(CalFormula(fEphi[VolId],RepId)*deg);
00079                                 tEtheta.push_back(CalFormula(fEtheta[VolId],RepId)*deg);
00080                                 tEpsi.push_back(CalFormula(fEpsi[VolId],RepId)*deg);
00081                                 G4ThreeVector vec3temp(1,1,1);
00082                                 if (PosType[VolId]=="Cartesian"){
00083                                         vec3temp.setX(CalFormula(fPosX[VolId],RepId)*mm);
00084                                         vec3temp.setY(CalFormula(fPosY[VolId],RepId)*mm);
00085                                         vec3temp.setZ(CalFormula(fPosZ[VolId],RepId)*mm);
00086                                 }
00087                                 else if (PosType[VolId]=="Spherical"){
00088                                         vec3temp.setMag(CalFormula(fPosR[VolId],RepId)*mm);
00089                                         vec3temp.setTheta(CalFormula(fPosTheta[VolId],RepId)*deg);
00090                                         vec3temp.setPhi(CalFormula(fPosPhi[VolId],RepId)*deg);
00091                                 }
00092                                 else if (PosType[VolId]=="Polar"){
00093                                         vec3temp.setRho(CalFormula(fPosR[VolId],RepId)*mm);
00094                                         vec3temp.setZ(CalFormula(fPosZ[VolId],RepId)*mm);
00095                                         vec3temp.setPhi(CalFormula(fPosPhi[VolId],RepId)*deg);
00096                                 }
00097                                 tPos.push_back(vec3temp);
00098                         }
00099                 }
00100                 Pos.push_back(tPos);
00101                 Ephi.push_back(tEphi);
00102                 Etheta.push_back(tEtheta);
00103                 Epsi.push_back(tEpsi);
00104                 int SolId = SolidIndex[VolId];
00105                 if ( SolidType[VolId] == "BooleanSolid" ){
00106                         std::vector<G4double> tBooleanSolid_Ephi;
00107                         std::vector<G4double> tBooleanSolid_Etheta;
00108                         std::vector<G4double> tBooleanSolid_Epsi;
00109                         std::vector<G4ThreeVector> tBooleanSolid_Pos;
00110                         for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00111                                 tBooleanSolid_Ephi.push_back(CalFormula(fBooleanSolid_Ephi[SolId],RepId)*deg);
00112                                 tBooleanSolid_Etheta.push_back(CalFormula(fBooleanSolid_Etheta[SolId],RepId)*deg);
00113                                 tBooleanSolid_Epsi.push_back(CalFormula(fBooleanSolid_Epsi[SolId],RepId)*deg);
00114                                 G4ThreeVector vec3temp(1,1,1);
00115                                 if (BooleanSolid_PosType[SolId]=="Cartesian"){
00116                                         vec3temp.setX(CalFormula(fBooleanSolid_PosX[SolId],RepId)*mm);
00117                                         vec3temp.setY(CalFormula(fBooleanSolid_PosY[SolId],RepId)*mm);
00118                                         vec3temp.setZ(CalFormula(fBooleanSolid_PosZ[SolId],RepId)*mm);
00119                                 }
00120                                 else if (BooleanSolid_PosType[SolId]=="Spherical"){
00121                                         vec3temp.setMag(CalFormula(fBooleanSolid_PosR[SolId],RepId)*mm);
00122                                         vec3temp.setTheta(CalFormula(fBooleanSolid_PosTheta[SolId],RepId)*deg);
00123                                         vec3temp.setPhi(CalFormula(fBooleanSolid_PosPhi[SolId],RepId)*deg);
00124                                 }
00125                                 else if (BooleanSolid_PosType[SolId]=="Polar"){
00126                                         vec3temp.setRho(CalFormula(fBooleanSolid_PosR[SolId],RepId)*mm);
00127                                         vec3temp.setZ(CalFormula(fBooleanSolid_PosZ[SolId],RepId)*mm);
00128                                         vec3temp.setPhi(CalFormula(fBooleanSolid_PosPhi[SolId],RepId)*deg);
00129                                 }
00130                                 tBooleanSolid_Pos.push_back(vec3temp);
00131                         }
00132                         BooleanSolid_Ephi.push_back(tBooleanSolid_Ephi);
00133                         BooleanSolid_Etheta.push_back(tBooleanSolid_Etheta);
00134                         BooleanSolid_Epsi.push_back(tBooleanSolid_Epsi);
00135                         BooleanSolid_Pos.push_back(tBooleanSolid_Pos);
00136                 }
00137                 else if ( SolidType[VolId] == "Box" ){
00138                         std::vector<G4double> tBox_X; tBox_X.clear();
00139                         std::vector<G4double> tBox_Y; tBox_Y.clear();
00140                         std::vector<G4double> tBox_Z; tBox_Z.clear();
00141                         for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00142                                 tBox_X.push_back(CalFormula(fBox_X[SolId],RepId)*mm);
00143                                 tBox_Y.push_back(CalFormula(fBox_Y[SolId],RepId)*mm);
00144                                 tBox_Z.push_back(CalFormula(fBox_Z[SolId],RepId)*mm);
00145                         }
00146                         Box_X.push_back(tBox_X);
00147                         Box_Y.push_back(tBox_Y);
00148                         Box_Z.push_back(tBox_Z);
00149                 }
00150                 else if ( SolidType[VolId] == "EllipticalTube" ){
00151                         std::vector<G4double> tEllipticalTube_X; tEllipticalTube_X.clear();
00152                         std::vector<G4double> tEllipticalTube_Y; tEllipticalTube_Y.clear();
00153                         std::vector<G4double> tEllipticalTube_Z; tEllipticalTube_Z.clear();
00154                         for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00155                                 tEllipticalTube_X.push_back(CalFormula(fEllipticalTube_X[SolId],RepId)*mm);
00156                                 tEllipticalTube_Y.push_back(CalFormula(fEllipticalTube_Y[SolId],RepId)*mm);
00157                                 tEllipticalTube_Z.push_back(CalFormula(fEllipticalTube_Z[SolId],RepId)*mm);
00158                         }
00159                         EllipticalTube_X.push_back(tEllipticalTube_X);
00160                         EllipticalTube_Y.push_back(tEllipticalTube_Y);
00161                         EllipticalTube_Z.push_back(tEllipticalTube_Z);
00162                 }
00163                 else if ( SolidType[VolId] == "Tubs" ){
00164                         std::vector<G4double> tTubs_RMax;
00165                         std::vector<G4double> tTubs_RMin;
00166                         std::vector<G4double> tTubs_Length;
00167                         std::vector<G4double> tTubs_StartAng;
00168                         std::vector<G4double> tTubs_SpanAng;
00169                         for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00170                                 tTubs_RMax.push_back(CalFormula(fTubs_RMax[SolId],RepId)*mm);
00171                                 tTubs_RMin.push_back(CalFormula(fTubs_RMin[SolId],RepId)*mm);
00172                                 tTubs_Length.push_back(CalFormula(fTubs_Length[SolId],RepId)*mm);
00173                                 tTubs_StartAng.push_back(CalFormula(fTubs_StartAng[SolId],RepId)*deg);
00174                                 tTubs_SpanAng.push_back(CalFormula(fTubs_SpanAng[SolId],RepId)*deg);
00175                         }
00176                         Tubs_RMax.push_back(tTubs_RMax);
00177                         Tubs_RMin.push_back(tTubs_RMin);
00178                         Tubs_Length.push_back(tTubs_Length);
00179                         Tubs_StartAng.push_back(tTubs_StartAng);
00180                         Tubs_SpanAng.push_back(tTubs_SpanAng);
00181                 }
00182                 else if( SolidType[VolId] == "Torus" ){
00183                         std::vector<G4double> tTorus_RMax;
00184                         std::vector<G4double> tTorus_RMin;
00185                         std::vector<G4double> tTorus_Rtor;
00186                         std::vector<G4double> tTorus_StartAng;
00187                         std::vector<G4double> tTorus_SpanAng;
00188                         for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00189                                 tTorus_RMax.push_back(CalFormula(fTorus_RMax[SolId],RepId)*mm);
00190                                 tTorus_RMin.push_back(CalFormula(fTorus_RMin[SolId],RepId)*mm);
00191                                 tTorus_Rtor.push_back(CalFormula(fTorus_Rtor[SolId],RepId)*mm);
00192                                 tTorus_StartAng.push_back(CalFormula(fTorus_StartAng[SolId],RepId)*deg);
00193                                 tTorus_SpanAng.push_back(CalFormula(fTorus_SpanAng[SolId],RepId)*deg);
00194                         }
00195                         Torus_RMax.push_back(tTorus_RMax);
00196                         Torus_RMin.push_back(tTorus_RMin);
00197                         Torus_Rtor.push_back(tTorus_Rtor);
00198                         Torus_StartAng.push_back(tTorus_StartAng);
00199                         Torus_SpanAng.push_back(tTorus_SpanAng);
00200                 }
00201                 else if( SolidType[VolId] == "Sphere" ){
00202                         std::vector<G4double> tSphere_RMax;
00203                         std::vector<G4double> tSphere_RMin;
00204                         std::vector<G4double> tSphere_StartPhi;
00205                         std::vector<G4double> tSphere_SpanPhi;
00206                         std::vector<G4double> tSphere_StartTheta;
00207                         std::vector<G4double> tSphere_SpanTheta;
00208                         for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00209                                 tSphere_RMax.push_back(CalFormula(fSphere_RMax[SolId],RepId)*mm);
00210                                 tSphere_RMin.push_back(CalFormula(fSphere_RMin[SolId],RepId)*mm);
00211                                 tSphere_StartPhi.push_back(CalFormula(fSphere_StartPhi[SolId],RepId)*deg);
00212                                 tSphere_SpanPhi.push_back(CalFormula(fSphere_SpanPhi[SolId],RepId)*deg);
00213                                 tSphere_StartTheta.push_back(CalFormula(fSphere_StartTheta[SolId],RepId)*deg);
00214                                 tSphere_SpanTheta.push_back(CalFormula(fSphere_SpanTheta[SolId],RepId)*deg);
00215                         }
00216                         Sphere_RMax.push_back(tSphere_RMax);
00217                         Sphere_RMin.push_back(tSphere_RMin);
00218                         Sphere_StartPhi.push_back(tSphere_StartPhi);
00219                         Sphere_SpanPhi.push_back(tSphere_SpanPhi);
00220                         Sphere_StartTheta.push_back(tSphere_StartTheta);
00221                         Sphere_SpanTheta.push_back(tSphere_SpanTheta);
00222                 }
00223                 else if( SolidType[VolId] == "Hype" ){
00224                         std::vector<G4double> tHype_innerRadius;
00225                         std::vector<G4double> tHype_outerRadius;
00226                         std::vector<G4double> tHype_innerStereo;
00227                         std::vector<G4double> tHype_outerStereo;
00228                         std::vector<G4double> tHype_Length;
00229                         for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00230                                 tHype_innerRadius.push_back(CalFormula(fHype_innerRadius[SolId],RepId)*mm);
00231                                 tHype_outerRadius.push_back(CalFormula(fHype_outerRadius[SolId],RepId)*mm);
00232                                 tHype_innerStereo.push_back(CalFormula(fHype_innerStereo[SolId],RepId)*deg);
00233                                 tHype_outerStereo.push_back(CalFormula(fHype_outerStereo[SolId],RepId)*deg);
00234                                 tHype_Length.push_back(CalFormula(fHype_Length[SolId],RepId)*mm);
00235                         }
00236                         Hype_innerRadius.push_back(tHype_innerRadius);
00237                         Hype_outerRadius.push_back(tHype_outerRadius);
00238                         Hype_innerStereo.push_back(tHype_innerStereo);
00239                         Hype_outerStereo.push_back(tHype_outerStereo);
00240                         Hype_Length.push_back(tHype_Length);
00241                 }
00242                 else if( SolidType[VolId] == "TwistedTubs" ){
00243                         std::vector<G4double> tTwistedTubs_twistedangle;
00244                         std::vector<G4double> tTwistedTubs_endinnerrad;
00245                         std::vector<G4double> tTwistedTubs_endouterrad;
00246                         std::vector<G4double> tTwistedTubs_Length;
00247                         std::vector<G4double> tTwistedTubs_dphi;
00248                         for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00249                                 tTwistedTubs_twistedangle.push_back(CalFormula(fTwistedTubs_twistedangle[SolId],RepId)*deg);
00250                                 tTwistedTubs_endinnerrad.push_back(CalFormula(fTwistedTubs_endinnerrad[SolId],RepId)*mm);
00251                                 tTwistedTubs_endouterrad.push_back(CalFormula(fTwistedTubs_endouterrad[SolId],RepId)*mm);
00252                                 tTwistedTubs_Length.push_back(CalFormula(fTwistedTubs_Length[SolId],RepId)*mm);
00253                                 tTwistedTubs_dphi.push_back(CalFormula(fTwistedTubs_dphi[SolId],RepId)*deg);
00254                         }
00255                         TwistedTubs_twistedangle.push_back(tTwistedTubs_twistedangle);
00256                         TwistedTubs_endinnerrad.push_back(tTwistedTubs_endinnerrad);
00257                         TwistedTubs_endouterrad.push_back(tTwistedTubs_endouterrad);
00258                         TwistedTubs_Length.push_back(tTwistedTubs_Length);
00259                         TwistedTubs_dphi.push_back(tTwistedTubs_dphi);
00260                 }
00261                 else if( SolidType[VolId] == "Cons" ){
00262                         std::vector<G4double> tCons_RMax1;
00263                         std::vector<G4double> tCons_RMin1;
00264                         std::vector<G4double> tCons_RMax2;
00265                         std::vector<G4double> tCons_RMin2;
00266                         std::vector<G4double> tCons_Length;
00267                         std::vector<G4double> tCons_StartAng;
00268                         std::vector<G4double> tCons_SpanAng;
00269                         for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00270                                 tCons_RMax1.push_back(CalFormula(fCons_RMax1[SolId],RepId)*mm);
00271                                 tCons_RMin1.push_back(CalFormula(fCons_RMin1[SolId],RepId)*mm);
00272                                 tCons_RMax2.push_back(CalFormula(fCons_RMax2[SolId],RepId)*mm);
00273                                 tCons_RMin2.push_back(CalFormula(fCons_RMin2[SolId],RepId)*mm);
00274                                 tCons_Length.push_back(CalFormula(fCons_Length[SolId],RepId)*mm);
00275                                 tCons_StartAng.push_back(CalFormula(fCons_StartAng[SolId],RepId)*deg);
00276                                 tCons_SpanAng.push_back(CalFormula(fCons_SpanAng[SolId],RepId)*deg);
00277                         }
00278                         Cons_RMax1.push_back(tCons_RMax1);
00279                         Cons_RMin1.push_back(tCons_RMin1);
00280                         Cons_RMax2.push_back(tCons_RMax2);
00281                         Cons_RMin2.push_back(tCons_RMin2);
00282                         Cons_Length.push_back(tCons_Length);
00283                         Cons_StartAng.push_back(tCons_StartAng);
00284                         Cons_SpanAng.push_back(tCons_SpanAng);
00285                 }
00286                 else if( SolidType[VolId] == "Polycone" ){
00287                         std::vector<G4double> tPolycone_StartAng;
00288                         std::vector<G4double> tPolycone_SpanAng;
00289                         for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00290                                 tPolycone_StartAng.push_back(CalFormula(fPolycone_StartAng[SolId],RepId)*deg);
00291                                 tPolycone_SpanAng.push_back(CalFormula(fPolycone_SpanAng[SolId],RepId)*deg);
00292                         }
00293                         Polycone_StartAng.push_back(tPolycone_StartAng);
00294                         Polycone_SpanAng.push_back(tPolycone_SpanAng);
00295                         std::vector<std::vector<G4double> > iPolycone_RMax;
00296                         std::vector<std::vector<G4double> > iPolycone_RMin;
00297                         std::vector<std::vector<G4double> > iPolycone_Z;
00298                         for ( int ConeId = 0; ConeId < Polycone_numZ[SolId]; ConeId++ ){
00299                                 std::vector<G4double> tPolycone_RMax;
00300                                 std::vector<G4double> tPolycone_RMin;
00301                                 std::vector<G4double> tPolycone_Z;
00302                                 for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00303                                         tPolycone_RMax.push_back(CalFormula(fPolycone_RMax[SolId][ConeId],RepId)*mm);
00304                                         tPolycone_RMin.push_back(CalFormula(fPolycone_RMin[SolId][ConeId],RepId)*mm);
00305                                         tPolycone_Z.push_back(CalFormula(fPolycone_Z[SolId][ConeId],RepId)*mm);
00306                                 }
00307                                 iPolycone_RMax.push_back(tPolycone_RMax);
00308                                 iPolycone_RMin.push_back(tPolycone_RMin);
00309                                 iPolycone_Z.push_back(tPolycone_Z);
00310                         }
00311                         Polycone_RMax.push_back(iPolycone_RMax);
00312                         Polycone_RMin.push_back(iPolycone_RMin);
00313                         Polycone_Z.push_back(iPolycone_Z);
00314                 }
00315                 else if( SolidType[VolId] == "ExtrudedSolid" ){
00316                         std::vector<std::vector<G4double> > iExtrudedSolid_X;
00317                         std::vector<std::vector<G4double> > iExtrudedSolid_Y;
00318                         std::vector<std::vector<G4double> > iExtrudedSolid_Z;
00319                         std::vector<std::vector<G4double> > iExtrudedSolid_X0;
00320                         std::vector<std::vector<G4double> > iExtrudedSolid_Y0;
00321                         std::vector<std::vector<G4double> > iExtrudedSolid_Scale;
00322                         for ( int ConeId = 0; ConeId < ExtrudedSolid_numZ[SolId]; ConeId++ ){
00323                                 std::vector<G4double> tExtrudedSolid_Z;
00324                                 std::vector<G4double> tExtrudedSolid_X0;
00325                                 std::vector<G4double> tExtrudedSolid_Y0;
00326                                 std::vector<G4double> tExtrudedSolid_Scale;
00327                                 for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00328                                         tExtrudedSolid_Z.push_back(CalFormula(fExtrudedSolid_Z[SolId][ConeId],RepId)*mm);
00329                                         tExtrudedSolid_X0.push_back(CalFormula(fExtrudedSolid_X0[SolId][ConeId],RepId)*mm);
00330                                         tExtrudedSolid_Y0.push_back(CalFormula(fExtrudedSolid_Y0[SolId][ConeId],RepId)*mm);
00331                                         tExtrudedSolid_Scale.push_back(CalFormula(fExtrudedSolid_Scale[SolId][ConeId],RepId));
00332                                 }
00333                                 iExtrudedSolid_Z.push_back(tExtrudedSolid_Z);
00334                                 iExtrudedSolid_X0.push_back(tExtrudedSolid_X0);
00335                                 iExtrudedSolid_Y0.push_back(tExtrudedSolid_Y0);
00336                                 iExtrudedSolid_Scale.push_back(tExtrudedSolid_Scale);
00337                         }
00338                         for ( int ConeId = 0; ConeId < ExtrudedSolid_numP[SolId]; ConeId++ ){
00339                                 std::vector<G4double> tExtrudedSolid_X;
00340                                 std::vector<G4double> tExtrudedSolid_Y;
00341                                 for ( int RepId = 0; RepId < RepNo[VolId]; RepId++ ){
00342                                         tExtrudedSolid_X.push_back(CalFormula(fExtrudedSolid_X[SolId][ConeId],RepId)*mm);
00343                                         tExtrudedSolid_Y.push_back(CalFormula(fExtrudedSolid_Y[SolId][ConeId],RepId)*mm);
00344                                 }
00345                                 iExtrudedSolid_X.push_back(tExtrudedSolid_X);
00346                                 iExtrudedSolid_Y.push_back(tExtrudedSolid_Y);
00347                         }
00348                         ExtrudedSolid_X.push_back(iExtrudedSolid_X);
00349                         ExtrudedSolid_Y.push_back(iExtrudedSolid_Y);
00350                         ExtrudedSolid_Z.push_back(iExtrudedSolid_Z);
00351                         ExtrudedSolid_X0.push_back(iExtrudedSolid_X0);
00352                         ExtrudedSolid_Y0.push_back(iExtrudedSolid_Y0);
00353                         ExtrudedSolid_Scale.push_back(iExtrudedSolid_Scale);
00354                 }
00355         }
00356 //      std::cout<<"End of SimpleGeometryParameter::Calculate"<<std::endl; // to be deleted
00357 }
00358 
00359 void SimpleGeometryParameter::Dump(){
00360         DumpInfo();
00361 }
00362 
00363 //-----------------------------------Special functions---------------------------------------------
00364 
00365 bool SimpleGeometryParameter::CheckInfo(){
00366         bool flag = false;// false means no problem
00367         flag = MyVGeometryParameter::CheckInfo();
00368         if (flag) return flag;// if something is wrong with its Parent Class, then return the status.
00369 
00370         //examine
00371         return flag;
00372 }
00373 
00374 void SimpleGeometryParameter::Preset(){
00375         MyVGeometryParameter::Preset();// Call its Parent class to preset
00376         notReSetVis = true;
00377         VolNo = 0;
00378         BoxNo = 0;
00379         EllipticalTubeNo = 0;
00380         TubsNo = 0;
00381         TorusNo = 0;
00382         SphereNo = 0;
00383         HypeNo = 0;
00384         TwistedTubsNo = 0;
00385         ConsNo = 0;
00386         PolyconeNo = 0;
00387         ExtrudedSolidNo = 0;
00388         BooleanSolidNo = 0;
00389 
00390         //General info about volume
00391         Name.clear();
00392         MotherName.clear();
00393         SDName.clear();
00394         Material.clear();
00395         SRepNo.clear();
00396         RepNo.clear();
00397         SolidType.clear();
00398         SolidIndex.clear();
00399         SolidBoolean.clear();
00400         fPosX.clear();
00401         fPosY.clear();
00402         fPosZ.clear();
00403         fPosR.clear();
00404         fPosPhi.clear();
00405         fPosTheta.clear();
00406         PosType.clear();
00407         fEphi.clear();
00408         fEtheta.clear();
00409         fEpsi.clear();
00410         Pos.clear();
00411         Ephi.clear();
00412         Etheta.clear();
00413         Epsi.clear();
00414 
00415         //Box info
00416         fBox_X.clear();
00417         fBox_Y.clear();
00418         fBox_Z.clear();
00419         Box_X.clear();
00420         Box_Y.clear();
00421         Box_Z.clear();
00422         Box_GenIndex.clear();
00423 
00424         //EllipticalTube info
00425         fEllipticalTube_X.clear();
00426         fEllipticalTube_Y.clear();
00427         fEllipticalTube_Z.clear();
00428         EllipticalTube_X.clear();
00429         EllipticalTube_Y.clear();
00430         EllipticalTube_Z.clear();
00431         EllipticalTube_GenIndex.clear();
00432 
00433         //Tubs info
00434         fTubs_RMax.clear();
00435         fTubs_RMin.clear();
00436         fTubs_Length.clear();
00437         fTubs_StartAng.clear();
00438         fTubs_SpanAng.clear();
00439         Tubs_RMax.clear();
00440         Tubs_RMin.clear();
00441         Tubs_Length.clear();
00442         Tubs_StartAng.clear();
00443         Tubs_SpanAng.clear();
00444         Tubs_GenIndex.clear();
00445 
00446         //Torus info
00447         fTorus_RMax.clear();
00448         fTorus_RMin.clear();
00449         fTorus_Rtor.clear();
00450         fTorus_StartAng.clear();
00451         fTorus_SpanAng.clear();
00452         Torus_RMax.clear();
00453         Torus_RMin.clear();
00454         Torus_Rtor.clear();
00455         Torus_StartAng.clear();
00456         Torus_SpanAng.clear();
00457         Torus_GenIndex.clear();
00458 
00459         //Sphere info
00460         fSphere_RMax.clear();
00461         fSphere_RMin.clear();
00462         fSphere_StartPhi.clear();
00463         fSphere_SpanPhi.clear();
00464         fSphere_StartTheta.clear();
00465         fSphere_SpanTheta.clear();
00466         Sphere_RMax.clear();
00467         Sphere_RMin.clear();
00468         Sphere_StartPhi.clear();
00469         Sphere_SpanPhi.clear();
00470         Sphere_StartTheta.clear();
00471         Sphere_SpanTheta.clear();
00472         Sphere_GenIndex.clear();
00473 
00474         //Hype info
00475         fHype_innerRadius.clear();
00476         fHype_outerRadius.clear();
00477         fHype_innerStereo.clear();
00478         fHype_outerStereo.clear();
00479         fHype_Length.clear();
00480         Hype_innerRadius.clear();
00481         Hype_outerRadius.clear();
00482         Hype_innerStereo.clear();
00483         Hype_outerStereo.clear();
00484         Hype_Length.clear();
00485         Hype_GenIndex.clear();
00486 
00487         //TwistedTubs info
00488         fTwistedTubs_twistedangle.clear();
00489         fTwistedTubs_endinnerrad.clear();
00490         fTwistedTubs_endouterrad.clear();
00491         fTwistedTubs_Length.clear();
00492         fTwistedTubs_dphi.clear();
00493         TwistedTubs_twistedangle.clear();
00494         TwistedTubs_endinnerrad.clear();
00495         TwistedTubs_endouterrad.clear();
00496         TwistedTubs_Length.clear();
00497         TwistedTubs_dphi.clear();
00498         TwistedTubs_GenIndex.clear();
00499 
00500         //Cons info
00501         fCons_RMax1.clear();
00502         fCons_RMin1.clear();
00503         fCons_RMax2.clear();
00504         fCons_RMin2.clear();
00505         fCons_Length.clear();
00506         fCons_StartAng.clear();
00507         fCons_SpanAng.clear();
00508         Cons_RMax1.clear();
00509         Cons_RMin1.clear();
00510         Cons_RMax2.clear();
00511         Cons_RMin2.clear();
00512         Cons_Length.clear();
00513         Cons_StartAng.clear();
00514         Cons_SpanAng.clear();
00515         Cons_GenIndex.clear();
00516 
00517         //Polycone info
00518         fPolycone_RMax.clear();
00519         fPolycone_RMin.clear();
00520         fPolycone_Z.clear();
00521         Polycone_RMax.clear();
00522         Polycone_RMin.clear();
00523         Polycone_Z.clear();
00524         Polycone_numZ.clear();
00525         fPolycone_StartAng.clear();
00526         fPolycone_SpanAng.clear();
00527         Polycone_StartAng.clear();
00528         Polycone_SpanAng.clear();
00529         Polycone_GenIndex.clear();
00530         waited_Polycone_iVol = -1;
00531         achieved_componets_Polycone = 0;
00532 
00533         //ExtrudedSolid info
00534         fExtrudedSolid_X.clear();
00535         fExtrudedSolid_Y.clear();
00536         fExtrudedSolid_Z.clear();
00537         fExtrudedSolid_X0.clear();
00538         fExtrudedSolid_Y0.clear();
00539         fExtrudedSolid_Scale.clear();
00540         ExtrudedSolid_X.clear();
00541         ExtrudedSolid_Y.clear();
00542         ExtrudedSolid_Z.clear();
00543         ExtrudedSolid_X0.clear();
00544         ExtrudedSolid_Y0.clear();
00545         ExtrudedSolid_Scale.clear();
00546         ExtrudedSolid_numZ.clear();
00547         ExtrudedSolid_numP.clear();
00548         ExtrudedSolid_GenIndex.clear();
00549         waited_ExtrudedSolid_iVol = -1;
00550         achieved_Z_ExtrudedSolid = 0;
00551         achieved_P_ExtrudedSolid = 0;
00552 
00553         //BooleanSolid info
00554         BooleanSolid_type.clear();
00555         BooleanSolid_sol1.clear();
00556         BooleanSolid_sol2.clear();
00557         fBooleanSolid_Ephi.clear();
00558         fBooleanSolid_Etheta.clear();
00559         fBooleanSolid_Epsi.clear();
00560         fBooleanSolid_PosX.clear();
00561         fBooleanSolid_PosY.clear();
00562         fBooleanSolid_PosZ.clear();
00563         fBooleanSolid_PosR.clear();
00564         fBooleanSolid_PosPhi.clear();
00565         fBooleanSolid_PosTheta.clear();
00566         BooleanSolid_PosType.clear();
00567         BooleanSolid_Ephi.clear();
00568         BooleanSolid_Etheta.clear();
00569         BooleanSolid_Epsi.clear();
00570         BooleanSolid_Pos.clear();
00571         BooleanSolid_GenIndex.clear();
00572 }
00573 
00574 int SimpleGeometryParameter::GetValue(G4String s_card){
00575         if (!MyVGeometryParameter::GetValue(s_card)) return 0;// if found by Parent Class, then return.
00576         int status = 0;// 0 means found the value
00577         std::stringstream buf_card;
00578         buf_card.str("");
00579         buf_card.clear();
00580         buf_card<<s_card;
00581         G4String name;
00582         buf_card>>name;
00583         G4String s_para;
00584         int iVol = VolNo;
00585         bool GoOn = true;
00586 //      std::cout<<"==> "<<s_card<<std::endl; // to be deleted
00587         if (waited_Polycone_iVol>=0){
00588                 GoOn = false;
00589                 if (achieved_componets_Polycone<Polycone_numZ[waited_Polycone_iVol]){
00590                         if (name=="PCI"){
00591                                 G4String tPolycone_RMax;
00592                                 G4String tPolycone_RMin;
00593                                 G4String tPolycone_Z;
00594                                 buf_card>>tPolycone_Z>>tPolycone_RMin>>tPolycone_RMax;
00595                                 fPolycone_RMax[waited_Polycone_iVol][achieved_componets_Polycone] = ReplaceMacro(tPolycone_RMax);
00596                                 fPolycone_RMin[waited_Polycone_iVol][achieved_componets_Polycone] = ReplaceMacro(tPolycone_RMin);
00597                                 fPolycone_Z[waited_Polycone_iVol][achieved_componets_Polycone] = ReplaceMacro(tPolycone_Z);
00598                                 achieved_componets_Polycone++;
00599                         }
00600                         else {
00601                                 std::cout<<"Not enough Polycone components! Needed: "<<Polycone_numZ[waited_Polycone_iVol]<<", got: "<<achieved_componets_Polycone+1<<std::endl;
00602                                 Polycone_numZ[waited_Polycone_iVol]=achieved_componets_Polycone;
00603                                 GoOn = true;
00604                         }
00605                         if (Polycone_numZ[waited_Polycone_iVol]==achieved_componets_Polycone){
00606                                 waited_Polycone_iVol=-1;
00607                                 achieved_componets_Polycone=0;
00608                         }
00609                 }
00610         }
00611         else if (waited_ExtrudedSolid_iVol>=0){
00612                 GoOn = false;
00613                 if (achieved_Z_ExtrudedSolid<ExtrudedSolid_numZ[waited_ExtrudedSolid_iVol]){
00614                         if (name=="ESZ"){
00615                                 G4String tExtrudedSolid_Z;
00616                                 G4String tExtrudedSolid_X0;
00617                                 G4String tExtrudedSolid_Y0;
00618                                 G4String tExtrudedSolid_Scale;
00619                                 buf_card>>tExtrudedSolid_Z>>tExtrudedSolid_X0>>tExtrudedSolid_Y0>>tExtrudedSolid_Scale;
00620                                 fExtrudedSolid_Z[waited_ExtrudedSolid_iVol][achieved_Z_ExtrudedSolid] = ReplaceMacro(tExtrudedSolid_Z);
00621                                 fExtrudedSolid_X0[waited_ExtrudedSolid_iVol][achieved_Z_ExtrudedSolid] = ReplaceMacro(tExtrudedSolid_X0);
00622                                 fExtrudedSolid_Y0[waited_ExtrudedSolid_iVol][achieved_Z_ExtrudedSolid] = ReplaceMacro(tExtrudedSolid_Y0);
00623                                 fExtrudedSolid_Scale[waited_ExtrudedSolid_iVol][achieved_Z_ExtrudedSolid] = ReplaceMacro(tExtrudedSolid_Scale);
00624                                 achieved_Z_ExtrudedSolid++;
00625                         }
00626                 }
00627                 if (achieved_P_ExtrudedSolid<ExtrudedSolid_numP[waited_ExtrudedSolid_iVol]){
00628                         if (name=="ESP"){
00629                                 G4String tExtrudedSolid_X;
00630                                 G4String tExtrudedSolid_Y;
00631                                 buf_card>>tExtrudedSolid_X>>tExtrudedSolid_Y;
00632                                 fExtrudedSolid_X[waited_ExtrudedSolid_iVol][achieved_P_ExtrudedSolid] = ReplaceMacro(tExtrudedSolid_X);
00633                                 fExtrudedSolid_Y[waited_ExtrudedSolid_iVol][achieved_P_ExtrudedSolid] = ReplaceMacro(tExtrudedSolid_Y);
00634                                 achieved_P_ExtrudedSolid++;
00635                         }
00636                 }
00637                 if (ExtrudedSolid_numP[waited_ExtrudedSolid_iVol]==achieved_P_ExtrudedSolid&&ExtrudedSolid_numZ[waited_ExtrudedSolid_iVol]==achieved_Z_ExtrudedSolid){
00638                         waited_ExtrudedSolid_iVol=-1;
00639                         achieved_P_ExtrudedSolid=0;
00640                         achieved_Z_ExtrudedSolid=0;
00641                 }
00642         }
00643         if (GoOn){
00644                 bool foundVolume = false;
00645                 if( name == "B" ){
00646                         SolidType.push_back("Box");
00647                         SolidIndex.push_back(BoxNo);
00648                         G4String tBox_X;
00649                         G4String tBox_Y;
00650                         G4String tBox_Z;
00651                         buf_card>>tBox_X>>tBox_Y>>tBox_Z;
00652                         fBox_X.push_back(ReplaceMacro(tBox_X));
00653                         fBox_Y.push_back(ReplaceMacro(tBox_Y));
00654                         fBox_Z.push_back(ReplaceMacro(tBox_Z));
00655                         Box_GenIndex.push_back(iVol);
00656                         BoxNo++;
00657                         foundVolume = true;
00658                 }
00659                 if( name == "ET" ){
00660                         SolidType.push_back("EllipticalTube");
00661                         SolidIndex.push_back(EllipticalTubeNo);
00662                         G4String tEllipticalTube_X;
00663                         G4String tEllipticalTube_Y;
00664                         G4String tEllipticalTube_Z;
00665                         buf_card>>tEllipticalTube_X>>tEllipticalTube_Y>>tEllipticalTube_Z;
00666                         fEllipticalTube_X.push_back(ReplaceMacro(tEllipticalTube_X));
00667                         fEllipticalTube_Y.push_back(ReplaceMacro(tEllipticalTube_Y));
00668                         fEllipticalTube_Z.push_back(ReplaceMacro(tEllipticalTube_Z));
00669                         EllipticalTube_GenIndex.push_back(iVol);
00670                         EllipticalTubeNo++;
00671                         foundVolume = true;
00672                 }
00673                 else if( name == "T" ){
00674                         SolidType.push_back("Tubs");
00675                         SolidIndex.push_back(TubsNo);
00676                         G4String tTubs_RMax;
00677                         G4String tTubs_RMin;
00678                         G4String tTubs_Length;
00679                         G4String tTubs_StartAng;
00680                         G4String tTubs_SpanAng;
00681                         buf_card>>tTubs_RMin>>tTubs_RMax>>tTubs_Length>>tTubs_StartAng>>tTubs_SpanAng;
00682                         fTubs_RMax.push_back(ReplaceMacro(tTubs_RMax));
00683                         fTubs_RMin.push_back(ReplaceMacro(tTubs_RMin));
00684                         fTubs_Length.push_back(ReplaceMacro(tTubs_Length));
00685                         fTubs_StartAng.push_back(ReplaceMacro(tTubs_StartAng));
00686                         fTubs_SpanAng.push_back(ReplaceMacro(tTubs_SpanAng));
00687                         Tubs_GenIndex.push_back(iVol);
00688                         TubsNo++;
00689                         foundVolume = true;
00690                 }
00691                 else if( name == "Tor" ){
00692                         SolidType.push_back("Torus");
00693                         SolidIndex.push_back(TorusNo);
00694                         G4String tTorus_RMax;
00695                         G4String tTorus_RMin;
00696                         G4String tTorus_Rtor;
00697                         G4String tTorus_StartAng;
00698                         G4String tTorus_SpanAng;
00699                         buf_card>>tTorus_RMin>>tTorus_RMax>>tTorus_Rtor>>tTorus_StartAng>>tTorus_SpanAng;
00700                         fTorus_RMax.push_back(ReplaceMacro(tTorus_RMax));;
00701                         fTorus_RMin.push_back(ReplaceMacro(tTorus_RMin));;
00702                         fTorus_Rtor.push_back(ReplaceMacro(tTorus_Rtor));;
00703                         fTorus_StartAng.push_back(ReplaceMacro(tTorus_StartAng));;
00704                         fTorus_SpanAng.push_back(ReplaceMacro(tTorus_SpanAng));;
00705                         Torus_GenIndex.push_back(iVol);
00706                         TorusNo++;
00707                         foundVolume = true;
00708                 }
00709                 else if( name == "Sph" ){
00710                         SolidType.push_back("Sphere");
00711                         SolidIndex.push_back(SphereNo);
00712                         G4String tSphere_RMax;
00713                         G4String tSphere_RMin;
00714                         G4String tSphere_StartPhi;
00715                         G4String tSphere_SpanPhi;
00716                         G4String tSphere_StartTheta;
00717                         G4String tSphere_SpanTheta;
00718                         buf_card>>tSphere_RMin>>tSphere_RMax>>tSphere_StartPhi>>tSphere_SpanPhi>>tSphere_StartTheta>>tSphere_SpanTheta;
00719                         fSphere_RMax.push_back(ReplaceMacro(tSphere_RMax));;
00720                         fSphere_RMin.push_back(ReplaceMacro(tSphere_RMin));;
00721                         fSphere_StartPhi.push_back(ReplaceMacro(tSphere_StartPhi));;
00722                         fSphere_SpanPhi.push_back(ReplaceMacro(tSphere_SpanPhi));;
00723                         fSphere_StartTheta.push_back(ReplaceMacro(tSphere_StartTheta));;
00724                         fSphere_SpanTheta.push_back(ReplaceMacro(tSphere_SpanTheta));;
00725                         Sphere_GenIndex.push_back(iVol);
00726                         SphereNo++;
00727                         foundVolume = true;
00728                 }
00729                 else if( name == "H" ){
00730                         SolidType.push_back("Hype");
00731                         SolidIndex.push_back(HypeNo);
00732                         G4String tHype_innerRadius;
00733                         G4String tHype_outerRadius;
00734                         G4String tHype_innerStereo;
00735                         G4String tHype_outerStereo;
00736                         G4String tHype_Length;
00737                         buf_card>>tHype_innerRadius>>tHype_outerRadius>>tHype_innerStereo>>tHype_outerStereo>>tHype_Length;
00738                         fHype_innerRadius.push_back(ReplaceMacro(tHype_innerRadius));;
00739                         fHype_outerRadius.push_back(ReplaceMacro(tHype_outerRadius));;
00740                         fHype_innerStereo.push_back(ReplaceMacro(tHype_innerStereo));;
00741                         fHype_outerStereo.push_back(ReplaceMacro(tHype_outerStereo));;
00742                         fHype_Length.push_back(ReplaceMacro(tHype_Length));;
00743                         Hype_GenIndex.push_back(iVol);
00744                         HypeNo++;
00745                         foundVolume = true;
00746                 }
00747                 else if( name == "TT" ){
00748                         SolidType.push_back("TwistedTubs");
00749                         SolidIndex.push_back(TwistedTubsNo);
00750                         G4String tTwistedTubs_twistedangle;
00751                         G4String tTwistedTubs_endinnerrad;
00752                         G4String tTwistedTubs_endouterrad;
00753                         G4String tTwistedTubs_Length;
00754                         G4String tTwistedTubs_dphi;
00755                         buf_card>>tTwistedTubs_twistedangle>>tTwistedTubs_endinnerrad>>tTwistedTubs_endouterrad>>tTwistedTubs_Length>>tTwistedTubs_dphi;
00756                         fTwistedTubs_twistedangle.push_back(ReplaceMacro(tTwistedTubs_twistedangle));;
00757                         fTwistedTubs_endinnerrad.push_back(ReplaceMacro(tTwistedTubs_endinnerrad));;
00758                         fTwistedTubs_endouterrad.push_back(ReplaceMacro(tTwistedTubs_endouterrad));;
00759                         fTwistedTubs_Length.push_back(ReplaceMacro(tTwistedTubs_Length));;
00760                         fTwistedTubs_dphi.push_back(ReplaceMacro(tTwistedTubs_dphi));;
00761                         TwistedTubs_GenIndex.push_back(iVol);
00762                         TwistedTubsNo++;
00763                         foundVolume = true;
00764                 }
00765                 else if( name == "C" ){
00766                         SolidType.push_back("Cons");
00767                         SolidIndex.push_back(ConsNo);
00768                         G4String tCons_RMax1;
00769                         G4String tCons_RMin1;
00770                         G4String tCons_RMax2;
00771                         G4String tCons_RMin2;
00772                         G4String tCons_Length;
00773                         G4String tCons_StartAng;
00774                         G4String tCons_SpanAng;
00775                         buf_card>>tCons_RMin1>>tCons_RMax1>>tCons_RMin2>>tCons_RMax2>>tCons_Length>>tCons_StartAng>>tCons_SpanAng;
00776                         fCons_RMax1.push_back(ReplaceMacro(tCons_RMax1));;
00777                         fCons_RMin1.push_back(ReplaceMacro(tCons_RMin1));;
00778                         fCons_RMax2.push_back(ReplaceMacro(tCons_RMax2));;
00779                         fCons_RMin2.push_back(ReplaceMacro(tCons_RMin2));;
00780                         fCons_Length.push_back(ReplaceMacro(tCons_Length));;
00781                         fCons_StartAng.push_back(ReplaceMacro(tCons_StartAng));;
00782                         fCons_SpanAng.push_back(ReplaceMacro(tCons_SpanAng));;
00783                         Cons_GenIndex.push_back(iVol);
00784                         ConsNo++;
00785                         foundVolume = true;
00786                 }
00787                 else if( name == "PC" ){
00788                         SolidType.push_back("Polycone");
00789                         SolidIndex.push_back(PolyconeNo);
00790                         G4int tPolycone_numZ;
00791                         G4String tPolycone_StartAng;
00792                         G4String tPolycone_SpanAng;
00793                         buf_card>>tPolycone_numZ>>tPolycone_StartAng>>tPolycone_SpanAng;
00794                         Polycone_numZ.push_back(tPolycone_numZ);
00795                         fPolycone_StartAng.push_back(ReplaceMacro(tPolycone_StartAng));;
00796                         fPolycone_SpanAng.push_back(ReplaceMacro(tPolycone_SpanAng));;
00797                         Polycone_GenIndex.push_back(iVol);
00798                         std::vector<G4String> empty_vec;
00799                         empty_vec.resize(tPolycone_numZ);
00800                         fPolycone_RMax.push_back(empty_vec);;
00801                         fPolycone_RMin.push_back(empty_vec);;
00802                         fPolycone_Z.push_back(empty_vec);;
00803                         waited_Polycone_iVol = PolyconeNo;
00804                         achieved_componets_Polycone = 0;
00805                         PolyconeNo++;
00806                         foundVolume = true;
00807                 }
00808                 else if( name == "ES" ){
00809                         SolidType.push_back("ExtrudedSolid");
00810                         SolidIndex.push_back(ExtrudedSolidNo);
00811                         G4int tExtrudedSolid_numZ;
00812                         G4int tExtrudedSolid_numP;
00813                         buf_card>>tExtrudedSolid_numZ>>tExtrudedSolid_numP;
00814                         ExtrudedSolid_numZ.push_back(tExtrudedSolid_numZ);
00815                         ExtrudedSolid_numP.push_back(tExtrudedSolid_numP);
00816                         ExtrudedSolid_GenIndex.push_back(iVol);
00817                         std::vector<G4String> empty_vec;
00818                         empty_vec.resize(tExtrudedSolid_numP);
00819                         fExtrudedSolid_X.push_back(empty_vec);;
00820                         fExtrudedSolid_Y.push_back(empty_vec);;
00821                         empty_vec.resize(tExtrudedSolid_numZ);
00822                         fExtrudedSolid_Z.push_back(empty_vec);;
00823                         fExtrudedSolid_X0.push_back(empty_vec);;
00824                         fExtrudedSolid_Y0.push_back(empty_vec);;
00825                         fExtrudedSolid_Scale.push_back(empty_vec);;
00826                         waited_ExtrudedSolid_iVol = ExtrudedSolidNo;
00827                         achieved_P_ExtrudedSolid = 0;
00828                         achieved_Z_ExtrudedSolid = 0;
00829                         ExtrudedSolidNo++;
00830                         foundVolume = true;
00831                 }
00832                 else if( name == "BL" ){
00833                         SolidType.push_back("BooleanSolid");
00834                         SolidIndex.push_back(BooleanSolidNo);
00835                         G4String dump;
00836                         G4String tBooleanSolid_type;
00837                         G4String tBooleanSolid_sol1;
00838                         G4String tBooleanSolid_sol2;
00839                         G4String tBooleanSolid_Ephi;
00840                         G4String tBooleanSolid_Etheta;
00841                         G4String tBooleanSolid_Epsi;
00842                         G4String tBooleanSolid_PosX;
00843                         G4String tBooleanSolid_PosY;
00844                         G4String tBooleanSolid_PosZ;
00845                         G4String tBooleanSolid_PosR;
00846                         G4String tBooleanSolid_PosTheta;
00847                         G4String tBooleanSolid_PosPhi;
00848                         G4String tBooleanSolid_PosType;
00849                         buf_card>>tBooleanSolid_type>>tBooleanSolid_sol1>>tBooleanSolid_sol2>>tBooleanSolid_Ephi>>tBooleanSolid_Etheta>>tBooleanSolid_Epsi>>dump;
00850                         if (dump=="P"){ // Need Polar Coordinates
00851                                 buf_card>>tBooleanSolid_PosR>>tBooleanSolid_PosPhi>>tBooleanSolid_PosZ;
00852                                 tBooleanSolid_PosType = "Polar";
00853                         }
00854                         else if (dump=="S"){ // Need Spherical Coordinates
00855                                 buf_card>>tBooleanSolid_PosR>>tBooleanSolid_PosPhi>>tBooleanSolid_PosTheta;
00856                                 tBooleanSolid_PosType = "Spherical";
00857                         }
00858                         else if (dump=="C"){ // Need Cartesian Coordinates
00859                                 buf_card>>tBooleanSolid_PosX>>tBooleanSolid_PosY>>tBooleanSolid_PosZ;
00860                                 tBooleanSolid_PosType = "Cartesian";
00861                         }
00862                         else{ // By default, need Cartesian Coordinates
00863                                 tBooleanSolid_PosX=dump;
00864                                 buf_card>>tBooleanSolid_PosY>>tBooleanSolid_PosZ;
00865                                 tBooleanSolid_PosType = "Cartesian";
00866                         }
00867                         BooleanSolid_type.push_back(tBooleanSolid_type);
00868                         BooleanSolid_sol1.push_back(tBooleanSolid_sol1);
00869                         BooleanSolid_sol2.push_back(tBooleanSolid_sol2);
00870                         fBooleanSolid_Ephi.push_back(ReplaceMacro(tBooleanSolid_Ephi));
00871                         fBooleanSolid_Etheta.push_back(ReplaceMacro(tBooleanSolid_Etheta));
00872                         fBooleanSolid_Epsi.push_back(ReplaceMacro(tBooleanSolid_Epsi));
00873                         fBooleanSolid_PosX.push_back(ReplaceMacro(tBooleanSolid_PosX));
00874                         fBooleanSolid_PosY.push_back(ReplaceMacro(tBooleanSolid_PosY));
00875                         fBooleanSolid_PosZ.push_back(ReplaceMacro(tBooleanSolid_PosZ));
00876                         fBooleanSolid_PosR.push_back(ReplaceMacro(tBooleanSolid_PosR));
00877                         fBooleanSolid_PosTheta.push_back(ReplaceMacro(tBooleanSolid_PosTheta));
00878                         fBooleanSolid_PosPhi.push_back(ReplaceMacro(tBooleanSolid_PosPhi));
00879                         BooleanSolid_PosType.push_back(ReplaceMacro(tBooleanSolid_PosType));
00880                         BooleanSolid_GenIndex.push_back(iVol);
00881                         BooleanSolidNo++;
00882                         foundVolume = true;
00883                 }
00884                 if (foundVolume){
00885                         G4String dump;
00886                         G4String tPosX;
00887                         G4String tPosY;
00888                         G4String tPosZ;
00889                         G4String tPosR;
00890                         G4String tPosTheta;
00891                         G4String tPosPhi;
00892                         G4String tPosType;
00893                         G4String tRepCont;
00894                         G4int tRepNo = 1;
00895                         G4int tSRepNo = 0;
00896                         G4String tSDName;
00897                         G4String tEphi;
00898                         G4String tEtheta;
00899                         G4String tEpsi;
00900                         G4String tName;
00901                         G4String tMotherName;
00902                         G4String tMaterial;
00903                         G4bool   tSolidBoolean = true;
00904                         buf_card>>tName>>tRepCont;
00905                         get_RepCont(tRepCont,tSRepNo,tRepNo);
00906                         if(buf_card>>tMotherName){
00907                                 tSolidBoolean = false;
00908                                 buf_card>>tMaterial>>tSDName>>dump;
00909                                 if (dump=="P"){ // Need Polar Coordinates
00910                                         buf_card>>tPosR>>tPosPhi>>tPosZ;
00911                                         tPosType = "Polar";
00912                                 }
00913                                 else if (dump=="S"){ // Need Spherical Coordinates
00914                                         buf_card>>tPosR>>tPosPhi>>tPosTheta;
00915                                         tPosType = "Spherical";
00916                                 }
00917                                 else if (dump=="C"){ // Need Cartesian Coordinates
00918                                         buf_card>>tPosX>>tPosY>>tPosZ;
00919                                         tPosType = "Cartesian";
00920                                 }
00921                                 else{ // By default, need Cartesian Coordinates
00922                                         tPosX=dump;
00923                                         buf_card>>tPosY>>tPosZ;
00924                                         tPosType = "Cartesian";
00925                                 }
00926                                 buf_card>>tEphi>>tEtheta>>tEpsi;
00927                         }
00928                         fPosX.push_back(ReplaceMacro(tPosX));;
00929                         fPosY.push_back(ReplaceMacro(tPosY));;
00930                         fPosZ.push_back(ReplaceMacro(tPosZ));;
00931                         fPosR.push_back(ReplaceMacro(tPosR));;
00932                         fPosPhi.push_back(ReplaceMacro(tPosPhi));;
00933                         fPosTheta.push_back(ReplaceMacro(tPosTheta));;
00934                         PosType.push_back(tPosType);
00935                         Name.push_back(tName);
00936                         MotherName.push_back(tMotherName);
00937                         Material.push_back(tMaterial);
00938                         SDName.push_back(tSDName);
00939                         SRepNo.push_back(tSRepNo);
00940                         RepNo.push_back(tRepNo);
00941                         fEphi.push_back(ReplaceMacro(tEphi));;
00942                         fEtheta.push_back(ReplaceMacro(tEtheta));;
00943                         fEpsi.push_back(ReplaceMacro(tEpsi));;
00944                         SolidBoolean.push_back(tSolidBoolean);
00945                         VolNo++;
00946 //                      std::cout<<"found Volume:"<<tName<<std::endl; // to be deleted
00947                 }
00948                 else if ( name == "DEFINE:" ){
00949                         G4String MacroName;
00950                         G4String MacroValue;
00951                         buf_card>>MacroName>>MacroValue;
00952 //                      std::cout<<"found DEFINE:"<<std::endl; // to be deleted
00953                         MacroValue = ReplaceMacro(MacroValue);
00954                         std::cout<<"Define: "<<MacroName<<":\t"<<MacroValue<<std::endl;
00955                         bool foundName = false;
00956                         for (int i = 0; i < knownValueNames.size(); i++){
00957                                 if (knownValueNames[i]==MacroName){ // If this name occurred once, replace the value
00958                                         foundName = true;
00959                                         knownValues[i]=MacroValue;
00960                                         break;
00961                                 }
00962                         }
00963                         if (!foundName){
00964                                 knownValueNames.push_back(MacroName);
00965                                 knownValues.push_back(MacroValue);
00966                         }
00967                 }
00968                 else if ( name == "VISSETTING" ){
00969                         if(notReSetVis) ReSetVis();
00970                         status = -1;
00971                 }
00972                 else{
00973                         bool foundornot = false;
00974                         if ( name.substr(0,4) == "vis_" ){
00975                                 std::stringstream buf_temp;
00976                                 for ( G4int i = 0; i < VolNo; i++ ){
00977                                         buf_temp.str("");
00978                                         buf_temp.clear();
00979                                         buf_temp<<"vis_"<<Name[i];
00980                                         if( (std::string)name == buf_temp.str() ){
00981                                                 set_vis(i,true);
00982                                                 G4double vTr, vTg, vTb;
00983                                                 G4double vTT = 0;
00984                                                 buf_card>>vTr>>vTg>>vTb>>vTT;
00985                                                 if (!vTT) vTT = 1;
00986                                                 set_r(i,vTr);
00987                                                 set_g(i,vTg);
00988                                                 set_b(i,vTb);
00989                                                 set_t(i,vTT);
00990                                                 foundornot = true;
00991                                                 break; // got the parameter, go to next line
00992                                         }
00993                                 }
00994                                 buf_temp.str("");
00995                                 buf_temp.clear();
00996                         }
00997                         if (!foundornot){
00998                                 status = 1;
00999                         }
01000                 }
01001         }
01002         buf_card.str("");
01003         buf_card.clear();
01004         return status;
01005 }
01006 
01007 //---------------------------ReSetVis---------------------------------
01008 //
01009 void SimpleGeometryParameter::ReSetVis() {
01010         vVis.resize(VolNo);
01011         vR.resize(VolNo);
01012         vG.resize(VolNo);
01013         vB.resize(VolNo);
01014         vT.resize(VolNo);
01015         for ( G4int i = 0; i < VolNo; i++ ){
01016                 vVis[i] = false;
01017         }
01018         notReSetVis = false;
01019 }
01020 
01021 //---------------------------DumpInfo---------------------------------
01022 //output information
01023 void SimpleGeometryParameter::DumpInfo() {
01024         MyVGeometryParameter::DumpInfo();// dump info of its Parent Class first
01025         std::cout<<"------SimpleGeometry info :--------"<<std::endl;
01026 //      std::cout<<std::scientific<<std::setprecision(2);
01027         for( G4int i = 0; i < BoxNo; i++ ){
01028                 if ( i == 0 ){
01029                         std::cout<<"=>Box info:"<<BoxNo<<std::endl;
01030                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<"No."
01031                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"x"
01032                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"y"
01033                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"z";
01034                         dump_general_header();
01035                         std::cout<<std::endl;
01036                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<""
01037                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01038                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01039                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm";
01040                         dump_general_note();
01041                         std::cout<<std::endl;
01042                 } 
01043                 int index = Box_GenIndex[i];
01044                 int repNo = RepNo[index];
01045                 for ( G4int j = 0; j < repNo; j++ ){
01046                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<i
01047                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Box_X[i][j]/mm
01048                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Box_Y[i][j]/mm
01049                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Box_Z[i][j]/mm;
01050                         dump_general_value(index,j);
01051                         std::cout<<std::endl;
01052                 }
01053         }
01054         for( G4int i = 0; i < EllipticalTubeNo; i++ ){
01055                 if ( i == 0 ){
01056                         std::cout<<"=>EllipticalTube info:"<<EllipticalTubeNo<<std::endl;
01057                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<"No."
01058                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Dx"
01059                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Dy"
01060                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Dz";
01061                         dump_general_header();
01062                         std::cout<<std::endl;
01063                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<""
01064                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01065                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01066                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm";
01067                         dump_general_note();
01068                         std::cout<<std::endl;
01069                 } 
01070                 int index = EllipticalTube_GenIndex[i];
01071                 int repNo = RepNo[index];
01072                 for ( G4int j = 0; j < repNo; j++ ){
01073                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<i
01074                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<EllipticalTube_X[i][j]/mm
01075                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<EllipticalTube_Y[i][j]/mm
01076                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<EllipticalTube_Z[i][j]/mm;
01077                         dump_general_value(index,j);
01078                         std::cout<<std::endl;
01079                 }
01080         }
01081 
01082         for( G4int i = 0; i < TubsNo; i++ ){
01083                 if ( i == 0 ){
01084                         std::cout<<"=>Tubs info:"<<TubsNo<<std::endl;
01085                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<"No."
01086                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"RMin"
01087                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"RMax"
01088                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Length"
01089                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"StartAng"
01090                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"SpanAng";
01091                         dump_general_header();
01092                         std::cout<<std::endl;
01093                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<""
01094                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01095                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01096                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01097                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg"
01098                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg";
01099                         dump_general_note();
01100                         std::cout<<std::endl;
01101                 }
01102                 int index = Tubs_GenIndex[i];
01103                 int repNo = RepNo[index];
01104                 for ( G4int j = 0; j < repNo; j++ ){
01105                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<i
01106                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Tubs_RMin[i][j]/mm
01107                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Tubs_RMax[i][j]/mm
01108                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Tubs_Length[i][j]/mm
01109                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Tubs_StartAng[i][j]/deg
01110                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Tubs_SpanAng[i][j]/deg;
01111                         dump_general_value(index,j);
01112                         std::cout<<std::endl;
01113                 }
01114         }
01115 
01116         for( G4int i = 0; i < TorusNo; i++ ){
01117                 if ( i == 0 ){
01118                         std::cout<<"=>Torus info:"<<std::endl;
01119                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<"No."
01120                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"RMin"
01121                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"RMax"
01122                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Rtor"
01123                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"StartAng"
01124                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"SpanAng";
01125                         dump_general_header();
01126                         std::cout<<std::endl;
01127                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<""
01128                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01129                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01130                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01131                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg"
01132                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg";
01133                         dump_general_note();
01134                         std::cout<<std::endl;
01135                 }
01136                 int index = Torus_GenIndex[i];
01137                 int repNo = RepNo[index];
01138                 for ( G4int j = 0; j < repNo; j++ ){
01139                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<i
01140                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Torus_RMin[i][j]/mm
01141                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Torus_RMax[i][j]/mm
01142                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Torus_Rtor[i][j]/mm
01143                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Torus_StartAng[i][j]/deg
01144                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Torus_SpanAng[i][j]/deg;
01145                         dump_general_value(index,j);
01146                         std::cout<<std::endl;
01147                 }
01148         }
01149 
01150         for( G4int i = 0; i < SphereNo; i++ ){
01151                 if ( i == 0 ){
01152                         std::cout<<"=>Sphere info:"<<std::endl;
01153                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<"No."
01154                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"RMin"
01155                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"RMax"
01156                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"StartPhi"
01157                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"SpanPhi"
01158                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"StartThe"
01159                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"SpanThe";
01160                         dump_general_header();
01161                         std::cout<<std::endl;
01162                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<""
01163                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01164                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01165                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg"
01166                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg"
01167                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg"
01168                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg";
01169                         dump_general_note();
01170                         std::cout<<std::endl;
01171                 }
01172                 int index = Sphere_GenIndex[i];
01173                 int repNo = RepNo[index];
01174                 for ( G4int j = 0; j < repNo; j++ ){
01175                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<i
01176                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Sphere_RMin[i][j]/mm
01177                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Sphere_RMax[i][j]/mm
01178                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Sphere_StartPhi[i][j]/deg
01179                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Sphere_SpanPhi[i][j]/deg
01180                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<Sphere_StartTheta[i][j]/deg
01181                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<Sphere_SpanTheta[i][j]/deg;
01182                         dump_general_value(index);
01183                         std::cout<<std::endl;
01184                 }
01185         }
01186 
01187         for( G4int i = 0; i < HypeNo; i++ ){
01188                 if ( i == 0 ){
01189                         std::cout<<"=>Hype info:"<<std::endl;
01190                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<"No."
01191                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<"iRadius"
01192                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<"oRadius"
01193                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<"iStereo"
01194                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<"oStereo"
01195                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Length";
01196                         dump_general_header();
01197                         std::cout<<std::endl;
01198                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<""
01199                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<"mm"
01200                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<"mm"
01201                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<"deg"
01202                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<"deg"
01203                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm";
01204                         dump_general_note();
01205                         std::cout<<std::endl;
01206                 }
01207                 int index = Hype_GenIndex[i];
01208                 int repNo = RepNo[index];
01209                 for ( G4int j = 0; j < repNo; j++ ){
01210                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<i
01211                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<Hype_innerRadius[i][j]/mm
01212                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<Hype_outerRadius[i][j]/mm
01213                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<Hype_innerStereo[i][j]/deg
01214                                 <<std::setiosflags(std::ios::left)<<std::setw(10)<<Hype_outerStereo[i][j]/deg
01215                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Hype_Length[i][j]/mm;
01216                         dump_general_value(index);
01217                         std::cout<<std::endl;
01218                 }
01219         }
01220 
01221         for( G4int i = 0; i < TwistedTubsNo; i++ ){
01222                 if ( i == 0 ){
01223                         std::cout<<"=>TwistedTubs info:"<<std::endl;
01224                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<"No."
01225                                 <<std::setiosflags(std::ios::left)<<std::setw(13)<<"TwistedAngle"
01226                                 <<std::setiosflags(std::ios::left)<<std::setw(12)<<"EndInnerRad"
01227                                 <<std::setiosflags(std::ios::left)<<std::setw(12)<<"EndOuterRad"
01228                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Length"
01229                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"dphi";
01230                         dump_general_header();
01231                         std::cout<<std::endl;
01232                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<""
01233                                 <<std::setiosflags(std::ios::left)<<std::setw(13)<<"deg"
01234                                 <<std::setiosflags(std::ios::left)<<std::setw(12)<<"mm"
01235                                 <<std::setiosflags(std::ios::left)<<std::setw(12)<<"mm"
01236                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01237                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg";
01238                         dump_general_note();
01239                         std::cout<<std::endl;
01240                 }
01241                 int index = TwistedTubs_GenIndex[i];
01242                 int repNo = RepNo[index];
01243                 for ( G4int j = 0; j < repNo; j++ ){
01244                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<i
01245                                 <<std::setiosflags(std::ios::left)<<std::setw(13)<<TwistedTubs_twistedangle[i][j]/deg
01246                                 <<std::setiosflags(std::ios::left)<<std::setw(12)<<TwistedTubs_endinnerrad[i][j]/mm
01247                                 <<std::setiosflags(std::ios::left)<<std::setw(12)<<TwistedTubs_endouterrad[i][j]/mm
01248                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<TwistedTubs_Length[i][j]/mm
01249                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<TwistedTubs_dphi[i][j]/deg;
01250                         dump_general_value(index);
01251                         std::cout<<std::endl;
01252                 }
01253         }
01254 
01255         for( G4int i = 0; i < ConsNo; i++ ){
01256                 if ( i == 0 ){
01257                         std::cout<<"=>Cons info:"<<std::endl;
01258                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<"No."
01259                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"RMin1"
01260                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"RMax1"
01261                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"RMin2"
01262                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"RMax2"
01263                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Length"
01264                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"StartAng"
01265                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"SpanAng";
01266                         dump_general_header();
01267                         std::cout<<std::endl;
01268                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<""
01269                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01270                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01271                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01272                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01273                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01274                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg"
01275                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg";
01276                         dump_general_note();
01277                         std::cout<<std::endl;
01278                 }
01279                 int index = Cons_GenIndex[i];
01280                 int repNo = RepNo[index];
01281                 for ( G4int j = 0; j < repNo; j++ ){
01282                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<i
01283                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Cons_RMin1[i][j]/mm
01284                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Cons_RMax1[i][j]/mm
01285                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Cons_RMin2[i][j]/mm
01286                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Cons_RMax2[i][j]/mm
01287                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Cons_Length[i][j]/mm
01288                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Cons_StartAng[i][j]/deg
01289                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Cons_SpanAng[i][j]/deg;
01290                         dump_general_value(index);
01291                         std::cout<<std::endl;
01292                 }
01293         }
01294 
01295         for( G4int i = 0; i < PolyconeNo; i++ ){
01296                 if ( i == 0 ){
01297                         std::cout<<"=>Polycone info:"<<std::endl;
01298                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<"No."
01299                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"numZ"
01300                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"StartAng"
01301                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"SpanAng";
01302                         dump_general_header();
01303                         std::cout<<std::endl;
01304                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<""
01305                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<""
01306                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg"
01307                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg";
01308                         dump_general_note();
01309                         std::cout<<std::endl;
01310                 }
01311                 int index = Polycone_GenIndex[i];
01312                 int repNo = RepNo[index];
01313                 for ( G4int j = 0; j < repNo; j++ ){
01314                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<i
01315                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Polycone_numZ[i]
01316                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Polycone_StartAng[i][j]/deg
01317                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<Polycone_SpanAng[i][j]/deg;
01318                         dump_general_value(index);
01319                         std::cout<<std::endl;
01320                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<"No."
01321                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Z"
01322                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"RMin"
01323                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"RMax"
01324                                 <<std::endl;
01325                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<""
01326                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01327                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01328                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01329                                 <<std::endl;
01330                         for (int k = 0; k< Polycone_numZ[i]; k++){
01331                                 std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<k
01332                                         <<std::setiosflags(std::ios::left)<<std::setw(10) <<Polycone_Z[i][k][j]/mm
01333                                         <<std::setiosflags(std::ios::left)<<std::setw(10) <<Polycone_RMin[i][k][j]/mm
01334                                         <<std::setiosflags(std::ios::left)<<std::setw(10) <<Polycone_RMax[i][k][j]/mm
01335                                         <<std::endl;
01336                         }
01337                 }
01338         }
01339         for( G4int i = 0; i < ExtrudedSolidNo; i++ ){
01340                 if ( i == 0 ){
01341                         std::cout<<"=>ExtrudedSolid info:"<<std::endl;
01342                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<"No."
01343                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"numZ"
01344                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"numP";
01345                         dump_general_header();
01346                         std::cout<<std::endl;
01347                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<""
01348                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<""
01349                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"";
01350                         dump_general_note();
01351                         std::cout<<std::endl;
01352                 }
01353                 int index = ExtrudedSolid_GenIndex[i];
01354                 int repNo = RepNo[index];
01355                 for ( G4int j = 0; j < repNo; j++ ){
01356                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<i
01357                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<ExtrudedSolid_numZ[i]
01358                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<ExtrudedSolid_numP[i];
01359                         dump_general_value(index);
01360                         std::cout<<std::endl;
01361                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<"No."
01362                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Z"
01363                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"X0"
01364                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Y0"
01365                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Scale"
01366                                 <<std::endl;
01367                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<""
01368                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01369                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01370                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01371                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<""
01372                                 <<std::endl;
01373                         for (int k = 0; k< ExtrudedSolid_numZ[i]; k++){
01374                                 std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<k
01375                                         <<std::setiosflags(std::ios::left)<<std::setw(10) <<ExtrudedSolid_Z[i][k][j]/mm
01376                                         <<std::setiosflags(std::ios::left)<<std::setw(10) <<ExtrudedSolid_X0[i][k][j]/mm
01377                                         <<std::setiosflags(std::ios::left)<<std::setw(10) <<ExtrudedSolid_Y0[i][k][j]/mm
01378                                         <<std::setiosflags(std::ios::left)<<std::setw(10) <<ExtrudedSolid_Scale[i][k][j]
01379                                         <<std::endl;
01380                         }
01381                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<"No."
01382                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"X"
01383                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Y"
01384                                 <<std::endl;
01385                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<""
01386                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01387                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01388                                 <<std::endl;
01389                         for (int k = 0; k< ExtrudedSolid_numP[i]; k++){
01390                                 std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<k
01391                                         <<std::setiosflags(std::ios::left)<<std::setw(10) <<ExtrudedSolid_X[i][k][j]/mm
01392                                         <<std::setiosflags(std::ios::left)<<std::setw(10) <<ExtrudedSolid_Y[i][k][j]/mm
01393                                         <<std::endl;
01394                         }
01395                 }
01396         }
01397         for( G4int i = 0; i < BooleanSolidNo; i++ ){
01398                 if ( i == 0 ){
01399                         std::cout<<"=>BooleanSolid info:"<<BooleanSolidNo<<std::endl;
01400                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(10) <<"type."
01401                                  <<std::setiosflags(std::ios::left)<<std::setw(20) <<"solid1"
01402                                  <<std::setiosflags(std::ios::left)<<std::setw(20) <<"solid2"
01403                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<"PosX"
01404                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<"PosY"
01405                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<"PosZ"
01406                                          <<std::setiosflags(std::ios::left)<<std::setw(6) <<"RepNo"
01407                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Ephi"
01408                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Etheta"
01409                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Epsi";
01410                         dump_general_header();
01411                         std::cout<<std::endl;
01412                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(10) <<""
01413                                  <<std::setiosflags(std::ios::left)<<std::setw(20) <<""
01414                                  <<std::setiosflags(std::ios::left)<<std::setw(20) <<""
01415                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01416                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01417                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01418                                          <<std::setiosflags(std::ios::left)<<std::setw(6) <<""
01419                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg"
01420                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg"
01421                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg";
01422                         dump_general_note();
01423                         std::cout<<std::endl;
01424                 } 
01425                 int index = BooleanSolid_GenIndex[i];
01426                 int repNo = RepNo[index];
01427                 for ( G4int j = 0; j < repNo; j++ ){
01428                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(5) <<i
01429                                 <<std::setiosflags(std::ios::left)<<std::setw(10) <<BooleanSolid_type[i]
01430                                 <<std::setiosflags(std::ios::left)<<std::setw(20)<<BooleanSolid_sol1[i]<<" "
01431                                 <<std::setiosflags(std::ios::left)<<std::setw(20)<<BooleanSolid_sol2[i]<<" ";
01432                         if (BooleanSolid_PosType[i]=="Cartesian"){
01433                                 std::cout<<std::setiosflags(std::ios::left)<<std::setw(2) <<"C"
01434                                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<BooleanSolid_Pos[i][j].x()/mm
01435                                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<BooleanSolid_Pos[i][j].y()/mm
01436                                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<BooleanSolid_Pos[i][j].z()/mm;
01437                         }
01438                         else if (BooleanSolid_PosType[i]=="Polar"){
01439                                 std::cout<<std::setiosflags(std::ios::left)<<std::setw(2) <<"P"
01440                                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<BooleanSolid_Pos[i][j].rho()/mm
01441                                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<BooleanSolid_Pos[i][j].phi()/deg
01442                                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<BooleanSolid_Pos[i][j].z()/mm;
01443                         }
01444                         else if (BooleanSolid_PosType[i]=="Spherical"){
01445                                 std::cout<<std::setiosflags(std::ios::left)<<std::setw(2) <<"S"
01446                                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<BooleanSolid_Pos[i][j].mag()/mm
01447                                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<BooleanSolid_Pos[i][j].phi()/deg
01448                                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<BooleanSolid_Pos[i][j].theta()/deg;
01449                         }
01450                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(10) << BooleanSolid_Ephi[i][j]/deg
01451                                          <<std::setiosflags(std::ios::left)<<std::setw(10) << BooleanSolid_Etheta[i][j]/deg
01452                                          <<std::setiosflags(std::ios::left)<<std::setw(10) << BooleanSolid_Epsi[i][j]/deg;
01453                         dump_general_value(index,j);
01454                         std::cout<<std::endl;
01455                 }
01456         }
01457 }
01458 
01459 void SimpleGeometryParameter::dump_general_header(){
01460         std::cout<<std::setiosflags(std::ios::left)<<std::setw(15)<<"Name"
01461                  <<std::setiosflags(std::ios::left)<<std::setw(15)<<"MotherName"
01462                  <<std::setiosflags(std::ios::left)<<std::setw(15)<<"Matierial"
01463                  <<std::setiosflags(std::ios::left)<<std::setw(15)<<"SDName"
01464                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"PosX"
01465                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"PosY"
01466                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"PosZ"
01467                  <<std::setiosflags(std::ios::left)<<std::setw(6) <<"RepNo"
01468                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Ephi"
01469                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Etheta"
01470                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"Epsi";
01471 }
01472 
01473 void SimpleGeometryParameter::dump_general_note(){
01474         std::cout<<std::setiosflags(std::ios::left)<<std::setw(15)<<""
01475                  <<std::setiosflags(std::ios::left)<<std::setw(15)<<""
01476                  <<std::setiosflags(std::ios::left)<<std::setw(15)<<""
01477                  <<std::setiosflags(std::ios::left)<<std::setw(15)<<""
01478                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01479                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01480                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"mm"
01481                  <<std::setiosflags(std::ios::left)<<std::setw(6) <<""
01482                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg"
01483                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg"
01484                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<"deg";
01485 }
01486 
01487 void SimpleGeometryParameter::dump_general_value(G4int index, G4int j){
01488         std::cout<<std::setiosflags(std::ios::left)<<std::setw(15)<<Name[index]<<" ";
01489         if (!SolidBoolean[index]){
01490                 std::cout<<std::setiosflags(std::ios::left)<<std::setw(15)<<MotherName[index]<<" "
01491                                  <<std::setiosflags(std::ios::left)<<std::setw(15)<<Material[index]<<" "
01492                                  <<std::setiosflags(std::ios::left)<<std::setw(15)<<SDName[index]<<" ";
01493                 if (PosType[index]=="Cartesian"){
01494                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(2) <<"C"
01495                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<Pos[index][j].x()/mm
01496                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<Pos[index][j].y()/mm
01497                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<Pos[index][j].z()/mm;
01498                 }
01499                 else if (PosType[index]=="Polar"){
01500                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(2) <<"P"
01501                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<Pos[index][j].rho()/mm
01502                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<Pos[index][j].phi()/deg
01503                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<Pos[index][j].z()/mm;
01504                 }
01505                 else if (PosType[index]=="Spherical"){
01506                         std::cout<<std::setiosflags(std::ios::left)<<std::setw(2) <<"S"
01507                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<Pos[index][j].mag()/mm
01508                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<Pos[index][j].phi()/deg
01509                                          <<std::setiosflags(std::ios::left)<<std::setw(10) <<Pos[index][j].theta()/deg;
01510                 }
01511                 std::cout<<std::setiosflags(std::ios::left)<<std::setw(6) <<RepNo[index]
01512                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<Ephi[index][j]/deg
01513                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<Etheta[index][j]/deg
01514                                  <<std::setiosflags(std::ios::left)<<std::setw(10) <<Epsi[index][j]/deg;
01515         }
01516         else{
01517                 std::cout<<"            [BOOLEANCOMPONENT!]";
01518         }
01519 }