#include <EndcapPiZeroDiscriminatorAlgo.h>

Public Types
typedef std::map< DetId, EcalRecHit >	RecHitsMap

Public Member Functions
float	Activation_fun (float SUM)

void	calculateBarrelNNInputVariables (float et, double s1, double s9, double s25, double m2, double cee, double cep, double cpp, double s4, double s6, double ratio, double xcog, double ycog)

bool	calculateNNInputVariables (std::vector< float > &vph1, std::vector< float > &vph2, float pS1_max, float pS9_max, float pS25_max, int EScorr)

	EndcapPiZeroDiscriminatorAlgo ()

	EndcapPiZeroDiscriminatorAlgo (double stripEnergyCut, int nStripCut, const std::string &path)

void	findPi0Road (ESDetId strip, EcalPreshowerNavigator &theESNav, int plane, std::vector< ESDetId > &vout)

std::vector< float >	findPreshVector (ESDetId strip, RecHitsMap rechits_map, CaloSubdetectorTopology topology_p)

float *	get_input_vector ()

float	GetBarrelNNOutput (float EB_Et)

float	getNNoutput (int sel_wfile)

float	GetNNOutput (float EE_Et)

bool	goodPi0Strip (RecHitsMap::iterator candidate_it, ESDetId lastID)

void	readWeightFile (const char *WFile)

	~EndcapPiZeroDiscriminatorAlgo ()

Private Attributes
int	barrelstart

int	debugLevel_

int	EB_Hidden

int	EB_Indim

int	EB_Layers

int	EB_Outdim

int	EE_Hidden

int	EE_Indim

int	EE_Layers

int	EE_Outdim

float *	H_O_Weight

std::vector< float >	H_O_Weight_all

float *	H_Thresh

std::vector< float >	H_Thresh_all

int	Hidden

float *	I_H_Weight

std::vector< float >	I_H_Weight_all

int	Indim

int	inp_var

float *	input_var

int	Layers

int	Nfiles_EB

int	Nfiles_EE

float *	O_Thresh

std::vector< float >	O_Thresh_all

int	Outdim

std::string	pathToFiles_

int	preshSeededNstr_

double	preshStripEnergyCut_

RecHitsMap *	rechits_map

Detailed Description

Definition at line 16 of file EndcapPiZeroDiscriminatorAlgo.h.

Member Typedef Documentation

typedef std::map<DetId, EcalRecHit> EndcapPiZeroDiscriminatorAlgo::RecHitsMap

Definition at line 20 of file EndcapPiZeroDiscriminatorAlgo.h.

Constructor & Destructor Documentation

EndcapPiZeroDiscriminatorAlgo::EndcapPiZeroDiscriminatorAlgo ( )

inline

Definition at line 22 of file EndcapPiZeroDiscriminatorAlgo.h.

                                    :
      preshStripEnergyCut_(0.), preshSeededNstr_(5), pathToFiles_("")
    {}

EndcapPiZeroDiscriminatorAlgo::EndcapPiZeroDiscriminatorAlgo	(	double	stripEnergyCut,
		int	nStripCut,
		const std::string &	path
	)

EndcapPiZeroDiscriminatorAlgo::~EndcapPiZeroDiscriminatorAlgo ( )

inline

Definition at line 29 of file EndcapPiZeroDiscriminatorAlgo.h.

29 {};

Member Function Documentation

float EndcapPiZeroDiscriminatorAlgo::Activation_fun ( float SUM )

Definition at line 343 of file EndcapPiZeroDiscriminatorAlgo.cc.

References create_public_lumi_plots::exp.

Referenced by getNNoutput().

                                                             {
         return( 1.0 / ( 1.0 + exp(-2.0*SUM) ) );
 }

void EndcapPiZeroDiscriminatorAlgo::calculateBarrelNNInputVariables	(	float	et,
		double	s1,
		double	s9,
		double	s25,
		double	m2,
		double	cee,
		double	cep,
		double	cpp,
		double	s4,
		double	s6,
		double	ratio,
		double	xcog,
		double	ycog
	)

Definition at line 483 of file EndcapPiZeroDiscriminatorAlgo.cc.

