Reference Manual

Go to the documentation of this file.
00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 
00020 
00021 
00022 
00023 
00024 
00025 #include "Geometry/TrackerGeometryBuilder/interface/StackedTrackerGeometryBuilder.h"
00026 #include "Geometry/TrackerGeometryBuilder/interface/StackedTrackerGeometry.h"
00027 #include "Geometry/TrackerGeometryBuilder/interface/StackedTrackerDetUnit.h"
00028 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
00029 #include "Geometry/CommonDetUnit/interface/GeomDetUnit.h"
00030 #include "Geometry/CommonDetUnit/interface/GeomDetType.h"
00031 #include "DataFormats/SiPixelDetId/interface/PXBDetId.h"
00032 #include "DataFormats/SiPixelDetId/interface/PXFDetId.h"
00033 
00034 #include <iomanip>
00035 #include <fstream>
00036 #include <time.h>
00037 
00038 
00039 StackedTrackerGeometry* StackedTrackerGeometryBuilder::build( const TrackerGeometry* theTracker,
00040                                                               double radial_window,
00041                                                               double phi_window,
00042                                                               double z_window,
00043                                                               int truncation_precision,
00044                                                               bool makeDebugFile )
00045 {
00046   // For legacy compatibility it takes more inputs than it needs...
00047   time_t start_time = time (NULL);
00048   StackedTrackerGeometry* StackedTrackergeom = new StackedTrackerGeometry( theTracker );
00049   TrackingGeometry::DetUnitContainer::const_iterator trkIterator,trkIterator1,trkIterator2,trkIter_start,trkIter_end;
00050 
00052 
00058 
00060   std::map< uint32_t, uint32_t > layToStackMap;
00061   uint32_t                       nStackLayers = 0;
00062 
00064   std::map< uint32_t, double >                                                       *modToZMap;
00065   std::map< uint32_t, std::map< uint32_t, double > >                                 *rodToModToZMap;
00066   std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, double > > >           layToRodToModToZMap;
00067   std::map< uint32_t, double >::iterator                                             modToZMapIter;
00068   std::map< uint32_t, double >::iterator                                             modToZMapIterTemp;
00069   std::map< uint32_t, std::map< uint32_t, double > >::iterator                       rodToModToZMapIter;
00070   std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, double > > >::iterator layToRodToModToZMapIter;
00071 
00074   std::map< uint32_t, int >                                                          modToZIdxMap;
00075   std::map< uint32_t, std::map< uint32_t, int > >                                    rodToModToZIdxMap;
00076   std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, int > > >              layToRodToModToZIdxMap;
00077 
00079   std::map< uint32_t, uint32_t >                                                     modToModMap;
00080   std::map< uint32_t, std::map< uint32_t, uint32_t > >                               rodToModToModMap;
00081   std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, uint32_t > > >         layToRodToModToModMap;
00082 
00084   std::map< uint32_t, uint32_t > rodsPerLayer;
00085   std::map< uint32_t, uint32_t > modsPerRod;
00086 
00093 
00095   std::map< uint32_t, uint32_t > diskToStackMap;
00096   uint32_t                       nStackDisks = 0;
00097 
00099   std::map< uint32_t, double >                                                                             *modToPhiMap;
00100   std::map< uint32_t, std::map< uint32_t, double > >                                                       *ringToModToPhiMap;
00101   std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, double > > >                                 *diskToRingToModToPhiMap;
00102   std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, double > > > >           sideToDiskToRingToModToPhiMap;
00103   std::map< uint32_t, double >::iterator                                                                   modToPhiMapIter;
00104   std::map< uint32_t, double >::iterator                                                                   modToPhiMapIterTemp;
00105   std::map< uint32_t, std::map< uint32_t, double > >::iterator                                             ringToModToPhiMapIter;
00106   std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, double > > >::iterator                       diskToRingToModToPhiMapIter;
00107   std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, double > > > >::iterator sideToDiskToRingToModToPhiMapIter;
00108 
00111   std::map< uint32_t, int >                                                                                modToPhiIdxMap;
00112   std::map< uint32_t, std::map< uint32_t, int > >                                                          ringToModToPhiIdxMap;
00113   std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, int > > >                                    diskToRingToModToPhiIdxMap;
00114   std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, int > > > >              sideToDiskToRingToModToPhiIdxMap;
00115 
00120   std::map< uint32_t, std::map< uint32_t, uint32_t > >                                                     ringToModToModMap;
00121   std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, uint32_t > > >                               diskToRingToModToModMap;
00122   std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, uint32_t > > > >         sideToDiskToRingToModToModMap;
00123 
00125   std::map< uint32_t, uint32_t >                       ringsPerDisk;
00126   std::map< uint32_t, std::map< uint32_t, uint32_t > > modsPerRingPerDisk;
00127 
00128   { 
00129 
00130     bool firstElement = true;
00131     for ( trkIterator = theTracker->detUnits().begin();
00132           trkIterator != theTracker->detUnits().end();
00133           ++trkIterator )
00134     {
00135       DetId id = (**trkIterator).geographicalId();
00136       double r = (**trkIterator).position().perp();
00137       double z = (**trkIterator).position().z();
00138 
00141       if ( (**trkIterator).type().isBarrel() &&
00142            (**trkIterator).type().isTrackerPixel() &&
00143            (r>20.0) )
00144       {
00145         if (firstElement)
00146         {
00147           trkIter_start = trkIterator;
00148           firstElement = false;
00149         }
00150         trkIter_end = trkIterator; 
00151 
00152         uint32_t lay = PXBDetId(id).layer();
00153         uint32_t rod = PXBDetId(id).ladder();
00154         uint32_t mod = PXBDetId(id).module();
00155 
00157         if ( rodsPerLayer.find(lay) == rodsPerLayer.end() )
00158           rodsPerLayer.insert( std::make_pair(lay, 0) );
00159         if ( modsPerRod.find(lay) == modsPerRod.end() )
00160           modsPerRod.insert( std::make_pair(lay, 0) );
00161         if ( rod > rodsPerLayer[lay] )
00162           rodsPerLayer[lay] = rod;
00163         if ( mod > modsPerRod[lay] )
00164           modsPerRod[lay] = mod;
00165 
00166         double zModule = (**trkIterator).position().z();
00167 
00169         layToRodToModToZMapIter = layToRodToModToZMap.find(lay);
00170         if (layToRodToModToZMapIter != layToRodToModToZMap.end())
00171         {
00173           rodToModToZMap = &layToRodToModToZMapIter->second;
00174           rodToModToZMapIter = rodToModToZMap->find(rod);
00175           if (rodToModToZMapIter != rodToModToZMap->end())
00176           {
00178             modToZMap = &rodToModToZMapIter->second;
00179             modToZMapIter = modToZMap->find(mod);
00180             if (modToZMapIter != modToZMap->end())
00181             {
00183               std::cerr << "A L E R T! Layer-Rod-Module already present!" << std::endl;
00184             }
00185             else
00186             {
00188               modToZMap->insert( std::make_pair( mod, zModule ) );
00189             }
00190           }
00191           else
00192           {
00195             std::map< uint32_t, double > tempMap;
00196             tempMap.insert( std::make_pair( mod, zModule ) );
00197             rodToModToZMap->insert( std::make_pair( rod, tempMap ) );
00198           }
00199         }
00200         else
00201         {
00205           std::map< uint32_t, double > tempMap1;
00206           tempMap1.insert( std::make_pair( mod, zModule ) );
00207           std::map< uint32_t, std::map< uint32_t, double > > tempMap2;
00208           tempMap2.insert( std::make_pair( rod, tempMap1 ) );
00209           layToRodToModToZMap.insert( std::make_pair( lay, tempMap2 ) );
00210 
00211           if (layToStackMap.find(lay) == layToStackMap.end())
00212           {
00213             layToStackMap.insert( std::make_pair( lay , nStackLayers ) );     // assumes that the layers are ordered already
00214             nStackLayers++;
00215           }
00216         }
00217       }
00218 
00221       if ( (**trkIterator).type().isEndcap() &&
00222            (**trkIterator).type().isTrackerPixel() &&
00223            (fabs(z)>70.0) )
00224       {
00225         if (firstElement)
00226         {
00227           trkIter_start = trkIterator;
00228           firstElement = false;
00229         }
00230         trkIter_end = trkIterator; 
00231 
00232         uint32_t side = PXFDetId(id).side();
00233         uint32_t disk = PXFDetId(id).disk();
00234         uint32_t ring = PXFDetId(id).ring();
00235         uint32_t mod  = PXFDetId(id).module();
00236 
00238         if ( ringsPerDisk.find(disk) == ringsPerDisk.end() )
00239           ringsPerDisk.insert( std::make_pair(disk, 0) );
00240         if ( modsPerRingPerDisk.find(disk) == modsPerRingPerDisk.end() )
00241         {
00242           std::map< uint32_t, uint32_t > tempMap;
00243           tempMap.insert( std::make_pair(ring, 0) );
00244           modsPerRingPerDisk.insert( std::make_pair(disk, tempMap) );
00245         }
00246         if ( modsPerRingPerDisk.find(disk)->second.find(ring) == modsPerRingPerDisk.find(disk)->second.end() )
00247           modsPerRingPerDisk.find(disk)->second.insert( std::make_pair( ring, 0 ) );
00248         if ( ring > ringsPerDisk[disk] )
00249           ringsPerDisk[disk] = ring;
00250         if ( mod > modsPerRingPerDisk.find(disk)->second.find(ring)->second )
00251           modsPerRingPerDisk.find(disk)->second.find(ring)->second = mod;
00252 
00253         double phiModule = (**trkIterator).position().phi();
00254         if (phiModule < 0) phiModule += 2*M_PI;
00255 
00257         sideToDiskToRingToModToPhiMapIter = sideToDiskToRingToModToPhiMap.find(side);
00258         if (sideToDiskToRingToModToPhiMapIter != sideToDiskToRingToModToPhiMap.end())
00259         {
00261           diskToRingToModToPhiMap = &sideToDiskToRingToModToPhiMapIter->second;
00262           diskToRingToModToPhiMapIter = diskToRingToModToPhiMap->find(disk);
00263           if (diskToRingToModToPhiMapIter != diskToRingToModToPhiMap->end())
00264           {
00266             ringToModToPhiMap = &diskToRingToModToPhiMapIter->second;
00267             ringToModToPhiMapIter = ringToModToPhiMap->find(ring);
00268             if (ringToModToPhiMapIter != ringToModToPhiMap->end())
00269             {
00271               modToPhiMap = &ringToModToPhiMapIter->second;
00272               modToPhiMapIter = modToPhiMap->find(mod);
00273               if (modToPhiMapIter != modToPhiMap->end())
00274               {
00276                 std::cerr << "A L E R T! Side-Disk-Ring-Module already present!" << std::endl;
00277               }
00278               else
00279               {
00281                 modToPhiMap->insert( std::make_pair( mod, phiModule ) );
00282               }
00283             }
00284             else
00285             {
00288               std::map< uint32_t, double > tempMap;
00289               tempMap.insert( std::make_pair( mod, phiModule ) );
00290               ringToModToPhiMap->insert( std::make_pair( ring, tempMap ) );
00291             }
00292           }
00293           else
00294           {
00298             std::map< uint32_t, double > tempMap1;
00299             tempMap1.insert( std::make_pair( mod, phiModule ) );
00300             std::map< uint32_t, std::map< uint32_t, double > > tempMap2;
00301             tempMap2.insert( std::make_pair( ring, tempMap1 ) );
00302             diskToRingToModToPhiMap->insert( std::make_pair( disk, tempMap2 ) );
00303 
00304             if (diskToStackMap.find(disk) == diskToStackMap.end())
00305             {
00306               diskToStackMap.insert( std::make_pair( disk , nStackDisks ) );     // assumes that the disks are ordered already and FW/BW symmetric
00307               nStackDisks++;
00308             }
00309           }
00310         }
00311         else
00312         {
00317           std::map< uint32_t, double > tempMap1;
00318           tempMap1.insert( std::make_pair( mod, phiModule ) );
00319           std::map< uint32_t, std::map< uint32_t, double > > tempMap2;
00320           tempMap2.insert( std::make_pair( ring, tempMap1 ) );
00321           std::map< uint32_t, std::map< uint32_t, std::map< uint32_t, double > > > tempMap3;
00322           tempMap3.insert( std::make_pair( disk, tempMap2 ) );
00323           sideToDiskToRingToModToPhiMap.insert( std::make_pair( side, tempMap3 ) );
00324 
00325           if (diskToStackMap.find(disk) == diskToStackMap.end())
00326           {
00327             diskToStackMap.insert( std::make_pair( disk , nStackDisks ) );     // assumes that the disks are ordered already and FW/BW symmetric
00328             nStackDisks++;
00329           }
00330 
00331         }
00332       }
00335 
00336     }
00337     trkIter_end++;
00338 
00342     for ( layToRodToModToZMapIter = layToRodToModToZMap.begin();
00343           layToRodToModToZMapIter != layToRodToModToZMap.end();
00344           ++layToRodToModToZMapIter )
00345     {
00346       rodToModToZMap = &layToRodToModToZMapIter->second;
00347       rodToModToModMap.clear();
00348       rodToModToZIdxMap.clear();
00349 
00350       for ( rodToModToZMapIter = (*rodToModToZMap).begin();
00351             rodToModToZMapIter != (*rodToModToZMap).end();
00352             ++rodToModToZMapIter )
00353       {
00354         modToZMap = &rodToModToZMapIter->second;
00355         modToModMap.clear();
00356         modToZIdxMap.clear();
00357 
00358         for ( modToZMapIter = (*modToZMap).begin();
00359               modToZMapIter != (*modToZMap).end();
00360               ++modToZMapIter )
00361         {
00362           double tempZ = modToZMapIter->second;
00363           double deltaZ = 9999999.9;
00364           uint32_t closeMod = 0xFFFFFFFF;
00365           uint32_t smallerz = 0;
00366 
00368           for ( modToZMapIterTemp = (*modToZMap).begin();
00369                 modToZMapIterTemp != (*modToZMap).end();
00370                 ++modToZMapIterTemp )
00371           {
00372             if ( modToZMapIter->first == modToZMapIterTemp->first ) continue;
00373 
00374             double closeZ = modToZMapIterTemp->second;
00375             if ( fabs(closeZ - tempZ) < deltaZ )
00376             {
00377               deltaZ = fabs(closeZ - tempZ);
00378               closeMod = modToZMapIterTemp->first;
00379             }
00380 
00381             if ( tempZ > closeZ ) smallerz++;
00382           }
00383 
00386           modToModMap.insert( std::make_pair( modToZMapIter->first, closeMod ) );
00387           modToZIdxMap.insert( std::make_pair( modToZMapIter->first, smallerz ) );
00388         }
00389         rodToModToModMap.insert( std::make_pair( rodToModToZMapIter->first, modToModMap ) );
00390         rodToModToZIdxMap.insert( std::make_pair( rodToModToZMapIter->first, modToZIdxMap ) );
00391       }
00392       layToRodToModToModMap.insert( std::make_pair( layToRodToModToZMapIter->first, rodToModToModMap ) );
00393       layToRodToModToZIdxMap.insert( std::make_pair( layToRodToModToZMapIter->first, rodToModToZIdxMap ) );
00394     }
00395 
00399     for ( sideToDiskToRingToModToPhiMapIter = sideToDiskToRingToModToPhiMap.begin();
00400           sideToDiskToRingToModToPhiMapIter != sideToDiskToRingToModToPhiMap.end();
00401           ++sideToDiskToRingToModToPhiMapIter )
00402     {
00403       diskToRingToModToPhiMap = &sideToDiskToRingToModToPhiMapIter->second;
00404       diskToRingToModToModMap.clear();
00405       diskToRingToModToPhiIdxMap.clear();
00406 
00407       for ( diskToRingToModToPhiMapIter = (*diskToRingToModToPhiMap).begin();
00408             diskToRingToModToPhiMapIter != (*diskToRingToModToPhiMap).end();
00409             ++diskToRingToModToPhiMapIter )
00410       {
00411         ringToModToPhiMap = &diskToRingToModToPhiMapIter->second;
00412         ringToModToModMap.clear();
00413         ringToModToPhiIdxMap.clear();
00414 
00415         for ( ringToModToPhiMapIter = (*ringToModToPhiMap).begin();
00416               ringToModToPhiMapIter != (*ringToModToPhiMap).end();
00417               ++ringToModToPhiMapIter )
00418         {
00419           modToPhiMap = &ringToModToPhiMapIter->second;
00420           modToModMap.clear();
00421           modToPhiIdxMap.clear();
00422 
00423           for ( modToPhiMapIter = (*modToPhiMap).begin();
00424                 modToPhiMapIter != (*modToPhiMap).end();
00425                 ++modToPhiMapIter )
00426           {
00427             double tempPhi = modToPhiMapIter->second;
00428             double deltaPhi = 9999999.9;
00429             uint32_t closeMod = 0xFFFFFFFF;
00430             uint32_t smallerphi = 0;
00431 
00433             for ( modToPhiMapIterTemp = (*modToPhiMap).begin();
00434                   modToPhiMapIterTemp != (*modToPhiMap).end();
00435                   ++modToPhiMapIterTemp )
00436             {
00437               if ( modToPhiMapIter->first == modToPhiMapIterTemp->first ) continue;
00438 
00439               double closePhi = modToPhiMapIterTemp->second;
00440               double tempDeltaPhi = closePhi - tempPhi;
00441               if ( tempDeltaPhi < 0 ) tempDeltaPhi = -tempDeltaPhi;
00442               if ( tempDeltaPhi > M_PI ) tempDeltaPhi = 2*M_PI - tempDeltaPhi;
00443               if ( fabs(tempDeltaPhi) < deltaPhi )
00444               {
00445                 deltaPhi = fabs(tempDeltaPhi);
00446                 closeMod = modToPhiMapIterTemp->first;
00447               }
00448 
00449               if ( tempPhi > closePhi ) smallerphi++;
00450             }
00451 
00454             modToModMap.insert( std::make_pair( modToPhiMapIter->first, closeMod ) );
00455             modToPhiIdxMap.insert( std::make_pair( modToPhiMapIter->first, smallerphi ) );
00456           }
00457           ringToModToModMap.insert( std::make_pair( ringToModToPhiMapIter->first, modToModMap ) );
00458           ringToModToPhiIdxMap.insert( std::make_pair( ringToModToPhiMapIter->first, modToPhiIdxMap ) );
00459         }
00460         diskToRingToModToModMap.insert( std::make_pair( diskToRingToModToPhiMapIter->first, ringToModToModMap ) );
00461         diskToRingToModToPhiIdxMap.insert( std::make_pair( diskToRingToModToPhiMapIter->first, ringToModToPhiIdxMap ) );
00462       }
00463       sideToDiskToRingToModToModMap.insert( std::make_pair( sideToDiskToRingToModToPhiMapIter->first, diskToRingToModToModMap ) );
00464       sideToDiskToRingToModToPhiIdxMap.insert( std::make_pair( sideToDiskToRingToModToPhiMapIter->first, diskToRingToModToPhiIdxMap ) );
00465     }
00466 
00467   } 
00468 
00470   std::map< uint32_t, uint32_t > detIdToDetIdMap;
00471 
00472   std::map< uint32_t, uint32_t > counterB;
00473   std::map< uint32_t, uint32_t > counterE;
00474   bool fastExit = false;
00475   for ( trkIterator1 = trkIter_start;
00476         trkIterator1 != trkIter_end;
00477         ++trkIterator1 )
00478   {
00479     DetId id1 = (**trkIterator1).geographicalId();
00480     double r1 = (**trkIterator1).position().perp();
00481     double z1 = (**trkIterator1).position().z();
00482 
00484     if ( (**trkIterator1).type().isBarrel() &&
00485          (**trkIterator1).type().isTrackerPixel() &&
00486          (r1>20.0) &&
00487          detIdToDetIdMap.find(id1) == detIdToDetIdMap.end() )
00488     {
00489       uint32_t lay1 = PXBDetId(id1).layer();
00490       uint32_t rod1 = PXBDetId(id1).ladder();
00491       uint32_t mod1 = PXBDetId(id1).module();
00492 
00494       fastExit = false;
00495       for ( trkIterator2 = trkIter_start;
00496             trkIterator2 != trkIter_end && !fastExit;
00497             ++trkIterator2 )
00498       {
00499         DetId id2 = (**trkIterator2).geographicalId();
00500         double r2 = (**trkIterator2).position().perp();
00501 
00502         if ( (**trkIterator2).type().isBarrel() &&
00503              (**trkIterator2).type().isTrackerPixel() &&
00504              (r2>20.0) )
00505         {
00506           uint32_t lay2 = PXBDetId(id2).layer();
00507           uint32_t rod2 = PXBDetId(id2).ladder();
00508           uint32_t mod2 = PXBDetId(id2).module();
00509 
00511           if (lay2 != lay1) continue;
00512           if (rod2 != rod1) continue;
00513           if (mod2 <= mod1) continue; 
00514 
00516           rodToModToModMap = layToRodToModToModMap.find(lay1)->second;
00517           modToModMap = rodToModToModMap.find(rod1)->second;
00518           uint32_t tempMod1 = modToModMap.find(mod1)->second;
00519           if (mod2 != tempMod1) continue;
00520 
00522           StackedTrackerDetUnit::StackContents listStackMembers ;
00523           if (r1 < r2)
00524           {
00525             listStackMembers.insert( std::make_pair( 0 , id1 ) );
00526             listStackMembers.insert( std::make_pair( 1 , id2 ) );
00527           } // first one should be the inner sensor
00528           else if (r1 > r2)
00529           {
00530             listStackMembers.insert( std::make_pair( 0 , id2 ) );
00531             listStackMembers.insert( std::make_pair( 1 , id1 ) );
00532           } // first one should be the inner sensor
00533           else
00534             throw cms::Exception("StackedTrackerGeometryBuilder") << "E R R O R! modules coincide! "
00535                                                                   << mod1 << " " << mod2 << " [ located at... ] "
00536                                                                   << (**trkIterator1).position().z() << " " << (**trkIterator2).position().z() << std::endl;
00537 
00538           uint32_t tempMod2 = layToRodToModToZIdxMap.find(lay1)->second.find(rod1)->second.find(mod1)->second;
00544           StackedTrackerDetId aStackId( uint32_t(layToStackMap.find(lay1)->second)+1, rod1, tempMod2/2+1 );
00545 
00548           if ( StackedTrackergeom->idToStack(aStackId) != NULL )
00549             throw cms::Exception("StackedTrackerGeometryBuilder") << "Attempted to build a duplicate ID from Barrel:" << aStackId << std::endl;
00550 
00552           double phi1 = (**trkIterator1).position().phi();
00553           double phi2 = (**trkIterator2).position().phi();
00554           if ( phi1 < 0.0 ) phi1 +=2.0*M_PI;
00555           if ( phi2 < 0.0 ) phi2 +=2.0*M_PI;
00556           double Dphi = fabs(phi2-phi1);
00557           if ( Dphi >= 2.0*M_PI ) Dphi -= 2.0*M_PI;
00558 
00560           double Dz = fabs( (**trkIterator2).position().z()-(**trkIterator1).position().z() );
00561 
00563           if ( fabs(r1-r2) > radial_window )
00564             throw cms::Exception("StackedTrackerGeometryBuilder") << "Attempted to build Barrel stacks that are far apart in R:" << fabs(r1-r2) << " " << aStackId << std::endl;
00565           if ( Dphi>=phi_window )
00566             throw cms::Exception("StackedTrackerGeometryBuilder") << "Attempted to build Barrel stacks that are far apart in phi:" << Dphi << " " << aStackId << std::endl;
00567           if ( Dz>=z_window )
00568             throw cms::Exception("StackedTrackerGeometryBuilder") << "Attempted to build Barrel stacks that are far apart in Z:" << Dz << " " <<  aStackId << std::endl;
00569 
00571           StackedTrackergeom->addStack( new StackedTrackerDetUnit(aStackId, listStackMembers) );
00572           detIdToDetIdMap.insert( std::make_pair(id2, id1) ); // Reverse order since the first one is being checked now
00573 
00574           if ( counterB.find(layToStackMap.find(lay1)->second) == counterB.end() )
00575             counterB.insert( std::make_pair(layToStackMap.find(lay1)->second, 0 ) );
00576 
00577           counterB[layToStackMap.find(lay1)->second]++;
00578           fastExit = true;
00579 
00580         }
00581       } 
00582     }
00583 
00585     if ( (**trkIterator1).type().isEndcap() &&
00586          (**trkIterator1).type().isTrackerPixel() &&
00587          (fabs(z1)>70.0) &&
00588          detIdToDetIdMap.find(id1) == detIdToDetIdMap.end() )
00589     {
00590       uint32_t side1 = PXFDetId(id1).side();
00591       uint32_t disk1 = PXFDetId(id1).disk();
00592       uint32_t ring1 = PXFDetId(id1).ring();
00593       uint32_t mod1  = PXFDetId(id1).module();
00594 
00596       fastExit = false;
00597       for ( trkIterator2 = trkIter_start;
00598             trkIterator2 != trkIter_end && !fastExit;
00599             ++trkIterator2 )
00600       {
00601         DetId id2 = (**trkIterator2).geographicalId();
00602         double z2 = (**trkIterator2).position().z();
00603 
00604         if ( (**trkIterator2).type().isEndcap() &&
00605              (**trkIterator2).type().isTrackerPixel() &&
00606              (fabs(z2)>70.0) )
00607         {
00608           uint32_t side2 = PXFDetId(id2).side();
00609           uint32_t disk2 = PXFDetId(id2).disk();
00610           uint32_t ring2 = PXFDetId(id2).ring();
00611           uint32_t mod2 = PXFDetId(id2).module();
00612 
00614           if (side1 != side2) continue;
00615           if (disk1 != disk2) continue;
00616           if (ring1 != ring2) continue;
00617           if (mod2 <= mod1)   continue; 
00618 
00620           diskToRingToModToModMap = sideToDiskToRingToModToModMap.find(side1)->second;
00621           ringToModToModMap = diskToRingToModToModMap.find(disk1)->second;
00622           modToModMap = ringToModToModMap.find(ring1)->second;
00623           uint32_t tempMod1 = modToModMap.find(mod1)->second;
00624           if (mod2 != tempMod1) continue;
00625 
00627           StackedTrackerDetUnit::StackContents listStackMembers ;
00628           if (fabs(z1) < fabs(z2))
00629           {
00630             listStackMembers.insert( std::make_pair( 0 , id1 ) );
00631             listStackMembers.insert( std::make_pair( 1 , id2 ) );
00632           } // first one should be the inner sensor
00633           else if (fabs(z1) > fabs(z2))
00634           {
00635             listStackMembers.insert( std::make_pair( 0 , id2 ) );
00636             listStackMembers.insert( std::make_pair( 1 , id1 ) );
00637           } // first one should be the inner sensor
00638           else
00639             throw cms::Exception("StackedTrackerGeometryBuilder") << "E R R O R! modules coincide! "
00640                                                                   << mod1 << " " << mod2 << " [ located at... ] "
00641                                                                   << z1 << " " << z2 << std::endl;
00642 
00643           uint32_t tempMod2 = sideToDiskToRingToModToPhiIdxMap.find(side1)->second.find(disk1)->second.find(ring1)->second.find(mod1)->second;
00649           StackedTrackerDetId aStackId( side1, uint32_t(diskToStackMap.find(disk1)->second)+1, ring1, tempMod2/2+1 );
00650 
00653           if ( StackedTrackergeom->idToStack(aStackId) != NULL )
00654             throw cms::Exception("StackedTrackerGeometryBuilder") << "Attempted to build a duplicate ID from Endcap:" << aStackId << std::endl;
00655 
00657           double phi1 = (**trkIterator1).position().phi();
00658           double phi2 = (**trkIterator2).position().phi();
00659           if ( phi1 < 0.0 ) phi1 +=2.0*M_PI;
00660           if ( phi2 < 0.0 ) phi2 +=2.0*M_PI;
00661           double Dphi = fabs(phi2-phi1);
00662           if ( Dphi >= 2.0*M_PI ) Dphi -= 2.0*M_PI;
00663 
00665           double DR = fabs( (**trkIterator2).position().perp()-(**trkIterator1).position().perp() );
00666 
00668           if ( DR > radial_window )
00669             throw cms::Exception("StackedTrackerGeometryBuilder") << "Attempted to build Endcap stacks that are far apart in R:" << DR << " " << aStackId << std::endl;
00670           if ( Dphi>=phi_window )
00671             throw cms::Exception("StackedTrackerGeometryBuilder") << "Attempted to build Endcap stacks that are far apart in phi:" << Dphi << " " << aStackId << std::endl;
00672           if ( fabs(z1-z2)>=z_window )
00673             throw cms::Exception("StackedTrackerGeometryBuilder") << "Attempted to build Endcap stacks that are far apart in Z:" << fabs(z1-z2) << " " <<  aStackId << std::endl;
00674 
00676           StackedTrackergeom->addStack( new StackedTrackerDetUnit(aStackId, listStackMembers) );
00677           detIdToDetIdMap.insert( std::make_pair(id2, id1) ); // Reverse order since the first one is being checked now
00678 
00679           if ( counterE.find(diskToStackMap.find(disk1)->second) == counterE.end() )
00680             counterE.insert( std::make_pair(diskToStackMap.find(disk1)->second, 0 ) );
00681 
00682           counterE[diskToStackMap.find(disk1)->second]++;
00683           fastExit = true;
00684 
00685         }
00686       } 
00687     }
00688 
00689   } 
00690 
00692   time_t end_time = time (NULL);
00693   std::cout << "Found:" << std::endl;
00694   std::cout << std::endl;
00695 
00696   for ( std::map< uint32_t, uint32_t >::iterator layIterator = layToStackMap.begin();
00697         layIterator != layToStackMap.end();
00698         ++layIterator )
00699   {
00700     std::cout << "\tBarrel Stack layer " << layIterator->first << " : " << counterB[layIterator->second] << " stacks" << std::endl;
00701   }
00702 
00703   for ( std::map< uint32_t, uint32_t >::iterator layIterator = layToStackMap.begin();
00704         layIterator != layToStackMap.end();
00705         ++layIterator )
00706   {
00707     uint32_t targetnum = ( modsPerRod[layIterator->first] * rodsPerLayer[layIterator->first] )/2;
00708     if ( counterB[layIterator->second] != targetnum )
00709     {
00710       throw cms::Exception("StackedTrackerGeometryBuilder")
00711         << "There should be more Stacks in PXB layer " << layIterator->first
00712         << ", "<<counterB[ layIterator->second ]
00713         << " Stacks were found and there should be "
00714         << targetnum << std::endl;
00715     }
00716   }
00717 
00718   std::cout << std::endl;
00719 
00720   for ( std::map< uint32_t, uint32_t >::iterator diskIterator = diskToStackMap.begin();
00721         diskIterator != diskToStackMap.end();
00722         ++diskIterator )
00723   {
00724     std::cout << "\tEndcap Stack disk " << diskIterator->first << " : " << counterE[diskIterator->second] << " stacks" << std::endl;
00725   }
00726 
00727   for ( std::map< uint32_t, uint32_t >::iterator diskIterator = diskToStackMap.begin();
00728         diskIterator != diskToStackMap.end();
00729         ++diskIterator )
00730   {
00731     uint32_t targetnum = 0;
00732 
00733     std::map< uint32_t, uint32_t > tempMap;
00734     tempMap = modsPerRingPerDisk[diskIterator->first];
00735     for ( std::map< uint32_t, uint32_t >::iterator iter = tempMap.begin();
00736           iter != tempMap.end();
00737           ++iter )
00738       targetnum += iter->second;
00739 
00740     //targetnum = targetnum/2;
00741 
00742     if ( counterE[diskIterator->second] != targetnum )
00743     {
00744       throw cms::Exception("StackedTrackerGeometryBuilder")
00745         << "There should be more Stacks in PXF disk " << diskIterator->first
00746         << ", "<<counterE[ diskIterator->second ]
00747         << " Stacks were found and there should be "
00748         << targetnum << std::endl;
00749     }
00750   }
00751 
00752   std::cout << "Created " << StackedTrackergeom->stacks().size() << " stacks in " << end_time-start_time << " s" << std::endl;
00753 
00754   return StackedTrackergeom;
00755 }
00756 
00757 
00758
/data/refman/pasoursint/CMSSW_6_1_2_SLHC2/src/Geometry/TrackerGeometryBuilder/src/StackedTrackerGeometryBuilder.cc
