./atlas/MuonSpectrometer/MuonGeoModel/src/SaddleBrepsBuilder.cxx

Report problems to ATLAS LXR Team (with time and IP address indicated)
The LXR Cross Referencer

[ source navigation ]
[ diff markup ]
[ identifier search ]
[ general search ]
Architecture:	[ linux ]
Version:	[ head ] [ nightly ] [ GaudiDev ]
Links to LXR source navigation pages for stable releases
[ 12.*.* ] [ 13.*.* ] [ 14.*.* ] [ 15.*.* ]
001 //Writed by Andrei Barashkou JINR(Russia,Dubna) 2007.
002 #include "MuonGeoModel/SaddleBrepsBuilder.h"
003 #include "AthenaKernel/getMessageSvc.h"
004 
005 #include "RDBAccessSvc/IRDBRecord.h"
006 #include "RDBAccessSvc/IRDBRecordset.h"
007 #include "RDBAccessSvc/IRDBAccessSvc.h"
008 
009 #include "MuonGeoModel/ArrayFunction.h"
010 
011 #include "GeoModelKernel/GeoBox.h"
012 #include "GeoModelKernel/GeoTube.h"
013 #include "GeoModelKernel/GeoTubs.h"
014 #include "GeoModelKernel/GeoPcon.h"  
015 #include "GeoModelKernel/GeoTrd.h"
016 #include "GeoModelKernel/GeoTrap.h"
017 #include "GeoModelKernel/GeoPara.h"
018 #include "GeoModelKernel/GeoPgon.h"
019 #include "GeoModelKernel/GeoSimplePolygonBrep.h"
020 #include "GeoModelKernel/GeoMaterial.h"
021 #include "GeoModelKernel/GeoLogVol.h"
022 #include "GeoModelKernel/GeoPhysVol.h"
023 #include "GeoModelKernel/GeoFullPhysVol.h"
024 #include "GeoModelKernel/GeoTransform.h"
025 #include "GeoModelKernel/GeoAlignableTransform.h"
026 #include "GeoModelKernel/GeoNameTag.h"
027 #include "GeoModelKernel/GeoShapeShift.h"
028 #include "GeoModelKernel/GeoShapeUnion.h"
029 #include "GeoModelKernel/GeoShapeSubtraction.h"
030 #include "GeoModelKernel/GeoSerialTransformer.h" 
031 #include "GeoModelKernel/GeoIdentifierTag.h"
032 #include "GeoModelSvc/StoredMaterialManager.h"
033 
034 #include "StoreGate/StoreGateSvc.h"
035 #include "CLHEP/GenericFunctions/Variable.hh"
036 
037 #include <stdexcept>
038 #include <vector>
039 #include <iomanip>  
040 
041 #include <sstream>
042 typedef std::stringstream  my_sstream;
043 typedef std::ostringstream my_osstream;
044 
045 using namespace Genfun;
046 using namespace GeoXF;
047 
048 namespace MuonGM {
049 SaddleBrepsBuilder::SaddleBrepsBuilder( StoreGateSvc  *pDetStore,
050                                     IRDBAccessSvc *pRDBAccess, 
051                                     std::string    geoTag,
052                                     std::string    geoNode )    :
053     m_pRDBAccess(pRDBAccess),
054     m_pDetStore (pDetStore)
055 {
056 
057   _unavailableData = false;
058   
059 //   m_Saddlebrvp     = pRDBAccess->getRecordset("SADDLEBRVP","SADDLEBRVP-00");
060 //   m_Saddlebrvbp    = pRDBAccess->getRecordset("SADDLEBRVBP","SADDLEBRVBP-00");
061 //   m_Saddlebrvn     = pRDBAccess->getRecordset("SADDLEBRVN","SADDLEBRVN-00");
062 // //  m_Fbrvsbo   = pRDBAccess->getRecordset("FBRVSBO","FBRVSBO-TEST-00");
063 //   m_Saddlebrvstu   = pRDBAccess->getRecordset("SADDLEBRVSTU","SADDLEBRVSTU-00");
064 // //  m_Fbrvsbr   = pRDBAccess->getRecordset("FBRVSBR","FBRVSBR-TEST-00");
065 // //  m_Feboxes   = pRDBAccess->getRecordset("FEBOXES","FEBOXES-TEST-00");
066 //   m_Saddleetubes   = pRDBAccess->getRecordset("SADDLEETUBES","SADDLEETUBES-00");
067 // //  m_Febreps   = pRDBAccess->getRecordset("FEBREPS","FEBREPS-TEST-00");
068 // //  m_Febrepsxy = pRDBAccess->getRecordset("FEBREPSXY","FEBREPSXY-TEST-00");
069 //   m_Saddle     = pRDBAccess->getRecordset("SADDLE","SADDLE-00");
070 
071   m_Saddlebrvp     = pRDBAccess->getRecordset("SADDLEBRVP", geoTag, geoNode);
072   m_Saddlebrvbp    = pRDBAccess->getRecordset("SADDLEBRVBP", geoTag, geoNode);
073   m_Saddlebrvn     = pRDBAccess->getRecordset("SADDLEBRVN", geoTag, geoNode);
074   //  m_Fbrvsbo   = pRDBAccess->getRecordset("FBRVSBO","FBRVSBO-TEST-00");
075   m_Saddlebrvstu   = pRDBAccess->getRecordset("SADDLEBRVSTU", geoTag, geoNode);
076   //  m_Fbrvsbr   = pRDBAccess->getRecordset("FBRVSBR","FBRVSBR-TEST-00");
077   //  m_Feboxes   = pRDBAccess->getRecordset("FEBOXES","FEBOXES-TEST-00");
078   m_Saddleetubes   = pRDBAccess->getRecordset("SADDLEETUBES", geoTag, geoNode);
079   //  m_Febreps   = pRDBAccess->getRecordset("FEBREPS","FEBREPS-TEST-00");
080   //  m_Febrepsxy = pRDBAccess->getRecordset("FEBREPSXY","FEBREPSXY-TEST-00");
081   m_Saddle     = pRDBAccess->getRecordset("SADDLE", geoTag, geoNode);
082   if (m_Saddlebrvp->size()*m_Saddlebrvbp->size()*m_Saddlebrvn->size()*
083       m_Saddlebrvstu->size()*m_Saddleetubes->size()*m_Saddle->size()==0) _unavailableData = true;
084 
085   std::string Iron = "Iron";
086   
087   std::string Aluminium = "Alum";
088 
089   MsgStream log( Athena::getMessageSvc(), "MuGM:SaddleBrepsBuilder" );
090   if (!_unavailableData) log << MSG::INFO << "All data fetched with tag <" << geoTag << ">" << endreq;
091   else log << MSG::INFO << "No data found with tag <" << geoTag << ">" << endreq;
092 }
093 
094 void SaddleBrepsBuilder::buildSaddleBreps( GeoPhysVol* container ) 
095 {
096         //std::cout<<"  constructor1 "<<std::endl;
097 
098         const StoredMaterialManager*  theMaterialManager;
099         if ( StatusCode::SUCCESS != m_pDetStore->retrieve( theMaterialManager, "MATERIALS" ) ) 
100         {
101             return;
102         } 
103         int m = 0; //need for creating dif. Breps
104         int n = 0; //need for position of volumes
105         int f = 0; //for tube subtraction
106         //int g = 0; //for box subtraction
107         //int q = 0; //for brep subtraction
108         //  double tolerance = 0.5 * mm;
109   
110         int Numbreps    = (int)(*m_Saddle)[0]->getFloat("SADL_NUMBREPS");
111   
112         double   Xpos[100];
113         double   Ypos[100];
114         double   Zpos[100];
115         double Zposgl[100];
116         double  Zposb[100];
117         double Xposgl[100];
118         double Yposgl[100];
119         double   Rotx[100];
120         double   Roty[100];
121         double   Rotz[100];
122         for (int k = 0; k < Numbreps; k++)
123         {
124             //  data from Saddlebrvn  
125             int NumVol    = (int)(*m_Saddlebrvn)[k]->getFloat("NUMVOL");
126             int Nump      = (int)(*m_Saddlebrvn)[k]->getFloat("NUMP");
127             double dZ     = (*m_Saddlebrvn)[k]->getFloat("DZ") * mm;
128             //    int Numembo   = (*m_Saddlebrvn)[k]->getInt("NUMEMBO");
129             int Numemtu   = (int)(*m_Saddlebrvn)[k]->getFloat("NUMEMTU");
130             const int SymX      = (int)(*m_Saddlebrvn)[k]->getFloat("SYMX");
131             const int SymY      = (int)(*m_Saddlebrvn)[k]->getFloat("SYMY");
132             const int SymZ      = (int)(*m_Saddlebrvn)[k]->getFloat("SYMZ");
133             //    int Numembr     = (*m_Saddlebrvn)[k]->getInt("NUMEMBR");
134     
135             //    const std::string ExFName        = getName(*m_Efbrvebp->"VOLNAME"); 
136             //    const std::string feetMaterial  = getMaterial(*m_Efbrven, "MATERIAL");
137             const std::string feetMaterial = getMaterial( "Iron" );
138 //             //ispul'zui kol-vo ob'emov i vinisi za predeli zikla ->v nachalo
139 //             double Xpos[Nump + m];
140 //             double Ypos[Nump + m];
141 //             double Zpos[NumVol + n];
142 //             double Zposgl[NumVol + n];
143 //             double Zposb[NumVol + n];
144 //             double Xposgl[NumVol + n];
145 //             double Yposgl[NumVol + n];
146 //             double Rotx[NumVol + n];
147 //             double Roty[NumVol + n];
148 //             double Rotz[NumVol +n];
149             //std::cout <<" m: "<<m <<std::endl;
150   
151             for (int i = m; i < Nump + m; i++)
152             {
153                 Xpos[i] = (*m_Saddlebrvp)[i]->getFloat("XPOS") * mm;
154                 Ypos[i] = (*m_Saddlebrvp)[i]->getFloat("YPOS") * mm;    
155             }
156 
157             GeoSimplePolygonBrep* BrepPlate = new GeoSimplePolygonBrep(dZ/2);
158             for (int i = m; i < Nump + m ; i++)
159             {
160                 BrepPlate->addVertex(Xpos[i],Ypos[i]);          //description breps volume
161             }
162                                               
163             m = m + Nump;
164 
165             const GeoShape* sBrepPlate = &( *BrepPlate );
166 
167             //GeoTubs* EmptyTube[Numemtu+f]; HepTransform3D trlEmptyTube[Numemtu+f];
168             GeoTubs* EmptyTube[100]; HepTransform3D trlEmptyTube[100];
169             //GeoBox* EmptyBox[Numembo+g]; HepTransform3D trlEmptyBox[Numembo+g];
170             //GeoSimplePolygonBrep* EmptyBrep[Numembr]; HepTransform3D trlEmptyBrep[Numembr];
171 
172             //tubes for subtraction
173             for (int i = f; i < Numemtu + f; i++)
174             {
175                 int Whichtube       = (int)(*m_Saddlebrvstu)[i]->getFloat("WHICHTUBE");
176                 double Rminetube    = (*m_Saddleetubes)[Whichtube]->getFloat("RMIN") * mm;
177                 double Rmaxetube    = (*m_Saddleetubes)[Whichtube]->getFloat("RMAX") * mm;
178                 double DZetube      = (*m_Saddleetubes)[Whichtube]->getFloat("DZ") * mm;
179                 //  double Xposetube    = (*m_Saddleetubes)[Whichtube]->getFloat("XPOS") * mm;
180                 //  double Yposetube    = (*m_Saddleetubes)[Whichtube]->getFloat("YPOS") * mm;
181                 double Xposetube    = -(*m_Saddlebrvbp)[Whichtube]->getFloat("XPOSG") * mm;
182                 double Yposetube    = -(*m_Saddlebrvbp)[Whichtube]->getFloat("YPOSG") * mm;
183                 double Zposetube    = (*m_Saddleetubes)[Whichtube]->getFloat("ZPOS") * mm;
184                 double RotXetube    = (*m_Saddleetubes)[Whichtube]->getFloat("ROTX") * deg;
185                 double RotYetube    = (*m_Saddleetubes)[Whichtube]->getFloat("ROTY") * deg;
186                 double RotZetube    = (*m_Saddleetubes)[Whichtube]->getFloat("ROTZ") * deg;
187                        
188                 EmptyTube[i] = new GeoTubs(Rminetube, Rmaxetube, DZetube/2, 301.8 * M_PI/180, 32.* M_PI/180 );
189             
190                 trlEmptyTube[i] = HepTranslate3D(Xposetube, Yposetube, Zposetube) * HepRotateY3D(RotYetube)
191                                   * HepRotateZ3D(RotZetube) * HepRotateX3D(RotXetube);
192 
193                 sBrepPlate = &( sBrepPlate->subtract(*EmptyTube[i]) << trlEmptyTube[i] );
194             }
195   
196             f = f + Numemtu;
197   
198             //boxes for subtraction
199             /*  for (int i = g; i < Numembo + g; i++)
200                 {
201                 int WhichBox            = (*m_Fbrvsbo)[i]->getInt("WHICHBOX");
202                 double DXembox  = (*m_Feboxes)[WhichBox]->getFloat("DX") * mm;
203                 double DYembox        = (*m_Feboxes)[WhichBox]->getFloat("DY") * mm;
204                 double DZembox        = (*m_Feboxes)[WhichBox]->getFloat("DZ") * mm;
205                 double Xposembox      = (*m_Feboxes)[WhichBox]->getFloat("XPOS") * mm;
206                 double Yposembox      = (*m_Feboxes)[WhichBox]->getFloat("YPOS") * mm;
207                 double Zposembox      = (*m_Feboxes)[WhichBox]->getFloat("ZPOS") * mm;
208                 double RotXembox      = (*m_Feboxes)[WhichBox]->getFloat("ROTX") * deg;
209                 double RotYembox      = (*m_Feboxes)[WhichBox]->getFloat("ROTY") * deg;
210                 double RotZembox      = (*m_Feboxes)[WhichBox]->getFloat("ROTZ") * deg;
211   
212                 EmptyBox[i] = new GeoBox(DXembox/2, DYembox/2, DZembox/2);
213   
214                 trlEmptyBox[i] = HepTranslate3D(Xposembox, Yposembox, Zposembox) * HepRotateZ3D(RotZembox)
215                 * HepRotateY3D(RotYembox) * HepRotateX3D(RotXembox);
216 
217                 sSidePlate = &( sSidePlate->subtract( (*EmptyBox[i]) << trlEmptyBox[i] ) );
218                 }
219   
220                 g = g + Numembo;  
221             */
222             //breps for subtraction
223             /*    double Xpossub[4];
224                   double Ypossub[4];
225 
226                   for (int i = q; i < Numembr + q; i++)
227                   {
228                   int WhichBrep          = (*m_Fbrvsbr)[i]->getInt("WHICHBREP");
229                   double Dzembrep        = (*m_Febreps)[WhichBrep]->getFloat("DZ") * mm;
230                   double Zposembrep      = (*m_Febreps)[WhichBrep]->getFloat("ZPOS") * mm;
231                   double RotXembrep      = (*m_Febreps)[WhichBrep]->getFloat("ROTX") * deg;
232                   double RotYembrep      = (*m_Febreps)[WhichBrep]->getFloat("ROTY") * deg;
233                   double RotZembrep      = (*m_Febreps)[WhichBrep]->getFloat("ROTZ") * deg;
234               
235                   for (int j = 0; j < 4; j++)
236                   {
237                   Xpossub[j] = (*m_Febrepsxy)[j]->getFloat("XPOS") * mm;
238                   Ypossub[j] = (*m_Febrepsxy)[j]->getFloat("YPOS") * mm;
239                   }
240                   EmptyBrep[i] = new GeoSimplePolygonBrep(Dzembrep/2);
241                   for (int j = 0; j < 4; j++)
242                   {
243                   EmptyBrep[i]->addVertex(Xpossub[j],Ypossub[j]);
244                   }
245       
246                   trlEmptyBrep[i] = HepTranslateZ3D(Zposembrep) * HepRotateZ3D(RotZembrep)
247                   * HepRotateY3D(RotYembrep) * HepRotateX3D(RotXembrep); 
248   
249                   sSidePlate = &( sSidePlate->subtract( (*EmptyBrep[i]) << trlEmptyBrep[i] ) );                                 
250                   }                             
251 
252                   q = q + Numembr;
253             */     
254             /*    for (int i = 0; i < SymX; i++)
255                   {
256                   HepTransform3D trlMirBrepPlate = HepReflectX3D(-1100.);
257     
258                   sBrepPlate = &( sBrepPlate->add( (*sBrepPlate) << trlMirBrepPlate ) );
259                   }
260             */    
261 
262             //replication and position of volume  
263             for (int j = n; j < NumVol + n; j++)
264             {
265                 Zposgl[j] = (*m_Saddlebrvbp)[j]->getFloat("ZPOSG") * mm;
266                 Zposb[j]  = (*m_Saddlebrvbp)[j]->getFloat("ZPOSB") * mm;
267                 Xposgl[j] = (*m_Saddlebrvbp)[j]->getFloat("XPOSG") * mm;
268                 Yposgl[j] = (*m_Saddlebrvbp)[j]->getFloat("YPOSG") * mm;
269                 Rotx[j] = (*m_Saddlebrvbp)[j]->getFloat("ROTX") * deg;
270                 Roty[j] = (*m_Saddlebrvbp)[j]->getFloat("ROTY") * deg;
271                 Rotz[j] = (*m_Saddlebrvbp)[j]->getFloat("ROTZ") * deg;
272                 Zpos[j] = Zposgl[j] + Zposb[j];
273 
274                 //          HepTransform3D trlBrepPlate = HepTranslate3D(Xposgl[j], Yposgl[j], Zpos[j]) * HepRotateZ3D(Rotz[j])
275                 //                      * HepRotateY3D(Roty[j]) * HepRotateX3D(Rotx[j]);
276                 HepTransform3D trlBrepPlate = HepTranslate3D(Xposgl[j], Yposgl[j], 0.) * HepRotateZ3D(Rotz[j])
277                                               * HepRotateY3D(Roty[j]) * HepRotateX3D(Rotx[j]);
278    
279                 const GeoShape& posBrepPlate = ( *sBrepPlate << trlBrepPlate );
280     
281                 GeoLogVol*  lBrepPlate = new GeoLogVol( "SaddleBrepPlate",
282                                                         &posBrepPlate,
283                                                         theMaterialManager->getMaterial(feetMaterial) );
284                 /*  std::cout<<" SaddleBrepsBuilder constructor1 "<<std::endl;
285                     GeoLogVol*  lBrepPlate = new GeoLogVol( "SaddleBrepPlate",
286                     *&sBrepPlate,
287                     theMaterialManager->getMaterial(feetMaterial) );
288                 */
289                 GeoPhysVol* pBrepPlate = new GeoPhysVol(lBrepPlate);
290   
291                 //  std::cout<<" SaddleBrepsBuilder constructor2 "<<std::endl;
292                 //----------------------------------------------------------------------------------------------------- 
293                 //  const int nXpos = SymX + 1.;
294                 const int nXpos = SymX + 1;
295                 const int nYpos = SymY + 1;
296                 const int nZpos = SymZ + 1;
297 
298                 //  double  rotAngleX[nXpos], xPosBrepPlate[nXpos], rotAngleY[nYpos], yPosBrepPlate[nYpos], rotAngleZ[nZpos], zPosBrepPlate[nZpos];
299 
300                 double rotAngleX[2] = { 0, M_PI }; double xPosBrepPlate[2] = { Xposgl[j], -Xposgl[j] };
301                 double rotAngleY[1] = { 0 }; double yPosBrepPlate[1] = {Yposgl[j]};
302                 double rotAngleZ[2] = { 0, M_PI }; double zPosBrepPlate[2] = {Zpos[j], -Zpos[j]};
303                 const int nAllpos = nXpos * nYpos * nZpos;
304                 //                double zPosBrepsAux[nAllpos], xPosBrepsAux[nAllpos], yPosBrepsAux[nAllpos], rotAngleBrepsAuxX[nAllpos],
305                 //                    rotAngleBrepsAuxY[nAllpos], rotAngleBrepsAuxZ[nAllpos];
306                 double zPosBrepsAux[100], xPosBrepsAux[100], yPosBrepsAux[100], rotAngleBrepsAuxX[100],
307                     rotAngleBrepsAuxY[100], rotAngleBrepsAuxZ[100];
308 
309                 for ( int w = 0; w < nAllpos; w++ )
310                 {
311                     int ww = w % (nAllpos / nZpos),
312                         ss = w / (nAllpos / nXpos),
313                         ee = w / (nAllpos / nYpos);
314                     //std::cout <<" ww: "<<ww <<std::endl;
315                     //std::cout <<" ss: "<<ss <<std::endl;
316                     //std::cout <<" ee: "<<ee <<std::endl;
317                     zPosBrepsAux[w]     = zPosBrepPlate[ww];
318                     //          std::cout <<" ZPosBrepsAux: "<<zPosBrepsAux[w] <<std::endl;
319                     xPosBrepsAux[w]     = xPosBrepPlate[ss];
320                     //          std::cout <<" XPosBrepsAux: "<<xPosBrepsAux[w] <<std::endl;
321                     yPosBrepsAux[w]     = yPosBrepPlate[ee];
322                     //          std::cout <<" YPosBrepsAux: "<<yPosBrepsAux[w] <<std::endl;
323                     rotAngleBrepsAuxX[w] = rotAngleX[ss];
324                     //          std::cout <<" rotAngleBrepsAuxX: "<<rotAngleBrepsAuxX[w] <<std::endl;
325                     rotAngleBrepsAuxY[w] = rotAngleY[ee];
326                     //          std::cout <<" rotAngleBrepsAuxY: "<<rotAngleBrepsAuxY[w] <<std::endl;
327                     rotAngleBrepsAuxZ[w] = rotAngleZ[ss];
328                     //          std::cout <<" rotAngleBrepsAuxZ: "<<rotAngleBrepsAuxZ[w] <<std::endl;
329                 }
330 
331                 GENFUNCTION fBrepsRotX = ArrayFunction( rotAngleBrepsAuxX, rotAngleBrepsAuxX + nAllpos );
332                 GENFUNCTION fBrepsTrlX = ArrayFunction( xPosBrepsAux, xPosBrepsAux + nAllpos );
333                 GENFUNCTION fBrepsRotY = ArrayFunction( rotAngleBrepsAuxY, rotAngleBrepsAuxY + nAllpos );
334                 GENFUNCTION fBrepsTrlY = ArrayFunction( yPosBrepsAux, yPosBrepsAux + nAllpos );
335                 GENFUNCTION fBrepsRotZ = ArrayFunction( rotAngleBrepsAuxZ, rotAngleBrepsAuxZ +  nAllpos );
336                 GENFUNCTION fBrepsTrlZ = ArrayFunction( zPosBrepsAux, zPosBrepsAux +  nAllpos );
337 
338                 TRANSFUNCTION XFBrepPlate   = Pow( HepTranslateX3D(1.0), fBrepsTrlX ) *
339                                               Pow( HepTranslateY3D(1.0), fBrepsTrlY ) *                           
340                                               Pow( HepTranslateZ3D(1.0), fBrepsTrlZ ) * 
341                                               Pow( HepRotateX3D(1.0), fBrepsRotX ) *
342                                               Pow( HepRotateY3D(1.0), fBrepsRotY ) *
343                                               Pow( HepRotateZ3D(1.0), fBrepsRotZ );
344 
345                 GeoSerialTransformer* sxBrepPlate = new GeoSerialTransformer( pBrepPlate,
346                                                                               &XFBrepPlate,
347                                                                               nAllpos );
348 
349                 container->add(sxBrepPlate);
350 
351                 //  GeoSerialTransformer* sxBrepPlate = new GeoSerialTransformer( pBrepPlate,
352                 //                                                                &XFBrepPlate,
353                 //                                                                nZpos * nXpos * nYpos );
354 
355 
356                 //  container->add(pBrepPlate);
357             }
358       
359             n = n + NumVol;      
360             NumVol = 0;
361             Nump         = 0;
362             dZ   = 0.;      
363             //std::cout<<" TEto konez progi sd"<<std::endl;
364         }
365 }
366     
367 std::string SaddleBrepsBuilder::getMaterial( std::string materialName ) 
368 {
369     MsgStream log(Athena::getMessageSvc(), "MuonGeoModel");
370     if ( materialName == "Alum" )
371     {
372         return "std::Aluminium";
373     }
374     else if ( materialName == "Iron" )  
375     {
376         return "std::Iron";
377     }  
378     else if ( materialName == "Fe50"  ||  materialName == "Al67" )   
379     {
380         return "toro::" + materialName;
381     }
382     else 
383     {
384         log  <<  " SaddleBrepsBuilder::getMaterial: material "  <<  materialName  
385              <<  " not defined! "
386              <<  " Take Aluminium instead."
387              <<  endreq;
388         return "std::Aluminium";           
389     }  
390 }  
391 
392 } // namespace MuonGM
393
[ source navigation ]
[ diff markup ]
[ identifier search ]
[ general search ]
Due to the LXR bug, the updates fail sometimes to remove references to deleted files. The Saturday's full rebuilds fix these problems
This page was automatically generated by the LXR engine.