References EB_Indim, input_var, and mathSSE::sqrt().

 {
   input_var = new float[EB_Indim];
 
   double lam, lam1, lam2;
 
   if(xcog < 0.) { 
     input_var[0] = -xcog/s25;
   } else { 
     input_var[0] = xcog/s25;
   }    
 
   input_var[1] = cee/0.0004;
 
   if(cpp<.001) {
     input_var[2] = cpp/.001;
   } else  { 
     input_var[2] = 0.;
   }
 
   if(s9!=0.) {
     input_var[3] = s1/s9; 
     input_var[8] = s6/s9; 
     input_var[10] = (m2+s1)/s9;
   }
   else {
     input_var[3] = 0.;
     input_var[8] = 0.;
     input_var[10] = 0.;
   }
 
   if(s25-s1>0.) {
     input_var[4] = (s9-s1)/(s25-s1); 
   } else {
     input_var[4] = 0.;
   }  
 
   if(s25>0.) {
     input_var[5] = s4/s25; 
   }  else {
     input_var[5] = 0.;
   } 
 
   if(ycog < 0.) {
     input_var[6] = -ycog/s25; 
   } else {
     input_var[6] = ycog/s25;
   } 
 
   input_var[7] = ratio;
 
   lam=sqrt((cee -cpp)*(cee -cpp)+4*cep*cep);
   lam1=(cee + cpp + lam)/2;
   lam2=(cee + cpp - lam)/2;
 
   if(lam1 == 0) {
     input_var[9] = .0;
   } else {
     input_var[9] = lam2/lam1;
   }
   if(s4!=0.) {
     input_var[11] = (m2+s1)/s4;
   } else {
     input_var[11] = 0.;
   }
 
 }

bool EndcapPiZeroDiscriminatorAlgo::calculateNNInputVariables	(	std::vector< float > &	vph1,
		std::vector< float > &	vph2,
		float	pS1_max,
		float	pS9_max,
		float	pS25_max,
		int	EScorr
	)

Definition at line 357 of file EndcapPiZeroDiscriminatorAlgo.cc.

References alignCSCRings::e, EE_Indim, input_var, gen::k, GetRecoTauVFromDQM_MC_cff::kk, and LogTrace.

 {
    input_var = new float[EE_Indim];
 
    bool valid_NNinput = true;
 
    /*   
    for(int i = 0; i<11;i++) {
    LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: Energies of the Preshower Strips in X plane = " << vph1[i] ;
    }
    
    for(int i = 0; i<11;i++) {
    LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: Energies of the Preshower Strips in Y plane = " << vph2[i] ;
    } 
    */
 
    // check if all Preshower info is availabla - If NOT use remaning info
    for(int k = 0; k<11; k++) {
       if(vph1[k] < 0 ) {
       
       LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: Oops!!! Preshower Info for strip : " << k << " of X plane Do not exists" ;
      
          vph1[k] = 0.0;
       }      
       if(vph2[k] < 0 ) { 
     LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: Oops!!! Preshower Info for strip : " << k << " of Y plane Do not exists" ;   
         
         vph2[k] = 0.0;
       }
    }   
 
    /*
    for(int i = 0; i<11;i++) {  
      LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: After: Energies of the Preshower Strips in X plane = " << vph1[i] ;
    }
 
    for(int i = 0; i<11;i++) {
  
      LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: After: Energies of the Preshower Strips in Y plane = " << vph2[i] ;
    }
    */
 
 
 // FIRST : Produce the 22 NN variables related with the Preshower 
 // --------------------------------------------------------------
 // New normalization of the preshower strip energies Aris 8/11/2004
    for(int kk=0;kk<11;kk++){
      input_var[kk] = fabs(vph1[kk]/0.01);
      input_var[kk + 11] = fabs(vph2[kk]/0.02);       
      if(input_var[kk] < 0.0001) input_var[kk] = 0.;
      if(input_var[kk + 11] < 0.0001) input_var[kk + 11] = 0.;
    }
    input_var[0] = fabs(input_var[0]/2.); 
    input_var[1] = fabs(input_var[1]/2.); 
    input_var[6] = fabs(input_var[6]/2.); 
    input_var[11] = fabs(input_var[11]/2.); 
    input_var[12] = fabs(input_var[12]/2.); 
    input_var[17] = fabs(input_var[17]/2.); 
    
 // correction for version > CMSSW_3_1_0_pre5 where extra enegry is given to the ES strips 
 // Aris 18/5/2009   
    if( EScorr == 1) { 
      input_var[0] -= 0.05;
      input_var[1] -= 0.035;
      input_var[2] -= 0.035;
      input_var[3] -= 0.02;
      input_var[4] -= 0.015;
      input_var[5] -= 0.0075;
      input_var[6] -= 0.035;
      input_var[7] -= 0.035;
      input_var[8] -= 0.02;
      input_var[9] -= 0.015;
      input_var[10] -= 0.0075;
     
      input_var[11] -= 0.05;
      input_var[12] -= 0.035;
      input_var[13] -= 0.035;
      input_var[14] -= 0.02;
      input_var[15] -= 0.015;
      input_var[16] -= 0.0075;
      input_var[17] -= 0.035;
      input_var[18] -= 0.035;
      input_var[19] -= 0.02;
      input_var[20] -= 0.015;
      input_var[21] -= 0.0075;   
      
      for(int kk1=0;kk1<22;kk1++){
        if(input_var[kk1] < 0 ) input_var[kk1] = 0.0;   
      }
    }
 // SECOND: Take the final NN variable related to the ECAL
 // -----------------------------------------------
    float ECAL_norm_factor = 500.;
    if(pS25_max>500&&pS25_max<=1000) ECAL_norm_factor = 1000;
    if(pS25_max>1000) ECAL_norm_factor = 7000;
 
    input_var[22] = pS1_max/ECAL_norm_factor;
    input_var[23] = pS9_max/ECAL_norm_factor;
    input_var[24] = pS25_max/ECAL_norm_factor;
 
    LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: S1/ECAL_norm_factor = " << input_var[22];
    LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: S9/ECAL_norm_factor = " << input_var[23];
    LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: S25/ECAL_norm_factor = " << input_var[24] ;
 
    for(int i=0;i<EE_Indim;i++){
      if(input_var[i] > 1.0e+00) {
        valid_NNinput = false;
        break;
      }
    }
    
    LogTrace("EcalClusters") << " valid_NNinput = " << valid_NNinput ;
    
 
    return valid_NNinput;
 }

