StRoot: StEEmcPool/StEEmcClusterMaker/StEEmcClusterMaker.cxx Source File

00001 
00048 #include "StEEmcClusterMaker.h"
00049 
00050 #include <algorithm>
00051 #include <iostream>
00052 
00053 #include "TMath.h"
00054 
00055 /* StEvent stuff */
00056 #include "StEvent/StEvent.h"
00057 #include "StEvent/StEmcCollection.h"
00058 #include "StEvent/StEmcDetector.h"
00059 #include "StEvent/StEmcModule.h"
00060 #include "StEvent/StEmcClusterCollection.h"
00061 #include "StEvent/StEmcCluster.h"
00062 
00063 #define DEBUG 0
00064 
00065 ClassImp(StEEmcClusterMaker);
00066 
00067 // ----------------------------------------------------------------------------
00068 StEEmcClusterMaker::StEEmcClusterMaker(const Char_t *name):StMaker(name)
00069 {
00070 
00072   mFillStEvent = 0;
00073 
00075   mSuppress = 0;
00076 
00077   mLoose=false;
00078   mSkip=true;
00079 
00082   mClusterId = 0;
00083 
00085   const Float_t eseeds[] = { 0.6, 1.0/1000, 1.0/1000, 1.0/1000., 0.3/1000., 0.3/1000. };
00086   for ( Int_t i = 0; i < 6; i++ ) seedEnergy( eseeds[i], i );
00087 
00088   mMaxExtent = 6; 
00089   mSeedFloor = 2.0; 
00090 
00103 
00104   StEEmcClusterVec_t t;
00105   std::vector< StEEmcClusterVec_t > layers;
00106   for ( Int_t i = 0; i < 4; i++ ) layers.push_back(t);
00107   for ( Int_t i = 0; i < 12; i++ ) mTowerClusters.push_back(layers);
00108 
00109   StEEmcSmdClusterVec_t s;
00110   std::vector< StEEmcSmdClusterVec_t > planes;
00111   planes.push_back(s);
00112   planes.push_back(s);
00113   for ( Int_t i = 0; i < 12; i++ ) mSmdClusters.push_back(planes);
00114 
00115   StEEmcTowerVec_t tow;
00116   std::vector< StEEmcTowerVec_t > lay;
00117   for ( Int_t i = 0; i < 4; i++ ) lay.push_back(tow);
00118   for ( Int_t i = 0; i < 12; i++ ) mSeedTowers.push_back(lay);
00119 
00120   mEEtow=new EEmcGeomSimple();
00121   mEEsmd=EEmcSmdGeom::instance();
00122   mEEmap=EEmcSmdMap::instance();
00123 
00124   mMinStrips=3;
00125   
00126 }
00127 
00128 // ----------------------------------------------------------------------------
00129 Int_t StEEmcClusterMaker::Init()
00130 {
00131   mEEanalysis=(const StEEmcA2EMaker*)GetMaker(mAnalysisName);
00132   assert(mEEanalysis);
00133 
00134   return StMaker::Init();
00135 }
00136 
00137 // ----------------------------------------------------------------------------
00138 Int_t StEEmcClusterMaker::Make()
00139 {
00140   StMaker::Make();
00142   if ( !buildTowerClusters() ) return kStWarn;
00143 
00145   if ( !buildSmdClusters() ) return kStWarn; 
00146 
00148   if ( mFillStEvent ) fillStEvent();
00149 
00151   if ( mFillStEvent ) 
00152     if ( !verifyStEvent() ) Warning("Make","StEvent not properly copied");
00153 
00154   return kStOK;
00155 }
00156 
00157 // ----------------------------------------------------------------------------
00158 void StEEmcClusterMaker::Clear( Option_t *opts )
00159 {
00160   StMaker::Clear();
00162   for ( Int_t sector=0; sector<12; sector++ ) {
00163     for ( Int_t layer=0; layer<4; layer++ )
00164       mTowerClusters[sector][layer].clear();    
00165     for ( Int_t plane=0; plane<2; plane++ )
00166       mSmdClusters[sector][plane].clear();
00167   }
00168 
00169   for ( Int_t i=0;i<6;i++ ) mNumberOfClusters[i]=0;
00170 
00171   mClusterId = 0;
00172 
00173   return;
00174 }
00175 
00176 
00177 // ----------------------------------------------------------------------------
00178 Bool_t StEEmcClusterMaker::buildTowerClusters()
00179 {
00180 
00183   //static const Int_t layer=0;
00184 
00185 
00187   for ( Int_t layer=0;layer<4;layer++)
00188   {
00189 
00192     Float_t weights[720]; for ( Int_t i=0;i<720;i++ ) weights[i]=0.;
00193 
00195     StEEmcClusterVec_t myClusters;
00196 
00197 
00199     StEEmcTowerVec_t towers = mEEanalysis -> towers( layer );
00200 
00201 
00202 
00204     std::sort(towers.begin(),towers.end());
00206     std::reverse(towers.begin(),towers.end());
00207    
00208 
00211     StEEmcTowerVec_t::iterator last = towers.begin();
00212     while ( last != towers.end() ) {
00213 
00214       if ( (*last).energy() < mSeedEnergy[layer] ) break;
00219       //$$$      mSeedTowers[layer][ (*last).sector() ].push_back((*last));
00220 #if DEBUG
00221       std::cout << "-- Seed tower ----------------------" << std::endl;
00222       (*last).print();
00223 #endif
00224       last++;
00225     }
00226     
00227     StEEmcTowerVec_t::iterator iter = towers.begin();
00228     while ( iter != towers.end() ) {
00229 
00231       if ( iter==last ) break;
00232       
00233 
00240       if ( weights[ (*iter).index() ] > 0. ) {
00241         iter++;
00242         continue;
00243       }
00244 
00247       for ( Int_t in=0; in < (*iter).numberOfNeighbors(); in++ ) {
00248         StEEmcTower t=(*iter).neighbor(in);
00249         weights[ t.index() ] += (*iter).energy();
00250       }
00251 
00252      
00253       iter++;
00254 
00255     }// loop over towers to init weights
00256 
00257 
00259     iter=towers.begin();
00260     while ( iter != towers.end() ) {
00261 
00263       if ( iter==last ) break;
00264 
00268       if ( weights[ (*iter).index() ] > 0. ) {
00269         iter++;
00270         continue;
00271       }
00272 
00273       StEEmcCluster cluster;
00274       StEEmcTower seed=(*iter);
00275 #if DEBUG
00276       std::cout << "--- Clustering ----------------" << std::endl;
00277       seed.print();
00278 #endif
00279 
00280       TVector3 momentum;
00281       cluster.add(seed,1.0);
00282       UInt_t sec,sub,eta;
00283       sec=(UInt_t)seed.sector(); 
00284       sub=(UInt_t)seed.subsector(); 
00285       eta=(UInt_t)seed.etabin();
00286       TVector3 d=mEEtow->getTowerCenter(sec,sub,eta).Unit();
00287       momentum += ( seed.energy() * d );
00288 
00289       for ( Int_t in=0; in<seed.numberOfNeighbors(); in++ ) {
00290         StEEmcTower t=seed.neighbor(in);
00291         sec=(UInt_t)t.sector(); 
00292         sub=(UInt_t)t.subsector(); 
00293         eta=(UInt_t)t.etabin();
00294         d=mEEtow->getTowerCenter(sec,sub,eta).Unit();
00295         Float_t weight = seed.energy() / weights[ t.index() ];
00296         momentum += ( t.energy() * d * weight );
00297         cluster.add(t, weight);
00298 #if DEBUG
00299         std::cout << "adding " << t.name() << " E=" << t.energy() << " W=" << weight << std::endl;
00300 #endif
00301       }
00302 
00303 
00305       cluster.momentum( momentum );
00306       cluster.key( mClusterId++ );
00307 #if DEBUG
00308       cluster.print();
00309 #endif
00310 
00311       mTowerClusters[ seed.sector() ][ layer ].push_back( cluster );
00312       mNumberOfClusters[layer]++;
00313      
00314       iter++;
00315 
00316     }
00317           
00318   }// end of eventual loop over layers
00319   
00320 
00321   return true;
00322 
00323 }
00324 
00325 // ----------------------------------------------------------------------------
00326 Bool_t StEEmcClusterMaker::buildSmdClusters()
00327 {
00328 
00329   Int_t max_extent = mMaxExtent;
00330 
00332   for ( Int_t sector=0; sector<12; sector++ ) 
00334     for ( Int_t plane=0; plane<2; plane++ ) {
00335 
00337         Float_t floor[288]; for ( Int_t i=0; i<288; i++ ) floor[i]=0.;
00338 
00340         Float_t energy[288]; for ( Int_t i=0; i<288; i++ ) energy[i]=0.;
00341 
00343         StEEmcStripVec_t strips=mEEanalysis->strips(sector,plane);
00344         StEEmcStripVec_t seeds;
00346         std::sort(strips.begin(),strips.end());
00348         std::reverse(strips.begin(),strips.end());
00349 
00351         StEEmcStripVec_t::iterator istrip=strips.begin();
00352         while ( istrip != strips.end() ) {
00353           if ( (*istrip).stat()||(*istrip).fail() ) {
00354             istrip++;
00355             continue;
00356           }
00357           energy[ (*istrip).index() ] = (*istrip).energy();
00358           istrip++;
00359         }
00360         
00362         std::vector<Bool_t> seed_flags( strips.size(), false );
00363 
00364 
00366         Int_t nstrip=0;
00367         Int_t nseeds=0;
00368         istrip=strips.begin();
00369         while ( istrip!=strips.end() ) {
00370 
00371           Int_t index=(*istrip).index();
00372           Float_t eseed=(*istrip).energy();
00373 
00375           if ( index <= 3 || index >= 283 ) {
00376             istrip++;
00377             nstrip++;
00378             continue;
00379           }
00380 
00382           if ( mSkip )
00383             if ( (*istrip).fail() ) {
00384               istrip++;
00385               nstrip++;
00386               continue;
00387             }
00388 
00389 
00392           if ( eseed < mSeedFloor*floor[ index ] + mSeedEnergy[4+plane] ) {
00393             istrip++;
00394             nstrip++;
00395             continue;
00396           }
00397 
00399           seeds.push_back( (*istrip) );
00400           nstrip++;
00401           nseeds++;
00402 
00403 
00409 #ifndef LOOSE_CUTS        
00411           for ( Int_t i=0; i < 288; i++ ) {
00412             Int_t dx=TMath::Abs(index-i);
00414             if ( dx<3 ) 
00415               if ( eseed > floor[i] ) floor[i]=eseed;       
00417             if ( dx<5 ) 
00418               if ( 0.20 * eseed > floor[i] ) floor[i] = 0.2 * eseed;
00420             if ( dx<11 )
00421               if ( 0.10 * eseed > floor[i] ) floor[i] = 0.1 * eseed;
00423             if ( dx<21 )
00424               if ( 0.20*eseed > floor[i] ) floor[i] = 0.05 * eseed;                         
00425           }
00426 #else
00428           for ( Int_t i=0; i < 288; i++ ) {
00429 
00430             Int_t dx=TMath::Abs(index-i);
00431 
00433             if ( dx<7 ) 
00434               if ( 0.05 * eseed > floor[i] ) floor[i] = 0.05 * eseed;
00435 
00436           }
00437 #endif
00438           istrip++;
00439 
00440         }// found all seed strips
00441 
00447         Bool_t owned[288]; for (Int_t i=0;i<288;i++) owned[i]=false;
00448         Bool_t xseed[288]; for (Int_t i=0;i<288;i++) xseed[i]=false;
00449 
00450         StEEmcStripVec_t::iterator iseed=seeds.begin();
00451         while ( iseed != seeds.end() ) {
00452           
00454           Int_t index=(*iseed).index();
00455           if ( owned[index] || (mSuppress&&xseed[index]) ) {
00456             iseed++;
00457             continue;
00458           }
00459 
00461           owned[index]=true;
00462           xseed[index]=true;
00464           StEEmcSmdCluster cluster;
00466           cluster.add( (*iseed) );
00467 
00468           Int_t ind_max = TMath::Min(287,index+max_extent); 
00469           Int_t ind_min = TMath::Max(0,  index-max_extent); 
00470 
00473           for ( Int_t i=index+1; i<=ind_max; i++ ) {
00475             StEEmcStrip strip=mEEanalysis->strip(sector,plane,i);
00477 
00478             if ( mSkip ) {
00479               if (strip.energy()<=0.&&!strip.fail()) break; 
00480             } else {
00481               if ( strip.energy()<=0. ) break;
00482             }
00483 
00485             owned[ strip.index() ] = true;
00486             xseed[ strip.index() ] = true;
00488             cluster.add(strip);             
00489           }
00490           for ( Int_t i=index-1; i>=ind_min; i-- ) {
00492             StEEmcStrip strip=mEEanalysis->strip(sector,plane,i);
00494 
00495             if ( mSkip ) {
00496               if (strip.energy()<=0.&&!strip.fail()) break;
00497             } else {
00498               if (strip.energy()<=0.) break;
00499             }
00500 
00502             owned[ strip.index() ] = true;
00503             xseed[ strip.index() ] = true;
00505             cluster.add(strip);             
00506           }
00507           
00509           if ( cluster.size() >= mMinStrips ) {
00510             cluster.key( mClusterId++ );
00511             mSmdClusters[ sector ][ plane ].push_back(cluster);
00512             mNumberOfClusters[4+plane]++;
00513 
00514             // disallow strips on either side of the cluster
00515             // from forming seeds
00516             Int_t ns=cluster.numberOfStrips();
00517             Int_t left=999,right=-999;
00518             for ( Int_t is=0;is<ns;is++ )
00519             {
00520                 StEEmcStrip s=cluster.strip(is);
00521                 if ( s.index()<left ) left=s.index();
00522                 if ( s.index()>right ) right=s.index();
00523             }
00524             /*
00525             xseed[left-1]=true;
00526             xseed[left-2]=true;
00527             xseed[right+1]=true;
00528             xseed[right+2]=true;
00529             */
00530             for ( Int_t ii=0;ii<=mSuppress;ii++ )
00531               {
00532                 if ( left-ii>=0   ) xseed[left-ii] = true;
00533                 if ( right+ii<288 ) xseed[right+ii]= true;
00534               }
00535             
00536           }
00537           
00538 
00539           iseed++;
00540         }                       
00541 
00542     }// loop over planes/sectors
00543 
00544   return true;
00545 
00546 }
00547 
00548 
00549 
00550 // ----------------------------------------------------------------------------
00551 
00552 void StEEmcClusterMaker::fillStEvent()
00553 {
00554 
00555   StEvent *stevent=(StEvent*)GetInputDS("StEvent");
00556   if ( !stevent ) {
00557     Warning("fillStEvent","called, but no StEvent to be found");
00558     return;
00559   }
00560 
00561   std::cout << "Adding tower clusters to StEvent at " << stevent << std::endl << std::flush;
00562 
00566   StEmcDetector *detector=stevent->emcCollection()->detector(kEndcapEmcTowerId);
00567   if ( !detector )
00568     {
00569       Warning("fillStEvent","detector == NULL, MAJOR StEvent problem, continuing");
00570       return;
00571     }
00572   
00573 
00581   
00582   if ( mNumberOfClusters[0] > 0 )
00583     {
00584 
00585 
00590       StEmcClusterCollection *collect = detector -> cluster();
00591       if ( !collect ) 
00592         {
00593           //Warning("fillStEvent","StEmcClusterCollection (towers) was NULL, so I'm creating one.");
00594           collect = new StEmcClusterCollection();
00595           detector->setCluster( collect );
00596         }
00597 
00598       assert(collect);
00599       collect->setDetector( kEndcapEmcTowerId );
00600       collect->setClusterFinderId( 123 );
00601       collect->setClusterFinderParamVersion( 123 );
00602   
00604       for ( Int_t isector=0; isector<12; isector++ )
00605         {
00606 
00608           for ( UInt_t iclust=0; iclust<mTowerClusters[isector][0].size(); iclust++ ) 
00609             {
00610 
00611               StEEmcCluster cl=(mTowerClusters[isector][0])[iclust]; 
00612               
00616               StEmcCluster *emccluster = new StEmcCluster();
00617               emccluster->setEta( cl.momentum().Eta() );
00618               emccluster->setPhi( cl.momentum().Phi() );
00619               emccluster->setSigmaEta(-1.);
00620               emccluster->setSigmaPhi(-1.);
00621               emccluster->setEnergy( cl.energy() );
00622               emccluster->SetUniqueID( cl.key() );
00623 #if 1
00624               for ( Int_t i=0; i< cl.numberOfTowers(); i++ ) 
00625                 {
00626                   StEmcRawHit *hit=cl.tower(i).stemc();
00627                   assert( hit );         
00628                   emccluster->addHit( hit );
00629                 }
00630 #endif
00631             
00632               collect->addCluster( emccluster );
00633 
00634               
00636               mEtoEE[ emccluster ] = cl;
00637               cl.stemc( emccluster );
00638 
00639             }
00640           
00641         }
00642 
00643     }
00644 
00645   else // if ( mNumberOfClusters[0] == 0 )
00646     {
00647 
00648       detector->setCluster( NULL );
00649 
00650     }
00651 
00652 
00653 
00654 
00656   //  detector->setCluster( collect );
00657 
00661   detector=stevent->emcCollection()->detector(kEndcapEmcPreShowerId);
00662   if ( !detector )
00663     {
00664       Warning("fillStEvent","detector == NULL for pre/post, no clusters for you");
00665     }
00666   else if ( mNumberOfClusters[1] > 0 ||
00667             mNumberOfClusters[2] > 0 || 
00668             mNumberOfClusters[3] > 0 )
00669     {
00670 
00671       StEmcClusterCollection *pqr = detector -> cluster();
00672       if ( !pqr )
00673         {
00674           //Warning("fillStEvent","StEmcClusterCollection (pre/post) was NULL, so I'm creating one.");
00675           pqr = new StEmcClusterCollection();
00676           detector->setCluster( pqr );
00677         }
00678       assert(pqr); 
00679       pqr -> setDetector( kEndcapEmcPreShowerId );
00680       pqr -> setClusterFinderId( 123 );
00681       pqr -> setClusterFinderParamVersion( 321 );
00682   
00684       for ( Int_t isector=0; isector<12; isector++ )
00685     
00687       for ( Int_t ilayer=1; ilayer<4; ilayer++ ) 
00688     
00690       for ( UInt_t iclust=0; iclust<mTowerClusters[isector][ilayer].size(); iclust++ ) 
00691         {
00692 
00693           StEEmcCluster cl=(mTowerClusters[isector][ilayer])[iclust];
00694 
00698           StEmcCluster *emccluster = new StEmcCluster();
00699           emccluster->setEta( cl.momentum().Eta() );
00700           emccluster->setPhi( cl.momentum().Phi() );
00701           emccluster->setSigmaEta(-1.);
00702           emccluster->setSigmaPhi(-1.);
00703           emccluster->setEnergy( cl.energy() );
00704           emccluster->SetUniqueID( cl.key() );
00705 #if 1
00706           for ( Int_t i=0; i< cl.numberOfTowers(); i++ ) 
00707             {
00708               StEmcRawHit *hit=cl.tower(i).stemc();
00709               assert( hit );         
00710               emccluster->addHit( hit );
00711             }
00712 #endif
00713 
00714 
00715           pqr->addCluster( emccluster );
00716 
00717           mEtoEE[ emccluster ] = cl;
00718           cl.stemc( emccluster );
00719 
00720         }
00721 
00722     }
00723   else // if ( mNumberOfClusters[1, 2 OR 3] == 0 )
00724     {
00725 
00726       detector->setCluster( NULL );
00727 
00728     }
00729 
00730   
00734   StDetectorId ids[]={ kEndcapSmdUStripId, kEndcapSmdVStripId };
00735 
00736 
00737   for ( Int_t iplane=0; iplane<2; iplane++ ) 
00738     {
00739 
00740       detector=stevent->emcCollection()->detector(ids[iplane]);
00741       if ( !detector ) 
00742         {
00743           Warning("fillStEvent","detector == NULL for smd plane, no clusters for you");
00744         }
00745       else if ( mNumberOfClusters[4+iplane] > 0 )
00746         {
00747           
00748           StEmcClusterCollection *smdc = detector -> cluster();
00749           if ( !smdc ) 
00750             {
00751               //Warning("fillStEvent","StEmcClusterCollection (smd) was NULL, so I'm creating one.");
00752               smdc = new StEmcClusterCollection();
00753               detector->setCluster( smdc );
00754             }
00755           
00756           smdc->setDetector( ids[iplane] );
00757           smdc->setClusterFinderId( 123 );
00758           smdc->setClusterFinderParamVersion( 321 );
00759 
00760           
00761           for ( Int_t isector=0; isector<12; isector++ ) 
00762             {
00763               
00764               for ( UInt_t iclust=0; iclust<mSmdClusters[isector][iplane].size(); iclust++ ) 
00765                 {
00766                   
00767                   StEEmcSmdCluster cl = (mSmdClusters[isector][iplane])[iclust];
00768                   
00769 
00770                   StEmcCluster *emccluster = new StEmcCluster();
00771                   emccluster->setEta( cl.mean() );
00772                   emccluster->setPhi( (Float_t)iplane );
00773                   emccluster->setSigmaEta(-1.);
00774                   emccluster->setSigmaPhi(-1.);
00775                   emccluster->setEnergy( cl.energy() );
00776                   emccluster->SetUniqueID( cl.key() );
00777                   for ( Int_t i=0; i< cl.numberOfStrips(); i++ ) 
00778                     {
00779                       StEmcRawHit *hit=cl.strip(i).stemc();
00780                       assert( hit );         
00781                       emccluster->addHit( hit );
00782                     }             
00783                   smdc->addCluster( emccluster );
00784 
00785                   mEtoEEsmd[ emccluster ] = cl;
00786                   cl.stemc( emccluster );
00787                   
00788                 }
00789           
00790               
00791             }
00792           
00793         }
00794 
00795       else
00796         {
00797           detector -> setCluster( NULL );
00798         }
00799 
00800 
00801 
00802     }
00803 
00804 
00805 }
00806 
00807 
00808 
00809 // ----------------------------------------------------------------------------
00810 Bool_t StEEmcClusterMaker::verifyStEvent() const
00811   {
00812 
00814   const StEvent *stevent=(const StEvent*)GetInputDS("StEvent");
00815   if ( !stevent ) {
00816     Warning("verifyStEvent","No StEvent found.");
00817     return true;
00818   }
00819   //StEmcCollection *emccollection=stevent->emcCollection();
00820 
00821   Bool_t go = true;
00822  
00823   const StEmcDetector *detector=stevent->emcCollection()->detector(kEndcapEmcTowerId);
00824   if ( !detector )
00825     {
00826       Warning("verifyStEvent","detector == NULL for towers");
00827       return false;
00828     }
00829 
00830   
00831   const StEmcClusterCollection *cc=detector->cluster();
00832   if ( cc )
00833     {
00834 
00835 
00840       
00841       Float_t emc_sum_towers = 0.;
00842       Float_t eemc_sum_towers = 0.;
00843   
00844       const StSPtrVecEmcCluster &emcClusters=cc->clusters();
00845       for ( UInt_t i=0; i<emcClusters.size(); i++ ) 
00846         {
00847           const StEmcCluster *cl=emcClusters[i];
00848           assert(cl);
00849           emc_sum_towers += cl->energy();
00850         }
00851       
00852       for ( Int_t sec=0; sec<12; sec++ ) 
00853         {
00854           
00855           for ( Int_t i=0; i<numberOfClusters(sec,0); i++ )
00856             eemc_sum_towers += cluster(sec,0,i).energy();
00857         }
00858       
00859       std::cout << "StEEmcClusterMaker tower checksum: ";
00860       if ( emc_sum_towers == eemc_sum_towers ) {
00861         std::cout << "passed";
00862       }
00863       else {
00864         std::cout << "FAILED"; go=false;
00865       }
00866       std::cout << std::endl;
00867 
00868     }
00869   else {
00870 
00871     std::cout << "StEEmcClusterMaker tower checksum: NULL collection, nclust=" << mNumberOfClusters[0] << std::endl;
00872     go &= (mNumberOfClusters[0]==0);
00873 
00874   }
00875 
00880   Float_t emc_sum_smdu = 0.;
00881   Float_t eemc_sum_smdu = 0.;
00882 
00883   detector=stevent->emcCollection()->detector(kEndcapSmdUStripId);
00884   if ( !detector )
00885     {
00886       Warning("verifyStEvent","detector == NULL for smdu");
00887       return false;
00888     }
00889 
00890   cc=detector->cluster();
00891   if ( cc ) 
00892     {
00893 
00894       const StSPtrVecEmcCluster &smduClusters=cc->clusters();
00895 
00896       for ( UInt_t i=0; i<smduClusters.size(); i++ ) 
00897         {
00898           const StEmcCluster *cl=smduClusters[i];
00899           assert(cl);
00900           emc_sum_smdu += cl->energy();
00901         }
00902       
00903   
00904       for ( Int_t sec=0; sec<12; sec++ ) 
00905         {
00906 
00907           for ( Int_t i=0; i<numberOfSmdClusters(sec,0); i++ )
00908         
00909             {
00910               eemc_sum_smdu += smdcluster(sec,0,i).energy();
00911 
00912             }
00913 
00914         }
00915 
00916       std::cout << "StEEmcClusterMaker smdu checksum: ";
00917       if ( emc_sum_smdu == eemc_sum_smdu ) {
00918         std::cout << "passed";
00919       }
00920       else {
00921         std::cout << "FAILED"; go=false;
00922       }
00923       std::cout << std::endl;
00924 
00925     }  
00926   else 
00927     {
00928       std::cout << "StEEmcClusterMaker smdu checksum: NULL collection, nclust=" << mNumberOfClusters[4] << std::endl;
00929       go &= (mNumberOfClusters[4]==0);
00930     }
00931 
00932 
00934 
00935   Float_t emc_sum_smdv = 0.;
00936   Float_t eemc_sum_smdv = 0.;
00937 
00938   detector=stevent->emcCollection()->detector(kEndcapSmdVStripId);
00939   if (!detector)
00940     {
00941       Warning("verifyStEvent","detector == NULL for smdv");
00942       return false;
00943     }
00944 
00945   cc=detector->cluster();
00946 
00947   if ( cc )
00948     {
00949 
00950       const StSPtrVecEmcCluster &smdvClusters=cc->clusters();
00951       
00952       for ( UInt_t i=0; i<smdvClusters.size(); i++ ) 
00953         {
00954           const StEmcCluster *cl=smdvClusters[i];
00955           assert(cl);
00956           emc_sum_smdv += cl->energy();
00957         }
00958       
00959       
00960       for ( Int_t sec=0; sec<12; sec++ ) 
00961         {
00962           
00963           for ( Int_t i=0; i<numberOfSmdClusters(sec,1); i++ )
00964             
00965             {
00966               eemc_sum_smdv += smdcluster(sec,1,i).energy();
00967               
00968             }
00969           
00970         }
00971       
00972       std::cout << "StEEmcClusterMaker smdv checksum: ";
00973       if ( emc_sum_smdv == eemc_sum_smdv ) {
00974         std::cout << "passed";
00975       }
00976       else {
00977         std::cout << "FAILED"; go=false;
00978       }
00979       std::cout << std::endl;
00980 
00981     }
00982   else 
00983     {
00984       std::cout << "StEEmcClusterMaker smdv checksum: NULL collection, nclust=" << mNumberOfClusters[5] << std::endl;
00985       go &= (mNumberOfClusters[5]==0);
00986     }
00987   
00988 
00989   
00990   return go;
00991 }
00992 
00993 
00994 
00995 // ----------------------------------------------------------------------------
00996 void StEEmcClusterMaker::print() const
00997 {
00998 
00999   std::cout << "StEEmcClusterMaker::print()" << std::endl;
01000   const Char_t *names[] = { "tower", "pre1", "pre2", "post", "smdu", "smdv" };
01001   for ( Int_t i=0;i<6;i++ )
01002     {
01003 
01004       std::cout << "Number of " << names[i] 
01005                 << " clusters = " << mNumberOfClusters[i] 
01006                 << std::endl;
01007 
01008     }
01009 
01010   std::cout << "printout of tower clusters follows:" << std::endl;
01011   for ( Int_t sec=0;sec<12;sec++)
01012   for ( Int_t i=0;i<numberOfClusters(sec,0);i++ )
01013     {
01014       const StEEmcCluster &clust=cluster(sec,0,i);
01015       clust.print();
01016       //      std::cout << "cluster.key()=" << clust.key() << std::endl;
01017       //      std::cout << "cluster.eta()=" << clust.momentum().Eta() << std::endl;
01018       //      std::cout << "cluster.phi()=" << clust.momentum().Phi() << std::endl;      
01019       //      std::cout << "cluster.energy()=" << clust.energy() << std::endl;
01020     }
01021 
01022   
01023 
01024 }