void EndcapPiZeroDiscriminatorAlgo::findPi0Road	(	ESDetId	strip,
		EcalPreshowerNavigator &	theESNav,
		int	plane,
		std::vector< ESDetId > &	vout
	)

Definition at line 163 of file EndcapPiZeroDiscriminatorAlgo.cc.

References LogTrace, GetRecoTauVFromDQM_MC_cff::next, and preshSeededNstr_.

Referenced by findPreshVector().

                                                                                                   {
   if ( strip == ESDetId(0) ) return;
    ESDetId next;
    theESNav.setHome(strip);
    LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPi0Road: starts from strip " << strip ;
    
    if (plane == 1) {
      // east road
      int n_east= 0;
      LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPi0Road: Go to the East " ;
    
      while ( ((next=theESNav.east()) != ESDetId(0) && next != strip) ) {
         LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPi0Road: East: " << n_east << " current strip is " << next ;
         
         vout.push_back(next);
         ++n_east;
         if (n_east == preshSeededNstr_) break;
      }
      // west road
      int n_west= 0;
      LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPi0Road: Go to the West " ;
      
      theESNav.home();
      while ( ((next=theESNav.west()) != ESDetId(0) && next != strip )) {
         LogTrace("EcalClusters") << "findPi0Road: West: " << n_west << " current strip is " << next ;
         
         vout.push_back(next);
         ++n_west;
         if (n_west == preshSeededNstr_) break;
      }
      LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPi0Road: Total number of strips found in the road at 1-st plane is " << n_east+n_west ;
      
   }
   else if (plane == 2) {
     // north road
     int n_north= 0;
     LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPi0Road: Go to the North " ;
     
     while ( ((next=theESNav.north()) != ESDetId(0) && next != strip) ) {
        LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPi0Road: North: " << n_north << " current strip is " << next;
        
        vout.push_back(next);
        ++n_north;
        if (n_north == preshSeededNstr_) break;
     }
     // south road
     int n_south= 0;
     LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPi0Road: Go to the South " ;
     
     theESNav.home();
     while ( ((next=theESNav.south()) != ESDetId(0) && next != strip) ) {
        LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPi0Road: South: " << n_south << " current strip is " << next ;
        
        vout.push_back(next);
        ++n_south;
        if (n_south == preshSeededNstr_) break;
     }
     LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPi0Road: Total number of strips found in the road at 2-nd plane is " << n_south+n_north ;
     
   }
   else {
     LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPi0Road: Wrong plane number, null cluster will be returned! " ;
     
   } // end of if
 
   theESNav.home();
 }

vector< float > EndcapPiZeroDiscriminatorAlgo::findPreshVector	(	ESDetId	strip,
		RecHitsMap *	rechits_map,
		CaloSubdetectorTopology *	topology_p
	)

Definition at line 62 of file EndcapPiZeroDiscriminatorAlgo.cc.

References findPi0Road(), goodPi0Strip(), i, LogTrace, ESDetId::plane(), and ESDetId::strip().

 {
   vector<float> vout_stripE;
 
   // skip if rechits_map contains no hits
   if ( rechits_map->size() == 0 ) {
           edm::LogWarning("EndcapPiZeroDiscriminatorAlgo") << "RecHitsMap has size 0.";
           return vout_stripE;
   }
 
   vout_stripE.clear();
 
   vector<ESDetId> road_2d;
   road_2d.clear();
 
   int plane = strip.plane();
 
   LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPreshVectors: Preshower Seeded Algorithm - looking for clusters" << "n"<< "findPreshVectors: Preshower is intersected at strip " << strip.strip() << ", at plane " << plane ;
 
 
   if ( strip == ESDetId(0) ) { //works in case of no intersected strip found
     for(int i=0;i<11;i++) {
        vout_stripE.push_back(-100.);
     }
   }
 
   // Add to the road the central strip
   road_2d.push_back(strip);
 
   //Make a navigator, and set it to the strip cell.
   EcalPreshowerNavigator navigator(strip, topology_p);
   navigator.setHome(strip);
  //search for neighbours in the central road
   findPi0Road(strip, navigator, plane, road_2d);
   
   LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo:findPreshVectors: Total number of strips in the central road: " << road_2d.size() ;
   
   // Find the energy of each strip
   RecHitsMap::iterator final_strip =  rechits_map->end();
   // very dangerous, added a protection on the rechits_map->size()
   // at the beginning of the method
   final_strip--;
   ESDetId last_stripID = final_strip->first;
 
   float E = 0;
   vector<ESDetId>::iterator itID;
   for (itID = road_2d.begin(); itID != road_2d.end(); itID++) {
     LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPreshVectors: ID = " << *itID ;
   
     RecHitsMap::iterator strip_it = rechits_map->find(*itID);
     if(goodPi0Strip(strip_it,last_stripID)) { // continue if strip not found in rechit_map
       E = strip_it->second.energy();
     } else  E = 0;
     vout_stripE.push_back(E);
     LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: findPreshVectors: E = " << E ;
     
   }
  
   // ***ML beg***
   // vector of size=11, content of vout_stripE is copied into vout_ElevenStrips_Energy
   // to avoid problem in case number of strips is less than 11
   vector<float> vout_ElevenStrips_Energy;
   for(int i=0;i<11;i++)
   {
     vout_ElevenStrips_Energy.push_back(0.);
   }
   
   for(unsigned int i=0;i<vout_stripE.size();i++)
   {
     vout_ElevenStrips_Energy[i] = vout_stripE.at(i);
   }
 
   //return vout_stripE;
   return vout_ElevenStrips_Energy;
   // ***ML end***
 
 }

float* EndcapPiZeroDiscriminatorAlgo::get_input_vector ( )

inline

Definition at line 56 of file EndcapPiZeroDiscriminatorAlgo.h.

56 {return input_var;};

EndcapPiZeroDiscriminatorAlgo::input_var

float * input_var

Definition: EndcapPiZeroDiscriminatorAlgo.h:84

float EndcapPiZeroDiscriminatorAlgo::GetBarrelNNOutput ( float EB_Et )

Definition at line 600 of file EndcapPiZeroDiscriminatorAlgo.cc.

References barrelstart, EB_Hidden, EB_Indim, EB_Layers, EB_Outdim, getNNoutput(), Indim, input_var, Layers, LogTrace, and Outdim.

 {
 
     Layers = EB_Layers; Indim = EB_Indim; Hidden = EB_Hidden; Outdim = EB_Outdim;  barrelstart = 1;  
 
     float nnout = -1;
 // Print the  NN input variables that are related to the ECAL Barrel
 // ------------------------------------------------------------------------
     LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo::GetBarrelNNoutput :nn_invar_presh = " ;
 
     for(int k1=0;k1<Indim;k1++) {
       LogTrace("EcalClusters") << input_var[k1] << " " ;
       
     }
      LogTrace("EcalClusters") << " " ;
      
      // select the appropriate Weigth file
      int sel_wfile;
      if(EB_Et<25.0)                     {sel_wfile = 0;}
      else if(EB_Et>=25.0 && EB_Et<35.0) {sel_wfile = 1;}
      else if(EB_Et>=35.0 && EB_Et<45.0) {sel_wfile = 2;}
      else if(EB_Et>=45.0 && EB_Et<55.0) {sel_wfile = 3;}
      else                               {sel_wfile = 4;}
      LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: E_SC = " << EB_Et << " and I select Weight file Number = " << sel_wfile ;
     
      nnout = getNNoutput(sel_wfile); // calculate the nnoutput for the given ECAL object
      
      LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: ===================> GetNNOutput : NNout = " << nnout ;
     
    return nnout;
 }

float EndcapPiZeroDiscriminatorAlgo::getNNoutput ( int sel_wfile )

Definition at line 303 of file EndcapPiZeroDiscriminatorAlgo.cc.

References Activation_fun(), barrelstart, EE_Hidden, EE_Indim, EE_Outdim, h, H_O_Weight_all, H_Thresh_all, Hidden, i, I_H_Weight_all, Indim, input_var, gen::k, LogTrace, O_Thresh_all, and Outdim.

Referenced by GetBarrelNNOutput(), and GetNNOutput().

 {
  float* I_SUM;
  float* OUT;
  float nnout=0.0;
  int mij;
 
  I_SUM = new float[Hidden];
  OUT = new  float[Outdim];
 
  for(int k=0;k<Hidden;k++) I_SUM[k]=0.0;
  for(int k1=0;k1<Outdim;k1++) OUT[k1]=0.0;
 
  for (int h = 0; h<Hidden; h++){
      mij = h - Hidden;
      for (int i = 0; i<Indim; i++){
          mij = mij + Hidden;
          I_SUM[h] += I_H_Weight_all[mij+sel_wfile*Indim*Hidden + barrelstart*Nfiles_EE*EE_Indim*EE_Hidden] * input_var[i];
      }
      I_SUM[h] += H_Thresh_all[h+sel_wfile*Hidden + barrelstart*Nfiles_EE*EE_Hidden];
      for (int o1 = 0; o1<Outdim; o1++) {
         OUT[o1] += H_O_Weight_all[barrelstart*Nfiles_EE*EE_Outdim*EE_Hidden + h*Outdim+o1 + sel_wfile*Outdim*Hidden]*Activation_fun(I_SUM[h]); 
 
      }
  }
  for (int o2 = 0; o2<Outdim; o2++){      
             OUT[o2] += O_Thresh_all[barrelstart*Nfiles_EE*EE_Outdim + o2 + sel_wfile*Outdim]; 
   }
   nnout = Activation_fun(OUT[0]);
   LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: getNNoutput :: -> NNout = " <<  nnout ;
   
 
   delete[] I_SUM;
   delete[] OUT;
   delete[] input_var;
    
   return (nnout);
 }

float EndcapPiZeroDiscriminatorAlgo::GetNNOutput ( float EE_Et )

Definition at line 560 of file EndcapPiZeroDiscriminatorAlgo.cc.

References barrelstart, EE_Hidden, EE_Indim, EE_Layers, EE_Outdim, getNNoutput(), Indim, input_var, Layers, LogTrace, and Outdim.

 {
     Layers = EE_Layers; Indim = EE_Indim; Hidden = EE_Hidden; Outdim = EE_Outdim;  barrelstart = 0;  
 
     float nnout = -1;
 // Print the  NN input variables that are related to the Preshower + ECAL
 // ------------------------------------------------------------------------
     LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo::GetNNoutput :nn_invar_presh = " ;
     
      for(int k1=0;k1<Indim;k1++) {
      LogTrace("EcalClusters") << input_var[k1] << " " ;
     
      }
      LogTrace("EcalClusters") << " " ;
     
      // select the appropriate Weigth file
      int sel_wfile;
      if(EE_Et<25.0)                     {sel_wfile = 0;}
      else if(EE_Et>=25.0 && EE_Et<35.0) {sel_wfile = 1;}
      else if(EE_Et>=35.0 && EE_Et<45.0) {sel_wfile = 2;}
      else if(EE_Et>=45.0 && EE_Et<55.0) {sel_wfile = 3;}
      else                               {sel_wfile = 4;} 
 
      LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: Et_SC = " << EE_Et << " and I select Weight file Number = " << sel_wfile ;
 
      
      nnout = getNNoutput(sel_wfile); // calculate the nnoutput for the given ECAL object
      
      LogTrace("EcalClusters") <<  "EndcapPiZeroDiscriminatorAlgo: ===================> GetNNOutput : NNout = " << nnout ;
      
     
    return nnout;
 }

bool EndcapPiZeroDiscriminatorAlgo::goodPi0Strip	(	RecHitsMap::iterator	candidate_it,
		ESDetId	lastID
	)

Definition at line 142 of file EndcapPiZeroDiscriminatorAlgo.cc.

References LogTrace, and preshStripEnergyCut_.

Referenced by findPreshVector().

 {
   RecHitsMap::iterator candidate_tmp = candidate_it;
   candidate_tmp--;
 
   if (candidate_tmp->first == lastID )
   LogTrace("EcalClusters") <<"EndcapPiZeroDiscriminatorAlgo: goodPi0Strip No such a strip in rechits_map " ;
   if (candidate_it->second.energy() <= preshStripEnergyCut_)
   LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: goodPi0Strip Strip energy " << candidate_it->second.energy() <<" is below threshold " ;
   
   // crystal should not be included...
   if ( (candidate_tmp->first == lastID )                    ||       // ...if it corresponds to a hit
        (candidate_it->second.energy() <= preshStripEnergyCut_ ) )   // ...if it has a negative or zero energy
     {
       return false;
     }
 
   return true;
 }

void EndcapPiZeroDiscriminatorAlgo::readWeightFile ( const char * WFile )

Definition at line 238 of file EndcapPiZeroDiscriminatorAlgo.cc.

References H_O_Weight, H_Thresh, Hidden, I_H_Weight, Indim, inp_var, j, Layers, geometryCSVtoXML::line, LogTrace, O_Thresh, Outdim, and create_public_pileup_plots::weights.

                                                                           {
    FILE *weights;
 
    char *line;
    line = new char[80];
 
    bool checkinit=false;
 // Open the weights file, generated by jetnet, and read
 // in the nodes and weights
 //*******************************************************
   weights = fopen(Weights_file, "r");
   LogTrace("EcalClusters") << "EndcapPiZeroDiscriminatorAlgo: I opeded the Weights file  = " << Weights_file ;
   
 
   while( !feof(weights) ){
     fscanf(weights, "%s", line);
     if (line[0] == 'A') { //Read in ANN nodes: Layers, input , Hidden, Output
        fscanf(weights, "%d", &Layers);   // # of NN Layers  used
        fscanf(weights, "%d", &Indim);    // # of Inputs actually used
        fscanf(weights, "%d", &Hidden);   // # of hidden nodes
        fscanf(weights, "%d", &Outdim);   // # of output nodes
 
            inp_var = Indim + 1;
 
        I_H_Weight = new float[Indim*Hidden];
        H_Thresh = new float[Hidden];
        H_O_Weight = new float[Hidden*Outdim];
        O_Thresh = new float[Outdim];
        checkinit=true;
     }else if (line[0] == 'B') { // read in weights between hidden and intput nodes
         assert(checkinit);
         for (int i = 0; i<Indim; i++){
                 for (int j = 0; j<Hidden; j++){
                     fscanf(weights, "%f", &I_H_Weight[i*Hidden+j]);
                 }
         }
     }else if (line[0] == 'C'){   // Read in the thresholds for hidden nodes
         assert(checkinit);
         for (int i = 0; i<Hidden; i++){
         fscanf(weights, "%f", &H_Thresh[i]);
         }
     }else if (line[0] == 'D'){ // read in weights between hidden and output nodes
         assert(checkinit);
         for (int i = 0; i<Hidden*Outdim; i++){
         fscanf(weights, "%f", &H_O_Weight[i]);
         }
     }else if (line[0] == 'E'){ // read in the threshold for the output nodes
         assert(checkinit);
         for (int i = 0; i<Outdim; i++){
         fscanf(weights, "%f", &O_Thresh[i]);
 
         }
         }
     else{edm::LogError("EEPi0Discrim")<< "EndcapPiZeroDiscriminatorAlgo: Not a Net file of Corrupted Net file " << endl;
         }
    }
    fclose(weights);
 }