/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86

Bug Summary

File:	alld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h
Warning:	line 398, column 7 Null pointer passed to 2nd parameter expecting 'nonnull'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -main-file-name DL1MCTrigger_factory.cc -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /w/halld-scifs17exp/home/sdobbs/clang/llvm-project/install/lib/clang/12.0.0 -D HAVE_CCDB -D HAVE_RCDB -D HAVE_EVIO -D HAVE_TMVA=1 -D RCDB_MYSQL=1 -D RCDB_SQLITE=1 -D SQLITE_USE_LEGACY_STRUCT=ON -I .Linux_CentOS7.7-x86_64-gcc4.8.5/libraries/TRIGGER -I libraries/TRIGGER -I . -I libraries -I libraries/include -I /w/halld-scifs17exp/home/sdobbs/clang/halld_recon/Linux_CentOS7.7-x86_64-gcc4.8.5/include -I external/xstream/include -I /usr/include/tirpc -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/root/root-6.08.06/include -I /w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/ccdb/ccdb_1.06.06/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/rcdb/rcdb_0.06.00/cpp/include -I /usr/include/mysql -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/sqlitecpp/SQLiteCpp-2.2.0^bs130/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/sqlite/sqlite-3.13.0^bs130/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/hdds/hdds-4.9.0/Linux_CentOS7.7-x86_64-gcc4.8.5/src -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/xerces-c/xerces-c-3.1.4/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/evio/evio-4.4.6/Linux-x86_64/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/backward -internal-isystem /usr/local/include -internal-isystem /w/halld-scifs17exp/home/sdobbs/clang/llvm-project/install/lib/clang/12.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /home/sdobbs/work/clang/halld_recon/src -ferror-limit 19 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /tmp/scan-build-2021-01-21-110224-160369-1 -x c++ libraries/TRIGGER/DL1MCTrigger_factory.cc

libraries/TRIGGER/DL1MCTrigger_factory.cc

→

1// Test version V0 of the L1 trigger simulation, Aug 18, 2017 (asomov)

3#include <iostream>
4#include <iomanip>
5#include <cmath>
6using namespace std;

8#include <JANA/JApplication.h>
9#include <DAQ/DCODAROCInfo.h>
10#include <DAQ/DL1Info.h>
11#include <DANA/DStatusBits.h>

13#include <HDDM/DEventSourceHDDM.h>

15using namespace jana;

17#include "DL1MCTrigger_factory.h"

19#if HAVE_RCDB1
20#include "RCDB/Connection.h"
21#include "RCDB/ConfigParser.h"
22#endif

24static bool print_data_message = true;

26//------------------
27// init
28//------------------
29jerror_t DL1MCTrigger_factory::init(void)
30{

debug = 0;

if(debug){
  hfcal_gains   = new TH1F("fcal_gains", "fcal_gains",  80,  -1., 3.);
  hfcal_gains2  = new TH2F("fcal_gains2","fcal_gains2", 71, -142., 142., 71, -142., 142.);
  hfcal_ped     = new TH1F("fcal_ped", "fcal_ped", 800, 0., 200.);
}

BYPASS = 0; // default is to use trigger emulation

// Default parameters for the main production trigger are taken from the 
// spring run of 2017: 25 F + B > 45000

FCAL_ADC_PER_MEV =  3.73;
FCAL_CELL_THR    =  65;
FCAL_EN_SC       =  25;
FCAL_NSA         =  10;
FCAL_NSB         =  3;
FCAL_WINDOW      =  10;

BCAL_ADC_PER_MEV =  34.48276; // Not corrected energy 
BCAL_CELL_THR    =  20;
BCAL_EN_SC       =  1;
BCAL_NSA         =  19;
BCAL_NSB         =  3;
BCAL_WINDOW      =  20;

FCAL_BCAL_EN     =  45000; 

ST_ADC_PER_MEV   =  1.;
ST_CELL_THR      =  40;
ST_NSA           =  10;
ST_NSB           =  3;
ST_WINDOW        =  10;
ST_NHIT          =  1;

BCAL_OFFSET      =  2;

SIMU_BASELINE = 1;
SIMU_GAIN = 1;


simu_baseline_fcal  =  1;
simu_baseline_bcal  =  1;

simu_gain_fcal  =  1;
simu_gain_bcal  =  1;

gPARMS->SetDefaultParameter("TRIG:BYPASS", BYPASS,
                            "Bypass trigger by hard coding physics bit");
gPARMS->SetDefaultParameter("TRIG:FCAL_ADC_PER_MEV", FCAL_ADC_PER_MEV,
	      "FCAL energy calibration for the Trigger");
gPARMS->SetDefaultParameter("TRIG:FCAL_CELL_THR", FCAL_CELL_THR,
	      "FCAL energy threshold per cell");
gPARMS->SetDefaultParameter("TRIG:FCAL_EN_SC", FCAL_EN_SC,
	      "FCAL energy threshold");
gPARMS->SetDefaultParameter("TRIG:FCAL_NSA", FCAL_NSA,
	      "FCAL NSA");
gPARMS->SetDefaultParameter("TRIG:FCAL_NSB", FCAL_NSB,
	      "FCAL NSB");
gPARMS->SetDefaultParameter("TRIG:FCAL_WINDOW", FCAL_WINDOW,
	      "FCAL GTP integration window");

gPARMS->SetDefaultParameter("TRIG:BCAL_ADC_PER_MEV", BCAL_ADC_PER_MEV,
	      "BCAL energy calibration for the Trigger");
gPARMS->SetDefaultParameter("TRIG:BCAL_CELL_THR", BCAL_CELL_THR,
	      "BCAL energy threshold per cell");
gPARMS->SetDefaultParameter("TRIG:BCAL_EN_SC", BCAL_EN_SC,
	      "BCAL energy threshold");
gPARMS->SetDefaultParameter("TRIG:BCAL_NSA", BCAL_NSA,
	      "BCAL NSA");
gPARMS->SetDefaultParameter("TRIG:BCAL_NSB", BCAL_NSB,
	      "BCAL NSB");
gPARMS->SetDefaultParameter("TRIG:BCAL_WINDOW", BCAL_WINDOW,
	      "BCAL GTP integration window");

gPARMS->SetDefaultParameter("TRIG:ST_ADC_PER_MEV", ST_ADC_PER_MEV,
	      "ST energy calibration for the Trigger");
gPARMS->SetDefaultParameter("TRIG:ST_CELL_THR", ST_CELL_THR,
	      "ST energy threshold per cell");
gPARMS->SetDefaultParameter("TRIG:ST_NSA", ST_NSA,
	      "ST NSA");
gPARMS->SetDefaultParameter("TRIG:ST_NSB", ST_NSB,
	      "ST NSB");  
gPARMS->SetDefaultParameter("TRIG:ST_WINDOW", ST_WINDOW,
	      "ST window for merging hits (GTP)");
gPARMS->SetDefaultParameter("TRIG:ST_NHIT", ST_NHIT,
	      "Number of hits in ST");

gPARMS->SetDefaultParameter("TRIG:FCAL_BCAL_EN", FCAL_BCAL_EN,
	      "Energy threshold for the FCAL & BCAL trigger");

gPARMS->SetDefaultParameter("TRIG:BCAL_OFFSET", BCAL_OFFSET,
	      "Timing offset between BCAL and FCAL energies at GTP (sampels)");


// Allows to switch off gain and baseline fluctuations
gPARMS->SetDefaultParameter("TRIG:SIMU_BASELINE", SIMU_BASELINE,
	      "Enable simulation of pedestal variations");

gPARMS->SetDefaultParameter("TRIG:SIMU_GAIN", SIMU_GAIN,
	      "Enable simulation of gain variations");


BCAL_ADC_PER_MEV_CORRECT  =  22.7273;

pedestal_sigma = 1.2;

time_shift = 100;

time_min  =  0;
time_max  =  (sample - 1)*max_adc_bins;

vector< vector<double > > fcal_gains_temp(DFCALGeometry::kBlocksTall, 
			    vector<double>(DFCALGeometry::kBlocksWide));
vector< vector<double > > fcal_pedestals_temp(DFCALGeometry::kBlocksTall, 
				vector<double>(DFCALGeometry::kBlocksWide));

fcal_gains      =  fcal_gains_temp;  
fcal_pedestals  =  fcal_pedestals_temp;

return NOERROR;
154}


157//------------------
158// brun
159//------------------
160jerror_t DL1MCTrigger_factory::brun(jana::JEventLoop *eventLoop, int32_t runnumber)
161{

int use_rcdb = 1;

int status   = 0;

fcal_trig_mask.clear();
bcal_trig_mask.clear();

triggers_enabled.clear();

// Only print messages for one thread whenever run number change

static pthread_mutex_t print_mutex = PTHREAD_MUTEX_INITIALIZER{ { 0, 0, 0, 0, 0, 0, 0, { 0, 0 } } };
static set<int> runs_announced;
pthread_mutex_lock(&print_mutex);
bool print_messages = false;

if(runs_announced.find(runnumber) == runs_announced.end()){
  print_messages = true;
  runs_announced.insert(runnumber);
}

pthread_mutex_unlock(&print_mutex);

// Don't use RCDB for mc_generic: ideal MC simulation

string JANA_CALIB_CONTEXT = "";

if(getenv("JANA_CALIB_CONTEXT") != NULL__null ){ 
  JANA_CALIB_CONTEXT = getenv("JANA_CALIB_CONTEXT");
  if(JANA_CALIB_CONTEXT.find("mc_generic") != string::npos){
    use_rcdb = 0;
    // Don't simulate baseline fluctuations for mc_generic
    simu_baseline_fcal = 0;
    simu_baseline_bcal = 0;
    // Don't simulate gain fluctuations for mc_generic
    simu_gain_fcal = 0;
    simu_gain_bcal = 0;
  }
}

//  runnumber = 30942;

if(use_rcdb == 1){
  status = Read_RCDB(runnumber, print_messages);
  if(print_messages) PrintTriggers();
}


if( (use_rcdb == 0) || (status > 0) || (triggers_enabled.size() == 0)){

  // Simulate FCAL & BCAL main production trigger only

  trigger_conf trig_tmp;
  trig_tmp.bit = 0;
  trig_tmp.gtp.fcal      =  FCAL_EN_SC;
  trig_tmp.gtp.bcal      =  BCAL_EN_SC;
  trig_tmp.gtp.en_thr    =  FCAL_BCAL_EN;
  trig_tmp.gtp.fcal_min  =  200;
  triggers_enabled.push_back(trig_tmp);

if(print_messages) 
   cout << " Do not use RCDB for the trigger simulation. Default (spring 2017) trigger settings are used " << endl;
}


 // extract the FCAL Geometry
vector<const DFCALGeometry*> fcalGeomVect;
eventLoop->Get( fcalGeomVect );
if (fcalGeomVect.size() < 1)
  return OBJECT_NOT_AVAILABLE;
const DFCALGeometry& fcalGeom = *(fcalGeomVect[0]);

if(print_messages) jout << "In DL1MCTrigger_factory, loading constants..." << endl;

vector< double > fcal_gains_ch;
vector< double > fcal_pedestals_ch;

if (eventLoop->GetCalib("/FCAL/gains", fcal_gains_ch)){
  jout << "DL1MCTrigger_factory: Error loading /FCAL/gains !" << endl;
  // Load default values of gains if CCDB table is not found
  for(int ii = 0; ii < DFCALGeometry::kBlocksTall; ii++){
    for(int jj = 0; jj < DFCALGeometry::kBlocksWide; jj++){
fcal_gains[ii][jj] = 1.;	
    }
  }
} else {
  LoadFCALConst(fcal_gains, fcal_gains_ch, fcalGeom);

  if(debug){
    for(int ch = 0; ch < (int)fcal_gains_ch.size(); ch++){
int row = fcalGeom.row(ch);
int col = fcalGeom.column(ch);	
// Sanity check for regular FCAL (row,col) ranges (anticipating 
// future upgrade to FCAL to include insert)
if(fcalGeom.isBlockActive(row,col)&&row<DFCALGeometry::kBlocksTall
  && col<DFCALGeometry::kBlocksWide){
 hfcal_gains->Fill(fcal_gains[row][col]);
 DVector2 aaa = fcalGeom.positionOnFace(row,col);
 hfcal_gains2->Fill(float(aaa.X()), float(aaa.Y()), fcal_gains[row][col]);
 //	  cout << aaa.X() << "  " << aaa.Y() << endl;
 
}	
    }
  }

}

if (eventLoop->GetCalib("/FCAL/pedestals", fcal_pedestals_ch)){
  jout << "DL1MCTrigger_factory: Error loading /FCAL/pedestals !" << endl;
  // Load default values of pedestals if CCDB table is not found
  for(int ii = 0; ii < DFCALGeometry::kBlocksTall; ii++){
    for(int jj = 0; jj < DFCALGeometry::kBlocksWide; jj++){
fcal_pedestals[ii][jj] = 100.;	
    }
  }
} else {
  LoadFCALConst(fcal_pedestals, fcal_pedestals_ch, fcalGeom);

  if(debug){
    for(int ch = 0; ch < (int)fcal_gains_ch.size(); ch++){
int row = fcalGeom.row(ch);
int col = fcalGeom.column(ch);
// Sanity check for regular FCAL (row,col) ranges (anticipating 
// future upgrade to FCAL to include insert)
if(fcalGeom.isBlockActive(row,col)&&row<DFCALGeometry::kBlocksTall
  && col<DFCALGeometry::kBlocksWide){
 hfcal_ped->Fill(fcal_pedestals[row][col]);
}
    }	
  }
  
}

if(!SIMU_BASELINE){
  simu_baseline_fcal = 0;
  simu_baseline_bcal = 0;
}

if(!SIMU_GAIN){
  simu_gain_fcal = 0;
  simu_gain_bcal = 0;
}

if(debug){
  for(int ii = 0; ii < 100; ii++){
    cout << " Channel = " << ii <<  " Value = " << 
fcal_gains_ch[ii] << endl;
  }
}


return NOERROR;
315}

317//------------------
318// evnt
319//------------------
320jerror_t DL1MCTrigger_factory::evnt(JEventLoop *loop, uint64_t eventnumber){

if(BYPASS) {
              DL1MCTrigger *trigger = new DL1MCTrigger;
              trigger->trig_mask = 1;
              _data.push_back(trigger);
return NOERROR;
      }

      int l1_found = 1;  

int status = 0;

fcal_signal_hits.clear();
bcal_signal_hits.clear();

fcal_merged_hits.clear();
bcal_merged_hits.clear();

memset(fcal_ssp,0,sizeof(fcal_ssp));
memset(fcal_gtp,0,sizeof(fcal_gtp));

memset(bcal_ssp,0,sizeof(bcal_ssp));
memset(bcal_gtp,0,sizeof(bcal_gtp));


      vector<const DFCALHit*>  fcal_hits;
vector<const DBCALHit*>  bcal_hits;

loop->Get(fcal_hits);
loop->Get(bcal_hits);

DRandom2 gDRandom(0); // declared extern in DRandom2.h

// This is temporary, to allow this simulation to be run on data
// to help out with trigger efficiency studies - sdobbs (Aug. 26, 2020)
if( loop->GetJEvent().GetStatusBit(kSTATUS_EVIO) ){
if(print_data_message) {
	jout << "WARNING: Running L1 trigger simulation on EVIO data" << endl; 
	print_data_message = false;
}

// for data, don't add in baseline shifts, since they already exist
simu_baseline_fcal = 0;
simu_baseline_bcal = 0;
} else {
// Initialize random number generator
// Read seeds from hddm file
// Generate seeds according to the event number if they are not stored in hddm
// The proceedure is consistent with the mcsmear

UInt_t seed1 = 0;
UInt_t seed2 = 0;
UInt_t seed3 = 0;

GetSeeds(loop, eventnumber, seed1, seed2, seed3);

gDRandom.SetSeeds(seed1, seed2, seed3);
}

//	cout << endl;
//	cout << " Event = " << eventnumber << endl;
//	cout << " Seed 1: " << seed1 << endl;
//	cout << " Seed 2: " << seed2 << endl;
//	cout << " Seed 3: " << seed3 << endl;
//	cout << endl;
      

DL1MCTrigger *trigger = new DL1MCTrigger;

//  FCAL energy sum	
double fcal_hit_en = 0;

for (unsigned int ii = 0; ii < fcal_hits.size(); ii++){
 int row  = fcal_hits[ii]->row;
 int col  = fcal_hits[ii]->column;

 // Shift time to simulate pile up hits
 double time = fcal_hits[ii]->t + time_shift;
 if((time < time_min) || (time > time_max)){
   continue;
 }

 // Check channels masked for trigger
 int ch_masked = 0;
 for(unsigned int jj = 0; jj < fcal_trig_mask.size(); jj++){
   if( (row == fcal_trig_mask[jj].row) && (col == fcal_trig_mask[jj].col)){	      
     ch_masked = 1;
     break;
   } 
 }
 
 if(ch_masked == 0){
   fcal_hit_en += fcal_hits[ii]->E;
   
   fcal_signal fcal_tmp;
   
   fcal_tmp.row     = row;
   fcal_tmp.column  = col;

   fcal_tmp.energy  = fcal_hits[ii]->E;
   fcal_tmp.time    = time;
   memset(fcal_tmp.adc_amp,0,sizeof(fcal_tmp.adc_amp));
   memset(fcal_tmp.adc_en, 0,sizeof(fcal_tmp.adc_en));

   double fcal_adc_en  = fcal_tmp.energy*FCAL_ADC_PER_MEV*1000;
   
   // Account for gain fluctuations
   if(simu_gain_fcal && row<DFCALGeometry::kBlocksTall
      && col<DFCALGeometry::kBlocksWide){
     
     double gain  =  fcal_gains[row][col];	  
     
     fcal_adc_en *= gain;
   }
   
   status = SignalPulse(fcal_adc_en, fcal_tmp.time, fcal_tmp.adc_en, 1);
   status = 0;

   fcal_signal_hits.push_back(fcal_tmp);
 }
 
}       		


// Merge FCAL hits
for(unsigned int ii = 0; ii < fcal_signal_hits.size(); ii++){	  
 
 if(fcal_signal_hits[ii].merged == 1) continue;
 
 fcal_signal fcal_tmp;
 fcal_tmp.row     = fcal_signal_hits[ii].row;
 fcal_tmp.column  = fcal_signal_hits[ii].column;
 fcal_tmp.energy  = 0.;
 fcal_tmp.time    = 0.;
 for(int kk = 0; kk < sample; kk++)	      
   fcal_tmp.adc_en[kk] = fcal_signal_hits[ii].adc_en[kk];
 
 for(unsigned int jj = ii + 1; jj < fcal_signal_hits.size(); jj++){
   if((fcal_signal_hits[ii].row  == fcal_signal_hits[jj].row) &&
      (fcal_signal_hits[ii].column == fcal_signal_hits[jj].column)){

     fcal_signal_hits[jj].merged = 1;
     
     for(int kk = 0; kk < sample; kk++)	      
fcal_tmp.adc_en[kk] += fcal_signal_hits[jj].adc_en[kk];	
   }
 }
 
 fcal_merged_hits.push_back(fcal_tmp);
}	

// Add baseline fluctuations for channels with hits
if(simu_baseline_fcal){
 for(unsigned int ii = 0; ii < fcal_merged_hits.size(); ii++){
   int row     = fcal_merged_hits[ii].row;
   int column  = fcal_merged_hits[ii].column;
   double pedestal = 100.0;
   if (row<DFCALGeometry::kBlocksTall
&& column<DFCALGeometry::kBlocksWide){
     pedestal=fcal_pedestals[row][column];
   }
   AddBaseline(fcal_merged_hits[ii].adc_en, pedestal, gDRandom);       
 }
}


// Digitize		
for(unsigned int ii = 0; ii < fcal_merged_hits.size(); ii++){
 Digitize(fcal_merged_hits[ii].adc_en,fcal_merged_hits[ii].adc_amp);
 //	  cout << " Digitize " << fcal_merged_hits[ii].adc_en[sample - 3] 
 //   << "  " <<  fcal_merged_hits[ii].adc_amp[sample - 3] << endl;
}


int fcal_hit_adc_en = 0;

for(unsigned int ii = 0; ii < fcal_merged_hits.size(); ii++)
 for(int jj = 0; jj < sample; jj++)
   fcal_hit_adc_en += fcal_merged_hits[ii].adc_amp[jj];	  


status += FADC_SSP(fcal_merged_hits, 1);

status += GTP(1);



// BCAL	energy sum
double bcal_hit_en = 0;

for (unsigned int ii = 0; ii < bcal_hits.size(); ii++){

 // Shift time to simulate pile up hits
 double time = bcal_hits[ii]->t + time_shift;	 
 if((time < time_min) || (time > time_max)){
   continue;
 }
 
 int module = bcal_hits[ii]->module;
 int layer  = bcal_hits[ii]->layer;
 int sector = bcal_hits[ii]->sector;
 int end    = bcal_hits[ii]->end;
 
 // Check trigger masks
 int ch_masked = 0;

 for(unsigned int jj = 0; jj < bcal_trig_mask.size(); jj++){
   if( (module == bcal_trig_mask[jj].module) && (layer == bcal_trig_mask[jj].layer) && 
(sector == bcal_trig_mask[jj].sector) && (end == bcal_trig_mask[jj].end)  ){ 
     ch_masked = 1;
     break;
   } 
 }
 

 if(ch_masked == 0){
   bcal_hit_en += bcal_hits[ii]->E;
   
   bcal_signal bcal_tmp;	    
   bcal_tmp.module  = module;
   bcal_tmp.layer   = layer;
	    bcal_tmp.sector  = sector;
   bcal_tmp.end     = end;

   bcal_tmp.energy  = bcal_hits[ii]->E;
   bcal_tmp.time    = time;
   memset(bcal_tmp.adc_amp,0,sizeof(bcal_tmp.adc_amp));
   memset(bcal_tmp.adc_en, 0,sizeof(bcal_tmp.adc_en));
   
   double bcal_adc_en  = bcal_tmp.energy*BCAL_ADC_PER_MEV*1000;

   status = SignalPulse(bcal_adc_en, bcal_tmp.time, bcal_tmp.adc_en, 2);
   status = 0;

   bcal_signal_hits.push_back(bcal_tmp);
 }	  
}       


// Merge BCAL hits	
for(unsigned int ii = 0; ii < bcal_signal_hits.size(); ii++){	  
 
 if(bcal_signal_hits[ii].merged == 1) continue;
 
 bcal_signal bcal_tmp;
 bcal_tmp.module  =  bcal_signal_hits[ii].module;
 bcal_tmp.layer   =  bcal_signal_hits[ii].layer;
 bcal_tmp.sector  =  bcal_signal_hits[ii].sector;
 bcal_tmp.end     =  bcal_signal_hits[ii].end;
 
 bcal_tmp.energy  = 0.;
 bcal_tmp.time    = 0.;
 
 for(int kk = 0; kk < sample; kk++)	      
   bcal_tmp.adc_en[kk] = bcal_signal_hits[ii].adc_en[kk];
 
 for(unsigned int jj = ii + 1; jj < bcal_signal_hits.size(); jj++){
   if((bcal_signal_hits[ii].module == bcal_signal_hits[jj].module) &&
      (bcal_signal_hits[ii].layer  == bcal_signal_hits[jj].layer) &&
      (bcal_signal_hits[ii].sector == bcal_signal_hits[jj].sector) &&    
      (bcal_signal_hits[ii].end    == bcal_signal_hits[jj].end)){
     
     bcal_signal_hits[jj].merged = 1;
     
     for(int kk = 0; kk < sample; kk++)	      
bcal_tmp.adc_en[kk] += bcal_signal_hits[jj].adc_en[kk];	
   }
 }
 
 bcal_merged_hits.push_back(bcal_tmp);
}


// Add baseline fluctuations for channels with hits
if(simu_baseline_bcal){
 for(unsigned int ii = 0; ii < bcal_merged_hits.size(); ii++){
   // Assume that all BCAL pedestals are 100
   double pedestal = TRIG_BASELINE;	    
   AddBaseline(bcal_merged_hits[ii].adc_en, pedestal, gDRandom);       
 }
}


// Digitize		
for(unsigned int ii = 0; ii < bcal_merged_hits.size(); ii++)
 Digitize(bcal_merged_hits[ii].adc_en,bcal_merged_hits[ii].adc_amp);


int bcal_hit_adc_en = 0;
for(unsigned int ii = 0; ii < bcal_merged_hits.size(); ii++)	  
 for(int jj = 0; jj < sample; jj++)
   bcal_hit_adc_en += bcal_merged_hits[ii].adc_amp[jj];	  


status = FADC_SSP(bcal_merged_hits, 2);

status = GTP(2);

// Search for triggers

l1_found = FindTriggers(trigger);

if(l1_found){
 
 int fcal_gtp_max = 0;
 int bcal_gtp_max = 0;
 
 for(unsigned int ii = 0; ii < sample; ii++){
   if(fcal_gtp[ii] > fcal_gtp_max) fcal_gtp_max = fcal_gtp[ii];
   if(bcal_gtp[ii] > bcal_gtp_max) bcal_gtp_max = bcal_gtp[ii];
 }	
 	  
 trigger->fcal_en      =  fcal_hit_en;
 trigger->fcal_adc     =  fcal_hit_adc_en;
 trigger->fcal_adc_en  =  fcal_hit_adc_en/FCAL_ADC_PER_MEV/1000.;
 trigger->fcal_gtp     =  fcal_gtp_max;
 trigger->fcal_gtp_en  =  fcal_gtp_max/FCAL_ADC_PER_MEV/1000.;
 
 trigger->bcal_en      =  bcal_hit_en;
 trigger->bcal_adc     =  bcal_hit_adc_en;
 trigger->bcal_adc_en  =  bcal_hit_adc_en/BCAL_ADC_PER_MEV_CORRECT/2./1000.;
 trigger->bcal_gtp     =  bcal_gtp_max;
 trigger->bcal_gtp_en  =  bcal_gtp_max/BCAL_ADC_PER_MEV_CORRECT/2./1000.;	  	  
 
 _data.push_back(trigger);	 
 
} else{
 delete trigger;
}

return NOERROR;
652}

654//------------------
655// erun
656//------------------
657jerror_t DL1MCTrigger_factory::erun(void)
658{
return NOERROR;
660}

662//------------------
663// fini
664//------------------
665jerror_t DL1MCTrigger_factory::fini(void)
666{
return NOERROR;
668}

670//*********************
671// Read RCDB 
672//*********************

674int  DL1MCTrigger_factory::Read_RCDB(int32_t runnumber, bool print_messages)
675{

677#if HAVE_RCDB1

vector<const DTranslationTable*> ttab;  
eventLoop->Get(ttab);
1
Calling 'JEventLoop::Get'→

vector<string> SectionNames = {"TRIGGER", "GLOBAL", "FCAL", "BCAL", "TOF", "ST", "TAGH",
		 "TAGM", "PS", "PSC", "TPOL", "CDC", "FDC"};

string RCDB_CONNECTION;

if( getenv("RCDB_CONNECTION")!= NULL__null )
  RCDB_CONNECTION = getenv("RCDB_CONNECTION");
else
  RCDB_CONNECTION = "mysql://rcdb@hallddb.jlab.org/rcdb";   // default to outward-facing MySQL DB


rcdb::Connection connection(RCDB_CONNECTION);

auto  rtvsCnd  =  connection.GetCondition(runnumber, "rtvs");

if( !rtvsCnd ) {
  cout<<"'rtvs' condition is not set for run " << runnumber << endl;
  return 2;
}


auto json = rtvsCnd->ToJsonDocument();               // The CODA rtvs is serialized as JSon dictionary.  
string fileName(json["%(config)"].GetString());      // We need item with name '%(config)'

auto file = connection.GetFile(runnumber, fileName);

if(!file) {                                                         // If there is no such file, null is returned
  cout<<"File with name: "<< fileName
<<" doesn't exist (not associated) with run: "<< runnumber << endl;
  return 3;
}

string fileContent = file->GetContent();                               // Get file content
auto result = rcdb::ConfigParser::Parse(fileContent, SectionNames);    // Parse it!


// Pulse parameters for trigger

auto trig_thr = result.Sections["FCAL"].NameValues["FADC250_TRIG_THR"];
auto trig_nsb = result.Sections["FCAL"].NameValues["FADC250_TRIG_NSB"];
auto trig_nsa = result.Sections["FCAL"].NameValues["FADC250_TRIG_NSA"];

if(trig_thr.size() > 0){
  FCAL_CELL_THR  =  stoi(trig_thr);
  if(FCAL_CELL_THR < 0) FCAL_CELL_THR = 0;
}

if(trig_nsb.size() > 0)
  FCAL_NSB  =  stoi(trig_nsb);

if(trig_thr.size() > 0)
  FCAL_NSA   =  stoi(trig_nsa);

trig_thr = result.Sections["BCAL"].NameValues["FADC250_TRIG_THR"];
trig_nsb = result.Sections["BCAL"].NameValues["FADC250_TRIG_NSB"];
trig_nsa = result.Sections["BCAL"].NameValues["FADC250_TRIG_NSA"];

if(trig_thr.size() > 0){
  BCAL_CELL_THR   =  stoi(trig_thr);
  if(BCAL_CELL_THR < 0) BCAL_CELL_THR = 0;
}

if(trig_nsb.size() > 0)
  BCAL_NSB  =  stoi(trig_nsb);

if(trig_thr.size() > 0)
  BCAL_NSA  =  stoi(trig_nsa);


// List of enabled GTP equations and triggers
vector<vector<string>> triggerTypes;

for(auto row : result.Sections["TRIGGER"].Rows) {    

  if(row[0] == "TRIG_TYPE") {
    
    if(row.size() >= 9){
triggerTypes.push_back(row);       // The line in config file starts with TRIG_TYPE
    } else {
cout <<  " Cannot parse TRIG_TYPE. Insufficient number of parameters " <<  row.size() << endl; 
    }      
  }    
 

  // Integration windows for BCAL and FCAL 
  if(row[0] == "TRIG_EQ") {
    if(row.size() >= 5){
if(stoi(row[4]) == 1){              // Trigger enabled 
 if(row[1] == "FCAL")
   FCAL_WINDOW = stoi(row[3]);  
 if(row[1] == "BCAL_E")
   BCAL_WINDOW = stoi(row[3]);  
}
    }            
  }
}




for(int ii = 0; ii < 32; ii++){
  
  int trig_found = 0;
  
  trigger_conf trigger_tmp;

  memset(&trigger_tmp,0,sizeof(trigger_tmp));
  
  trigger_tmp.bit = ii;   
  
  for(unsigned int jj = 0; jj < triggerTypes.size(); jj++){
    
    if(triggerTypes[jj].size() < 9) continue;   // Minimum  9 parameters are required in the config file 

    int bit = stoi(triggerTypes[jj][8]);  // Trigger bit
    
    if( bit == ii){      

// FCAL, BCAL triggers 
if(triggerTypes[jj][1] == "BFCAL"){
 
 int fcal = 0; 
 int bcal = 0; 

 if(triggerTypes[jj][4].size() > 0) fcal = stoi(triggerTypes[jj][4]); 
 if(triggerTypes[jj][5].size() > 0) bcal = stoi(triggerTypes[jj][5]); 


 if( (fcal > 0) && (bcal > 0)){             // FCAL & BCAL 
   trigger_tmp.type  =  0x3;
   trigger_tmp.gtp.fcal      =   fcal;
   trigger_tmp.gtp.bcal      =   bcal;
   if(triggerTypes[jj][6].size() > 0) trigger_tmp.gtp.en_thr = stoi(triggerTypes[jj][6]);
   
   if(triggerTypes[jj].size() > 9){
     if((triggerTypes[jj].size() >= 10) && (triggerTypes[jj][9].size() > 0))  trigger_tmp.gtp.fcal_min  =   stoi(triggerTypes[jj][9]);
     if((triggerTypes[jj].size() >= 11) && (triggerTypes[jj][10].size() > 0)) trigger_tmp.gtp.fcal_max  =   stoi(triggerTypes[jj][10]);
     if((triggerTypes[jj].size() >= 12) && (triggerTypes[jj][11].size() > 0)) trigger_tmp.gtp.bcal_min  =   stoi(triggerTypes[jj][11]);
     if((triggerTypes[jj].size() >= 13) && (triggerTypes[jj][12].size() > 0)) trigger_tmp.gtp.bcal_max  =   stoi(triggerTypes[jj][12]);
   }
   
   trig_found++;
 } else if ((fcal > 0) && (bcal == 0)){      // FCAL only
   trigger_tmp.type  =  0x1;
   trigger_tmp.gtp.fcal      =   fcal;
   if(triggerTypes[jj][6].size() > 0)  trigger_tmp.gtp.en_thr      =   stoi(triggerTypes[jj][6]);
   if(triggerTypes[jj].size() > 9){
     if(triggerTypes[jj][9].size() > 0) trigger_tmp.gtp.fcal_min   =   stoi(triggerTypes[jj][9]);
     if(triggerTypes[jj][10].size() > 0) trigger_tmp.gtp.fcal_max  =   stoi(triggerTypes[jj][10]);
   }
   trig_found++;
 } else if ((bcal > 0) && (fcal == 0)){      // BCAL only
   trigger_tmp.type  =  0x2;
   trigger_tmp.gtp.bcal      =   bcal;
   if(triggerTypes[jj][6].size() > 0)  trigger_tmp.gtp.en_thr    =   stoi(triggerTypes[jj][6]);
   if((triggerTypes[jj].size() >= 12) && (triggerTypes[jj][11].size() > 0))  trigger_tmp.gtp.bcal_min  =   stoi(triggerTypes[jj][11]);
   if((triggerTypes[jj].size() >= 13) && (triggerTypes[jj][12].size() > 0))  trigger_tmp.gtp.bcal_max  =   stoi(triggerTypes[jj][12]);

   
   trig_found++;
 } else {
   cout << " Incorrect parameters for BFCAL trigger " << endl;
 }
 
} else if(triggerTypes[jj][1] == "ST"){          //  ST 
 trigger_tmp.type    =  0x4;
 if(triggerTypes[jj][7].size() > 0)   trigger_tmp.gtp.st_nhit     =  stoi(triggerTypes[jj][7]);
 if((triggerTypes[jj].size() >= 14) && (triggerTypes[jj][13].size() > 0))  trigger_tmp.gtp.st_pattern  =  stoi(triggerTypes[jj][13]);

 trig_found++;
}   else if(triggerTypes[jj][1] == "PS"){        //  PS
 trigger_tmp.type    =  0x8;
 if(triggerTypes[jj][7].size() > 0)  trigger_tmp.gtp.ps_nhit      =  stoi(triggerTypes[jj][7]);
 if((triggerTypes[jj].size() >= 14) && (triggerTypes[jj][13].size() > 0)) trigger_tmp.gtp.ps_pattern   =  stoi(triggerTypes[jj][13]);
 trig_found++;
}  else if(triggerTypes[jj][1] == "TAGH"){       //  TAGH
 trigger_tmp.type     =  0x10;
 if(triggerTypes[jj][7].size() > 0)  trigger_tmp.gtp.tof_nhit      =  stoi(triggerTypes[jj][7]);
 if((triggerTypes[jj].size() >= 14) && (triggerTypes[jj][13].size() > 0)){
   trigger_tmp.gtp.tagh_pattern   =  stoi(triggerTypes[jj][13],nullptr,0);
 }

 trig_found++;
}  else if(triggerTypes[jj][1] == "TOF"){        //  TOF
 trigger_tmp.type     =  0x20;
 if(triggerTypes[jj][7].size() > 0)  trigger_tmp.gtp.ps_nhit      =  stoi(triggerTypes[jj][7]);
 if((triggerTypes[jj].size() >= 14) && (triggerTypes[jj][13].size() > 0)) trigger_tmp.gtp.tof_pattern   =  stoi(triggerTypes[jj][13]);
 trig_found++;
} else {
 cout << " Incorrect Trigger type " << triggerTypes[jj][1] << endl;
}

if(trig_found > 0){
 triggers_enabled.push_back(trigger_tmp);
}

    }  // Trigger lane is enabled      
  }    // Trigger types
    
}



// Load FCAL Trigger Masks

string comDir  = result.Sections["FCAL"].NameValues["FADC250_COM_DIR"];
string comVer  = result.Sections["FCAL"].NameValues["FADC250_COM_VER"];
string userDir = result.Sections["FCAL"].NameValues["FADC250_USER_DIR"];
string userVer = result.Sections["FCAL"].NameValues["FADC250_USER_VER"];


for(int crate = 1; crate <= 12; crate++){
  
  std::string s = std::to_string(crate);
  
  string comFileName   =  comDir  +  "/rocfcal" +s + "_fadc250_" + comVer + ".cnf";
  string userFileName  =  userDir + "/rocfcal"  +s + "_" + userVer + ".cnf";
      
  auto userFile = connection.GetFile(runnumber, userFileName);
  
  if(!userFile) {                                                         
    //      cout<<" USER File with name: "<< userFileName
    //	  <<" doesn't exist (not associated) with run: "<< runnumber <<endl;
    continue;      
  }
  
  
  auto userParseResult = rcdb::ConfigParser::ParseWithSlots(userFile->GetContent(), "FADC250_SLOTS");
  
  
  for(unsigned int slot = 3; slot <= 21; slot++){
    
    auto userValues = userParseResult.SectionsBySlotNumber[slot].NameVectors["FADC250_TRG_MASK"];  // Parse it and return
    
    if(userValues.size() > 0){
for (unsigned int ch = 0; ch < userValues.size(); ++ch) {

 if(userValues[ch].size() == 0) continue;
 
 if(stoi(userValues[ch]) > 0){

   uint32_t roc_id = 10 + crate;

   DTranslationTable::csc_t daq_index = {roc_id, slot, ch };
   
   DTranslationTable::DChannelInfo channel_info;
   
   try {		
     channel_info = ttab[0]->GetDetectorIndex(daq_index);	      
   }
   
   catch(...){
     if(print_messages) cout << "Exception: FCAL channel is not in the translation table  " <<  " Crate = " << 10 + crate << "  Slot = " << slot << 
" Channel = " << ch << endl;
     continue;
   }
   	    
   fcal_mod tmp;

   tmp.roc     =  crate;	    
   tmp.slot    =  slot;
   tmp.ch      =  ch;
   
   tmp.row = channel_info.fcal.row;
   tmp.col = channel_info.fcal.col;
   
   fcal_trig_mask.push_back(tmp);
 }
 
}

    }	
    
  }  // Loop over slots
}    // Loop over crates       




// Load BCAL Trigger Masks

comDir  = result.Sections["BCAL"].NameValues["FADC250_COM_DIR"];
comVer  = result.Sections["BCAL"].NameValues["FADC250_COM_VER"];
userDir = result.Sections["BCAL"].NameValues["FADC250_USER_DIR"];
userVer = result.Sections["BCAL"].NameValues["FADC250_USER_VER"];


for(int crate = 1; crate <= 12; crate++){
  
  if( (crate == 3) || (crate == 6) || (crate == 9) || (crate == 12)) continue;

  std::string s = std::to_string(crate);
  
  string comFileName   =  comDir  +  "/rocbcal" +s + "_fadc250_" + comVer + ".cnf";
  string userFileName  =  userDir + "/rocbcal"  +s + "_" + userVer + ".cnf";
  
  auto userFile = connection.GetFile(runnumber, userFileName);
  
  if(!userFile){
    //      cout<<" USER File with name: "<< userFileName
    //	  <<" doesn't exist (not associated) with run: "<< runnumber <<endl;                                               
    continue;
  }
  
  
  auto userParseResult = rcdb::ConfigParser::ParseWithSlots(userFile->GetContent(), "FADC250_SLOTS");
    
  for(unsigned int slot = 3; slot <= 21; slot++){
    
    auto userValues = userParseResult.SectionsBySlotNumber[slot].NameVectors["FADC250_TRG_MASK"];  // Parse it and return
    
    if(userValues.size() > 0){

for (unsigned int ch = 0; ch < userValues.size(); ++ch) {

 if(userValues[ch].size() == 0) continue;
 
 if(stoi(userValues[ch]) > 0){

   uint32_t roc_id = 30 + crate;

   DTranslationTable::csc_t daq_index = {roc_id, slot, ch };
   
   DTranslationTable::DChannelInfo channel_info;
   
   try {		
     channel_info = ttab[0]->GetDetectorIndex(daq_index);	      
   }
   
   catch(...){
     cout << "Exception: BCAL channel is not in the translation table  " <<  " Crate = " << 30 + crate << "  Slot = " << slot << 
" Channel = " << ch << endl;
     continue;
   }
   
   
   bcal_mod tmp;

   tmp.roc     =  crate;	    
   tmp.slot    =  slot;
   tmp.ch      =  ch;

   tmp.module  =  channel_info.bcal.module;
   tmp.layer   =  channel_info.bcal.layer;
   tmp.sector  =  channel_info.bcal.sector;	      
   tmp.end     =  channel_info.bcal.end;

   bcal_trig_mask.push_back(tmp);
 }
 
}

    }	
    
  }  // Loop over slots
}    // Loop over crates       

return 0;

1041#else // HAVE_RCDB

return 10; // RCDB is not available

1045#endif

1047}


1050int  DL1MCTrigger_factory::SignalPulse(double en, double time, double amp_array[sample], int type){
 

// Parameterize and digitize pulse shapes. Sum up amplitudes
// type = 1 - FCAL
// type = 2 - BCAL

float exp_par = 0.358;

int pulse_length = 20;

if(type == 2) exp_par = 0.18;

int sample_first = (int)floor(time/time_stamp);

// digitization range
int ind_min = sample_first + 1;
int ind_max = ind_min + pulse_length + 1;
  
if( (ind_min > sample) || (ind_min < 0)){
  //    cout << " SignalPulse() FATAL error: time out of range   "  <<  time <<  "     " << ind_min << endl;
  return 1;
}

if(ind_max > sample){
  //    cout << " SignalPulse(): ind_max set to maximum" << time <<  "  "  << ind_max << endl;
  ind_max = sample - 1;
}

for(int i = ind_min; i < ind_max; i++ ){
  double adc_t  =  time_stamp*i - time;
  double amp    =  exp_par*exp_par*exp(-adc_t*exp_par)*adc_t;
  
  //    amp_array[i] += (int)(amp*time_stamp*en + 0.5);
  //    if(amp_array[i] > max_adc_bins){
  //      amp_array[i] = max_adc_bins;
  //    }   
  
  amp_array[i] += amp*time_stamp*en;
  
}

return 0;  
1093}

1095int DL1MCTrigger_factory::GTP(int detector){

// 1  - FCAL
// 2  - BCAL

int INT_WINDOW = 20; 

switch(detector){
case 1:
  INT_WINDOW =  FCAL_WINDOW;
  break;
case 2:
  INT_WINDOW =  BCAL_WINDOW;
  break;
default:
  break;
}

int index_min = 0;
int index_max = 0;

for(unsigned int samp = 0; samp < sample; samp++){

  index_max = samp;
  index_min = samp - INT_WINDOW;
  
  if(index_min < 0) index_min = 0;

  int energy_sum = 0;

  for(int ii = index_min; ii <= index_max; ii++){
    if(detector == 1)
energy_sum += fcal_ssp[ii];
    else 
energy_sum += bcal_ssp[ii];
  }

  if(detector == 1)
    fcal_gtp[samp] = energy_sum;
  else 
    bcal_gtp[samp] = energy_sum;
}  

return 0;

1140}


1143template <typename T>  int DL1MCTrigger_factory::FADC_SSP(vector<T> merged_hits, int detector){

//  1  - FCAL
//  2  - BCAL

int EN_THR =  4096; 
int NSA    =  10;
int NSB    =  3;;

switch(detector){
case 1:
  EN_THR =  FCAL_CELL_THR;
  NSA    =  FCAL_NSA;
  NSB    =  FCAL_NSB;
  break;
case 2:
  EN_THR =  BCAL_CELL_THR;
  NSA    =  BCAL_NSA;
  NSB    =  BCAL_NSB;
  break;
default:
  break;
}

for(unsigned int hit = 0; hit < merged_hits.size(); hit++){

  int index_min  =  -10;
  int index_max  =  -10;
  
  for(int ii = 0; ii < sample; ii++){

    int pulse_found = 0;

    if(merged_hits[hit].adc_amp[ii] >= EN_THR){
pulse_found = 1;
    } else {
continue;
    }
    
    index_min = ii - NSB;

    if(index_max > index_min) index_min = index_max + 1;

    index_max = ii + NSA - 1;

    if(index_min < 0) index_min = 0;

    if(index_max >= sample){
index_max = sample - 1;
    }

    int extend_nsa = 1;

    // Extend FADC range if needed
    
    while(extend_nsa){

int index_tmp = index_max + 1;

if(index_tmp < sample){
 if(merged_hits[hit].adc_amp[index_tmp] >= EN_THR){
   index_max += NSA;
 } else extend_nsa = 0;
} else extend_nsa = 0;	
    }
    
    if(index_max >= sample)
index_max = sample - 1;
        
    for(int kk = index_min; kk <= index_max; kk++){
if(detector == 1){
 if((merged_hits[hit].adc_amp[kk] - 100) > 0)
   fcal_ssp[kk] += (merged_hits[hit].adc_amp[kk] - TRIG_BASELINE);
}
else if(detector == 2){
 if((merged_hits[hit].adc_amp[kk] - 100) > 0)
   bcal_ssp[kk] += (merged_hits[hit].adc_amp[kk] - TRIG_BASELINE);
}
    }
    
    if(pulse_found == 1){
ii = index_max + 1;
pulse_found = 0;
    }
    
  }        
  
}

return 0;
1233}

1235void DL1MCTrigger_factory::PrintTriggers(){

string detector;
int nhit = 0;
unsigned int pattern = 0;

cout << endl << endl;
cout << " ------------  Trigger Settings --------------- " << endl;
cout << endl << endl;

cout << "----------- FCAL ----------- " << endl << endl;

cout << "FCAL_CELL_THR  = " <<  setw(10) <<  FCAL_CELL_THR <<  endl;
cout << "FCAL_NSA       = " <<  setw(10) <<  FCAL_NSA      <<  endl;
cout << "FCAL_NSB       = " <<  setw(10) <<  FCAL_NSB      <<  endl;
cout << "FCAL_WINDOW    = " <<  setw(10) <<  FCAL_WINDOW   <<  endl;

cout << endl;

cout << "----------- BCAL ----------- " << endl << endl;

cout << "BCAL_CELL_THR  = " <<  setw(10) <<  BCAL_CELL_THR <<  endl;
cout << "BCAL_NSA       = " <<  setw(10) <<  BCAL_NSA      <<  endl;
cout << "BCAL_NSB       = " <<  setw(10) <<  BCAL_NSB      <<  endl;
cout << "BCAL_WINDOW    = " <<  setw(10) <<  BCAL_WINDOW   <<  endl;

cout << endl << endl;


if(triggers_enabled.size() > 0){
  cout  << "TYPE     "  << "FCAL_E   " << "BCAL_E   " << 
    "EN_THR   " << "NHIT     "  << "LANE     " << "FCAL_EMIN    " << "FCAL_EMAX   "  <<
    "BCAL_EMIN   " << "BCAL_EMAX   " << "PATTERN   " << endl;
}


for(unsigned int ii = 0; ii < triggers_enabled.size(); ii++){
  
  switch(triggers_enabled[ii].type){
  case 1: detector =  "BFCAL  ";
    break;
  case 2: detector =  "BFCAL  ";
    break;
  case 3: detector =  "BFCAL  ";
    break;
  case 4: detector =  "ST     ";
    nhit    = triggers_enabled[ii].gtp.st_nhit;
    pattern = triggers_enabled[ii].gtp.st_pattern;
    break;
  case 8: detector = "PS     ";
    nhit    = triggers_enabled[ii].gtp.ps_nhit;
    pattern = triggers_enabled[ii].gtp.ps_pattern;
    break;
  case 16: detector = "TAGH   ";
    nhit    = triggers_enabled[ii].gtp.tagh_nhit;
    pattern = triggers_enabled[ii].gtp.tagh_pattern;
    break;
  case 32: detector = "TOF   ";
    nhit    = triggers_enabled[ii].gtp.tof_nhit;
    pattern = triggers_enabled[ii].gtp.tof_pattern;
    break;
  default: detector = "NONE ";
    cout << " Unknown detector ===== " << triggers_enabled[ii].type << endl;
    break;
  }
  
  cout  << detector  <<  setw(6) <<  
    triggers_enabled[ii].gtp.fcal << setw(9) <<  
    triggers_enabled[ii].gtp.bcal << setw(11) <<  
    triggers_enabled[ii].gtp.en_thr << setw(6) <<  
    nhit << setw(9) << 
    triggers_enabled[ii].bit << setw(12) <<  
    triggers_enabled[ii].gtp.fcal_min << setw(14) <<
    triggers_enabled[ii].gtp.fcal_max << setw(10) <<
    triggers_enabled[ii].gtp.bcal_min << setw(14) <<
    triggers_enabled[ii].gtp.bcal_max << setw(8) <<
    hex << uppercase << "0x" << pattern << nouppercase << dec <<  endl;

}

cout << endl << endl;

1317}



1321int DL1MCTrigger_factory::FindTriggers(DL1MCTrigger *trigger){

int trig_found = 0;

// Main production trigger  
for(unsigned int ii = 0; ii < triggers_enabled.size(); ii++){
  
  if(triggers_enabled[ii].bit == 0){    // Main production trigger found
    
    int gtp_energy  = 0;
    int bcal_energy = 0;
    
    for(unsigned int samp = 0; samp < sample; samp++){

int bcal_samp = samp - BCAL_OFFSET;

if(bcal_samp < 0){
 bcal_energy = 0;
} else if(bcal_samp >= sample){ 
 bcal_energy = 0;
} else{ 
 bcal_energy = bcal_gtp[bcal_samp];
}


gtp_energy = triggers_enabled[ii].gtp.fcal*fcal_gtp[samp] + 
 triggers_enabled[ii].gtp.bcal*bcal_energy;

if(gtp_energy >= triggers_enabled[ii].gtp.en_thr){

 if(triggers_enabled[ii].gtp.fcal_min > 0) {     // FCAL > 0
   if(fcal_gtp[samp] > triggers_enabled[ii].gtp.fcal_min){
     trigger->trig_mask   = (trigger->trig_mask | 0x1);
     trigger->trig_time[0]   = samp - 25;
     trig_found++;
   }
 } else {
   
   trigger->trig_mask   = (trigger->trig_mask | 0x1);
   trigger->trig_time[0]   = samp - 25; 
   trig_found++;
 }
 
 break;

}  // Check energy threshold	
    }      
  }     // Trigger Bit 0


  if(triggers_enabled[ii].bit == 2){    //  BCAL trigger found
          
    int gtp_energy  = 0;
    int bcal_energy = 0;
    
    for(unsigned int samp = 0; samp < sample; samp++){

int bcal_samp = samp - BCAL_OFFSET;

if(bcal_samp < 0){
 bcal_energy = 0;
} else if(bcal_samp >= sample){ 
 bcal_energy = 0;
} else{ 
 bcal_energy = bcal_gtp[bcal_samp];
}
     
gtp_energy = triggers_enabled[ii].gtp.bcal*bcal_energy;
    
if(gtp_energy >= triggers_enabled[ii].gtp.en_thr){
 
 trigger->trig_mask   = (trigger->trig_mask | 0x4);
 trigger->trig_time[2]   = samp - 25; 
 trig_found++;

 break;
 
}  // Energy threshold			
    }
  }      // Trigger Bit  3

}    // Loop over triggers found in the config file

return trig_found;

1406}


1409// Fill fcal calibration tables similar to FCALHit factory
1410void DL1MCTrigger_factory::LoadFCALConst(fcal_constants_t &table, const vector<double> &fcal_const_ch, 
			 const DFCALGeometry  &fcalGeom){
for (int ch = 0; ch < static_cast<int>(fcal_const_ch.size()); ch++) {
  int row = fcalGeom.row(ch);
  int col = fcalGeom.column(ch);
  table[row][col] = fcal_const_ch[ch];
}
	
1418}

1420void DL1MCTrigger_factory::Digitize(double adc_amp[sample], int adc_count[sample]){

for(int samp = 0; samp < sample; samp++ ){
  
  adc_count[samp] += (int)(adc_amp[samp] + TRIG_BASELINE + 0.5);

  if(adc_count[samp] > max_adc_bins)
    adc_count[samp] = max_adc_bins;

}
1430}


1433void DL1MCTrigger_factory::AddBaseline(double adc_amp[sample], double pedestal, DRandom2 &gDRandom){

double pedestal_correct = pedestal - TRIG_BASELINE;

for(int samp = 0; samp < sample; samp++ ){  
  double tmp = gDRandom.Gaus(pedestal_correct, pedestal_sigma);   
  adc_amp[samp] += tmp;
  //    cout << "  " << tmp;
}

if(debug){
  cout << endl;    
  cout << " Corrected pedestals = " << pedestal_correct << "  " <<  adc_amp[sample - 2] 
<< "  " << pedestal_sigma << endl; 
}

1449}



1453void DL1MCTrigger_factory::GetSeeds(JEventLoop *loop, uint64_t eventnumber, UInt_t &seed1, UInt_t &seed2, UInt_t &seed3){

// Use seeds similar to mcsmear

JEvent& event = loop->GetJEvent();

JEventSource *source = event.GetJEventSource();

DEventSourceHDDM *hddm_source = dynamic_cast<DEventSourceHDDM*>(source);

if (!hddm_source) {

  cerr << "DL1MCTrigger_factory:  This program MUST be used with an HDDM file as input!" << endl;
  cerr << "   Default seeds will be used for the random generator  " << endl;
  seed1 = 259921049 + eventnumber;
  seed2 = 442249570 + eventnumber;
  seed3 = 709975946 + eventnumber;
} else {

  hddm_s::HDDM *record = (hddm_s::HDDM*)event.GetRef();
  if (!record){
    seed1 = 259921049 + eventnumber;
    seed2 = 442249570 + eventnumber;
    seed3 = 709975946 + eventnumber;  
  } else {
    
    
    hddm_s::ReactionList::iterator reiter = record->getReactions().begin();
    
    hddm_s::Random my_rand = reiter->getRandom();

    // Copy seeds from event record to local variables
    seed1 = my_rand.getSeed1();
    seed2 = my_rand.getSeed2();
    seed3 = my_rand.getSeed3();
    
    // If no seeds are stored in the hddm file, generate them in the same way
    // as in mcsmear      
    if ((seed1 == 0) || (seed2 == 0) || (seed3 == 0)){
uint64_t eventNo = record->getPhysicsEvent().getEventNo();
seed1 = 259921049 + eventNo;
seed2 = 442249570 + eventNo;
seed3 = 709975946 + eventNo;

    }
    
  }  // Record doesn't exist
}    // Not an HDDM file
1501}

←

/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h

→

1// $Id: JEventLoop.h 1763 2006-05-10 14:29:25Z davidl $
2//
3//    File: JEventLoop.h
4// Created: Wed Jun  8 12:30:51 EDT 2005
5// Creator: davidl (on Darwin wire129.jlab.org 7.8.0 powerpc)
6//

8#ifndef _JEventLoop_
9#define _JEventLoop_

11#include <sys/time.h>

13#include <vector>
14#include <list>
15#include <string>
16#include <utility>
17#include <typeinfo>
18#include <string.h>
19#include <map>
20#include <utility>
21using std::vector;
22using std::list;
23using std::string;
24using std::type_info;

26#include <JANA/jerror.h>
27#include <JANA/JObject.h>
28#include <JANA/JException.h>
29#include <JANA/JEvent.h>
30#include <JANA/JThread.h>
31#include <JANA/JFactory_base.h>
32#include <JANA/JCalibration.h>
33#include <JANA/JGeometry.h>
34#include <JANA/JResourceManager.h>
35#include <JANA/JStreamLog.h>

37// The following is here just so we can use ROOT's THtml class to generate documentation.
38#include "cint.h"


41// Place everything in JANA namespace
42namespace jana{


45template<class T> class JFactory;
46class JApplication;
47class JEventProcessor;


50class JEventLoop{
public:

friend class JApplication;

enum data_source_t{
	DATA_NOT_AVAILABLE = 1,
	DATA_FROM_CACHE,
	DATA_FROM_SOURCE,
	DATA_FROM_FACTORY
};

typedef struct{
	string caller_name;
	string caller_tag;
	string callee_name;
	string callee_tag;
	double start_time;
	double end_time;
	data_source_t data_source;
}call_stack_t;

typedef struct{
	const char* factory_name;
	string tag;
	const char* filename;
	int line;
}error_call_stack_t;

                                  JEventLoop(JApplication *app); ///< Constructor
					   virtual ~JEventLoop(); ////< Destructor
		   virtual const char* className(void){return static_className();}
			static const char* static_className(void){return "JEventLoop";}

				 JApplication* GetJApplication(void) const {return app;} ///< Get pointer to the JApplication object
                                void RefreshProcessorListFromJApplication(void); ///< Re-copy the list of JEventProcessors from JApplication
                    virtual jerror_t AddFactory(JFactory_base* factory); ///< Add a factory
					  jerror_t RemoveFactory(JFactory_base* factory); ///< Remove a factory
                      JFactory_base* GetFactory(const string data_name, const char *tag="", bool allow_deftag=true); ///< Get a specific factory pointer
              vector<JFactory_base*> GetFactories(void) const {return factories;} ///< Get all factory pointers
                                void GetFactoryNames(vector<string> &factorynames); ///< Get names of all factories in name:tag format
                                void GetFactoryNames(map<string,string> &factorynames); ///< Get names of all factories in map with key=name, value=tag
                  map<string,string> GetDefaultTags(void) const {return default_tags;}
                            jerror_t ClearFactories(void); ///< Reset all factories in preparation for next event.
					  jerror_t PrintFactories(int sparsify=0); ///< Print a list of all factories.
                            jerror_t Print(const string data_name, const char *tag=""); ///< Print the data of the given type

				 JCalibration* GetJCalibration();
              template<class T> bool GetCalib(string namepath, map<string,T> &vals);
              template<class T> bool GetCalib(string namepath, vector<T> &vals);
              template<class T> bool GetCalib(string namepath, T &val);

                          JGeometry* GetJGeometry();
              template<class T> bool GetGeom(string namepath, map<string,T> &vals);
	    template<class T> bool GetGeom(string namepath, T &val);

                   JResourceManager* GetJResourceManager(void);
                              string GetResource(string namepath);
              template<class T> bool GetResource(string namepath, T vals, int event_number=0);

                                void Initialize(void); ///< Do initializations just before event processing starts
                            jerror_t Loop(void); ///< Loop over events
                            jerror_t OneEvent(uint64_t event_number); ///< Process a specific single event (if source supports it)
                            jerror_t OneEvent(void); ///< Process a single event
                         inline void Pause(void){pause = 1;} ///< Pause event processing
                         inline void Resume(void){pause = 0;} ///< Resume event processing
                         inline void Quit(void){quit = 1;} ///< Clean up and exit the event loop
                         inline bool GetQuit(void) const {return quit;}
                                void QuitProgram(void);

                               // Support for random access of events
                          bool HasRandomAccess(void);
                          void AddToEventQueue(uint64_t event_number){ next_events_to_process.push_back(event_number); }
                          void AddToEventQueue(list<uint64_t> &event_numbers) { next_events_to_process.insert(next_events_to_process.end(), event_numbers.begin(), event_numbers.end()); }
                list<uint64_t> GetEventQueue(void){ return next_events_to_process; }
                          void ClearEventQueue(void){ next_events_to_process.clear(); }

      template<class T> JFactory<T>* GetSingle(const T* &t, const char *tag="", bool exception_if_not_one=true); ///< Get pointer to first data object from (source or factory).
      template<class T> JFactory<T>* Get(vector<const T*> &t, const char *tag="", bool allow_deftag=true); ///< Get data object pointers from (source or factory)
      template<class T> JFactory<T>* GetFromFactory(vector<const T*> &t, const char *tag="", data_source_t &data_source=null_data_source, bool allow_deftag=true); ///< Get data object pointers from factory
          template<class T> jerror_t GetFromSource(vector<const T*> &t, JFactory_base *factory=NULL__null); ///< Get data object pointers from source.
                      inline JEvent& GetJEvent(void){return event;} ///< Get pointer to the current JEvent object.
                         inline void SetJEvent(JEvent *event){this->event = *event;} ///< Set the JEvent pointer.
                         inline void SetAutoFree(int auto_free){this->auto_free = auto_free;} ///< Set the Auto-Free flag on/off
                    inline pthread_t GetPThreadID(void) const {return pthread_id;} ///< Get the pthread of the thread to which this JEventLoop belongs
                              double GetInstantaneousRate(void) const {return rate_instantaneous;} ///< Get the current event processing rate
                              double GetIntegratedRate(void) const {return rate_integrated;} ///< Get the current event processing rate
                              double GetLastEventProcessingTime(void) const {return delta_time_single;}
                        unsigned int GetNevents(void) const {return Nevents;}

                         inline bool CheckEventBoundary(uint64_t event_numberA, uint64_t event_numberB);

                         inline bool GetCallStackRecordingStatus(void){ return record_call_stack; }
                         inline void DisableCallStackRecording(void){ record_call_stack = false; }
                         inline void EnableCallStackRecording(void){ record_call_stack = true; }
                     inline void CallStackStart(JEventLoop::call_stack_t &cs, const string &caller_name, const string &caller_tag, const string callee_name, const string callee_tag);
                     inline void CallStackEnd(JEventLoop::call_stack_t &cs);
         inline vector<call_stack_t> GetCallStack(void){return call_stack;} ///< Get the current factory call stack
                         inline void AddToCallStack(call_stack_t &cs){if(record_call_stack) call_stack.push_back(cs);} ///< Add specified item to call stack record but only if record_call_stack is true
                         inline void AddToErrorCallStack(error_call_stack_t &cs){error_call_stack.push_back(cs);} ///< Add layer to the factory call stack
   inline vector<error_call_stack_t> GetErrorCallStack(void){return error_call_stack;} ///< Get the current factory error call stack
                                void PrintErrorCallStack(void); ///< Print the current factory call stack

                      const JObject* FindByID(JObject::oid_t id); ///< Find a data object by its identifier.
          template<class T> const T* FindByID(JObject::oid_t id); ///< Find a data object by its type and identifier
                      JFactory_base* FindOwner(const JObject *t); ///< Find the factory that owns a data object by pointer
                      JFactory_base* FindOwner(JObject::oid_t id); ///< Find a factory that owns a data object by identifier

                                     // User defined references
              template<class T> void SetRef(T *t);    ///< Add a user reference to this JEventLoop (must be a pointer)
                template<class T> T* GetRef(void);   ///< Get a user-defined reference of a specific type
        template<class T> vector<T*> GetRefsT(void); ///< Get all user-defined refrences of a specicif type
   vector<pair<const char*, void*> > GetRefs(void){ return user_refs; }  ///< Get copy of full list of user-defined references
              template<class T> void RemoveRef(T *t); ///< Remove user reference from list

							   // Convenience methods wrapping JEvent methods of same name
                      uint64_t GetStatus(void){return event.GetStatus();}
                          bool GetStatusBit(uint32_t bit){return event.GetStatusBit(bit);}
                          bool SetStatusBit(uint32_t bit, bool val=true){return event.SetStatusBit(bit, val);}
                          bool ClearStatusBit(uint32_t bit){return event.ClearStatusBit(bit);}
                          void ClearStatus(void){event.ClearStatus();}
                          void SetStatusBitDescription(uint32_t bit, string description){event.SetStatusBitDescription(bit, description);}
                        string GetStatusBitDescription(uint32_t bit){return event.GetStatusBitDescription(bit);}
                          void GetStatusBitDescriptions(map<uint32_t, string> &status_bit_descriptions){return event.GetStatusBitDescriptions(status_bit_descriptions);}
                              string StatusWordToString(void);

private:
JEvent event;
vector<JFactory_base*> factories;
vector<JEventProcessor*> processors;
vector<error_call_stack_t> error_call_stack;
vector<call_stack_t> call_stack;
JApplication *app;
JThread *jthread;
bool initialized;
bool print_parameters_called;
int pause;
int quit;
int auto_free;
pthread_t pthread_id;
map<string, string> default_tags;
vector<pair<string,string> > auto_activated_factories;
bool record_call_stack;
string caller_name;
string caller_tag;
vector<uint64_t> event_boundaries;
int32_t event_boundaries_run; ///< Run number boundaries were retrieved from (possbily 0)
list<uint64_t> next_events_to_process;

uint64_t Nevents;			      ///< Total events processed (this thread)
uint64_t Nevents_rate;		   ///< Num. events accumulated for "instantaneous" rate
double delta_time_single;		///< Time spent processing last event
double delta_time_rate;			///< Integrated time accumulated "instantaneous" rate (partial number of events)
double delta_time;				///< Total time spent processing events (this thread)
double rate_instantaneous;		///< Latest instantaneous rate
double rate_integrated;			///< Rate integrated over all events
 
static data_source_t null_data_source;

vector<pair<const char*, void*> > user_refs;
210};


213// The following is here just so we can use ROOT's THtml class to generate documentation.
214#ifdef G__DICTIONARY
215typedef JEventLoop::call_stack_t call_stack_t;
216typedef JEventLoop::error_call_stack_t error_call_stack_t;
217#endif

219#if !defined(__CINT__) && !defined(__CLING__)

221//-------------
222// GetSingle
223//-------------
224template<class T>
225JFactory<T>* JEventLoop::GetSingle(const T* &t, const char *tag, bool exception_if_not_one)
226{
/// This is a convenience method that can be used to get a pointer to the single
/// object of type T from the specified factory. It simply calls the Get(vector<...>) method
/// and copies the first pointer into "t" (or NULL if something other than 1 object is returned).
/// 
/// This is intended to address the common situation in which there is an interest
/// in the event if and only if there is exactly 1 object of type T. If the event
/// has no objects of that type or more than 1 object of that type (for the specified
/// factory) then an exception of type "unsigned long" is thrown with the value
/// being the number of objects of type T. You can supress the exception by setting
/// exception_if_not_one to false. In that case, you will have to check if t==NULL to
/// know if the call succeeded.
vector<const T*> v;
JFactory<T> *fac = Get(v, tag);

if(v.size()!=1){
t = NULL__null;
if(exception_if_not_one) throw v.size();
}

t = v[0];

return fac;
249}

251//-------------
252// Get
253//-------------
254template<class T> 
255JFactory<T>* JEventLoop::Get(vector<const T*> &t, const char *tag, bool allow_deftag)
256{
/// Retrieve or generate the array of objects of
/// type T for the curent event being processed
/// by this thread.
///
/// By default, preference is given to reading the
/// objects from the data source(e.g. file) before generating
/// them in the factory. A flag exists in the factory
/// however to change this so that the factory is
/// given preference.
///
/// Note that regardless of the setting of this flag,
/// the data are only either read in or generated once.
/// Ownership of the objects will always be with the
/// factory so subsequent calls will always return pointers to
/// the same data.
///
/// If the factory is called on to generate the data,
/// it is done by calling the factory's Get() method
/// which, in turn, calls the evnt() method. 
/// 
/// First, we just call the GetFromFactory() method.
/// It will make the initial decision as to whether
/// it should look in the source first or not. If
/// it returns NULL, then the factory couldn't be
/// found so we automatically try the file.
///
/// Note that if no factory exists to hold the objects
/// from the file, one can be created automatically
/// providing the <i>JANA:AUTOFACTORYCREATE</i>
/// configuration parameter is set.

// Check if a tag was specified for this data type to use for the
// default.
const char *mytag = tag1.1
'tag' is not equal to NULL
1
'tag' is not equal to NULL
1
'tag' is not equal to NULL
==NULL__null ? "":tag; // protection against NULL tags
2
←
'?' condition is false→
if(strlen(mytag)==0 && allow_deftag2.1
'allow_deftag' is true
1
'allow_deftag' is true
1
'allow_deftag' is true
){
3
←
Taking true branch→
map<string, string>::const_iterator iter = default_tags.find(T::static_className());
if(iter!=default_tags.end())tag = iter->second.c_str();
4
←
Assuming the condition is true→
5
←
Taking true branch→
6
←
Value assigned to 'tag'→
}


// If we are trying to keep track of the call stack then we
// need to add a new call_stack_t object to the the list
// and initialize it with the start time and caller/callee
// info.
call_stack_t cs;

// Optionally record starting info of call stack entry
if(record_call_stack) CallStackStart(cs, caller_name, caller_tag, T::static_className(), tag);
7
←
Assuming field 'record_call_stack' is false→
8
←
Taking false branch→

// Get the data (or at least try to)
JFactory<T>* factory=NULL__null;
try{
factory = GetFromFactory(t, tag, cs.data_source, allow_deftag);
9
←
Passing value via 2nd parameter 'tag'→
10
←
Calling 'JEventLoop::GetFromFactory'→
if(!factory){
	// No factory exists for this type and tag. It's possible
	// that the source may be able to provide the objects
	// but it will need a place to put them. We can create a
	// dumb JFactory just to hold the data in case the source
	// can provide the objects. Before we do though, make sure
	// the user condones this via the presence of the
	// "JANA:AUTOFACTORYCREATE" config parameter.
	string p;
	try{
		gPARMS->GetParameter("JANA:AUTOFACTORYCREATE", p);
	}catch(...){}
	if(p.size()==0){
		jout<<std::endl;
		_DBG__std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<324<<std::endl;
		jout<<"No factory of type \""<<T::static_className()<<"\" with tag \""<<tag<<"\" exists."<<std::endl;
		jout<<"If you are reading objects from a file, I can auto-create a factory"<<std::endl;
		jout<<"of the appropriate type to hold the objects, but this feature is turned"<<std::endl;
		jout<<"off by default. To turn it on, set the \"JANA:AUTOFACTORYCREATE\""<<std::endl;
		jout<<"configuration parameter. This can usually be done by passing the"<<std::endl;
		jout<<"following argument to the program from the command line:"<<std::endl;
		jout<<std::endl;
		jout<<"   -PJANA:AUTOFACTORYCREATE=1"<<std::endl;
		jout<<std::endl;
		jout<<"Note that since the most commonly expected occurance of this situation."<<std::endl;
		jout<<"is an error, the program will now throw an exception so that the factory."<<std::endl;
		jout<<"call stack can be printed."<<std::endl;
		jout<<std::endl;
		throw exception();
	}else{
		AddFactory(new JFactory<T>(tag));
		jout<<__FILE__"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"<<":"<<__LINE__341<<" Auto-created "<<T::static_className()<<":"<<tag<<" factory"<<std::endl;
	
		// Now try once more. The GetFromFactory method will call
		// GetFromSource since it's empty.
		factory = GetFromFactory(t, tag, cs.data_source, allow_deftag);
	}
}
}catch(exception &e){
// Uh-oh, an exception was thrown. Add us to the call stack
// and re-throw the exception
error_call_stack_t ecs;
ecs.factory_name = T::static_className();
ecs.tag = tag;
ecs.filename = NULL__null;
error_call_stack.push_back(ecs);
throw e;
}

// If recording the call stack, update the end_time field and add to stack
if(record_call_stack) CallStackEnd(cs);

return factory;
363}

365//-------------
366// GetFromFactory
367//-------------
368template<class T> 
369JFactory<T>* JEventLoop::GetFromFactory(vector<const T*> &t, const char *tag, data_source_t &data_source, bool allow_deftag)
370{
// We need to find the factory providing data type T with
// tag given by "tag". 
vector<JFactory_base*>::iterator iter=factories.begin();
JFactory<T> *factory = NULL__null;
string className(T::static_className());

// Check if a tag was specified for this data type to use for the
// default.
const char *mytag = tag==NULL__null ? "":tag; // protection against NULL tags
11
←
Assuming 'tag' is equal to NULL→
12
←
Assuming pointer value is null→
13
←
'?' condition is true→
if(strlen(mytag)==0 && allow_deftag13.1
'allow_deftag' is true
1
'allow_deftag' is true
1
'allow_deftag' is true
){
14
←
Taking true branch→
map<string, string>::const_iterator iter = default_tags.find(className);
if(iter!=default_tags.end())tag = iter->second.c_str();
15
←
Assuming the condition is false→
16
←
Taking false branch→
}

for(; iter!=factories.end(); iter++){
17
←
Calling 'operator!=<jana::JFactory_base **, std::vector<jana::JFactory_base *>>'→
20
←
Returning from 'operator!=<jana::JFactory_base **, std::vector<jana::JFactory_base *>>'→
21
←
Loop condition is true.  Entering loop body→
// It turns out a long standing bug in g++ makes dynamic_cast return
// zero improperly when used on objects created on one side of
// a dynamically shared object (DSO) and the cast occurs on the 
// other side. I saw bug reports ranging from 2001 to 2004. I saw
// saw it first-hand on LinuxEL4 using g++ 3.4.5. This is too bad
// since it is much more elegant (and safe) to use dynamic_cast.
// To avoid this problem which can occur with plugins, we check
// the name of the data classes are the same. (sigh)
//factory = dynamic_cast<JFactory<T> *>(*iter);
if(className == (*iter)->GetDataClassName())factory = (JFactory<T>*)(*iter);
22
←
Taking true branch→
if(factory == NULL__null)continue;
23
←
Assuming 'factory' is not equal to NULL→
24
←
Taking false branch→
const char *factag = factory->Tag()==NULL__null ? "":factory->Tag();
25
←
Assuming the condition is true→
26
←
'?' condition is true→
if(!strcmp(factag, tag)){
27
←
Null pointer passed to 2nd parameter expecting 'nonnull'
	break;
}else{
	factory=NULL__null;
}
}

// If factory not found, just return now
if(!factory){
data_source = DATA_NOT_AVAILABLE;
return NULL__null;
}

// OK, we found the factory. If the evnt() routine has already
// been called, then just call the factory's Get() routine
// to return a copy of the existing data
if(factory->evnt_was_called()){
factory->CopyFrom(t);
data_source = DATA_FROM_CACHE;
return factory;
}

// Next option is to get the objects from the data source
if(factory->GetCheckSourceFirst()){
// If the object type/tag is found in the source, it
// will return NOERROR, even if there are zero instances
// of it. If it is not available in the source then it
// will return OBJECT_NOT_AVAILABLE.

jerror_t err = GetFromSource(t, factory);
if(err == NOERROR){
	// A return value of NOERROR means the source had the objects
	// even if there were zero of them.(If the source had no
	// information about the objects OBJECT_NOT_AVAILABLE would 
	// have been returned.)
	// The GetFromSource() call will eventually lead to a call to
	// the GetObjects() method of the concrete class derived
	// from JEventSource. That routine should copy the object
	// pointers into the factory using the factory's CopyTo()
	// method which also sets the evnt_called flag for the factory.
	// Note also that the "t" vector is then filled with a call
	// to the factory's CopyFrom() method in JEvent::GetObjects().
	// All we need to do now is just set the factory pointers in
	// the newly generated JObjects and return the factory pointer.

	factory->SetFactoryPointers();
	data_source = DATA_FROM_SOURCE;

	return factory;
}
}

// OK. It looks like we have to have the factory make this.
// Get pointers to data from the factory.
factory->Get(t);
factory->SetFactoryPointers();
data_source = DATA_FROM_FACTORY;

return factory;
457}

459//-------------
460// GetFromSource
461//-------------
462template<class T> 
463jerror_t JEventLoop::GetFromSource(vector<const T*> &t, JFactory_base *factory)
464{
/// This tries to get objects from the event source.
/// "factory" must be a valid pointer to a JFactory
/// object since that will take ownership of the objects
/// created by the source.
/// This should usually be called from JEventLoop::GetFromFactory
/// which is called from JEventLoop::Get. The latter will
/// create a dummy JFactory of the proper flavor and tag if
/// one does not already exist so if objects exist in the
/// file without a corresponding factory to create them, they
/// can still be used.
if(!factory)throw OBJECT_NOT_AVAILABLE;

return event.GetObjects(t, factory);
478}

480//-------------
481// CallStackStart
482//-------------
483inline void JEventLoop::CallStackStart(JEventLoop::call_stack_t &cs, const string &caller_name, const string &caller_tag, const string callee_name, const string callee_tag)
484{
/// This is used to fill initial info into a call_stack_t stucture
/// for recording the call stack. It should be matched with a call
/// to CallStackEnd. It is normally called from the Get() method
/// above, but may also be used by external actors to manipulate
/// the call stack (presumably for good and not evil).

struct itimerval tmr;
getitimer(ITIMER_PROFITIMER_PROF, &tmr);

cs.caller_name    = this->caller_name;
cs.caller_tag     = this->caller_tag;
this->caller_name = cs.callee_name = callee_name;
this->caller_tag  = cs.callee_tag  = callee_tag;
cs.start_time = tmr.it_value.tv_sec + tmr.it_value.tv_usec/1.0E6;
499}

501//-------------
502// CallStackEnd
503//-------------
504inline void JEventLoop::CallStackEnd(JEventLoop::call_stack_t &cs)
505{
/// Complete a call stack entry. This should be matched
/// with a previous call to CallStackStart which was
/// used to fill the cs structure.

struct itimerval tmr;
getitimer(ITIMER_PROFITIMER_PROF, &tmr);
cs.end_time = tmr.it_value.tv_sec + tmr.it_value.tv_usec/1.0E6;
caller_name = cs.caller_name;
caller_tag  = cs.caller_tag;
call_stack.push_back(cs);
516}

518//-------------
519// CheckEventBoundary
520//-------------
521inline bool JEventLoop::CheckEventBoundary(uint64_t event_numberA, uint64_t event_numberB)
522{
/// Check whether the two event numbers span one or more boundaries
/// in the calibration/conditions database for the current run number.
/// Return true if they do and false if they don't. The first parameter
/// "event_numberA" is also checked if it lands on a boundary in which
/// case true is also returned. If event_numberB lands on a boundary,
/// but event_numberA does not, then false is returned.
///
/// This method is not expected to be called by a user. It is, however called,
/// everytime a JFactory's Get() method is called.

// Make sure our copy of the boundaries is up to date
if(event.GetRunNumber()!=event_boundaries_run){
event_boundaries.clear(); // in case we can't get the JCalibration pointer
JCalibration *jcalib = GetJCalibration();
if(jcalib)jcalib->GetEventBoundaries(event_boundaries);
event_boundaries_run = event.GetRunNumber();
}

// Loop over boundaries
for(unsigned int i=0; i<event_boundaries.size(); i++){
uint64_t eb = event_boundaries[i];
if((eb - event_numberA)*(eb - event_numberB) < 0.0 || eb==event_numberA){ // think about it ....
	// events span a boundary or is on a boundary. Return true
	return true;
}
}

return false;
551}

553//-------------
554// FindByID
555//-------------
556template<class T> 
557const T* JEventLoop::FindByID(JObject::oid_t id)
558{
/// This is a templated method that can be used in place
/// of the non-templated FindByID(oid_t) method if one knows
/// the class of the object with the specified id.
/// This method is faster than calling the non-templated
/// FindByID and dynamic_cast-ing the JObject since
/// this will only search the objects of factories that
/// produce the desired data type.
/// This method will cast the JObject pointer to one
/// of the specified type. To use this method,
/// a type is specified in the call as follows:
///
/// const DMyType *t = loop->FindByID<DMyType>(id);

// Loop over factories looking for ones that provide
// specified data type.
for(unsigned int i=0; i<factories.size(); i++){
if(factories[i]->GetDataClassName() != T::static_className())continue;

// This factory provides data of type T. Search it for
// the object with the specified id.
const JObject *my_obj = factories[i]->GetByID(id);
if(my_obj)return dynamic_cast<const T*>(my_obj);
}

return NULL__null;
584}

586//-------------
587// GetCalib (map)
588//-------------
589template<class T>
590bool JEventLoop::GetCalib(string namepath, map<string,T> &vals)
591{
/// Get the JCalibration object from JApplication for the run number of
/// the current event and call its Get() method to get the constants.

// Note that we could do this by making "vals" a generic type T thus, combining
// this with the vector version below. However, doing this explicitly will make
// it easier for the user to understand how to call us.

vals.clear();

JCalibration *calib = GetJCalibration();
if(!calib){
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<603<<" "<<"Unable to get JCalibration object for run "<<event.GetRunNumber()<<std::endl;
return true;
}

return calib->Get(namepath, vals, event.GetEventNumber());
608}

610//-------------
611// GetCalib (vector)
612//-------------
613template<class T> bool JEventLoop::GetCalib(string namepath, vector<T> &vals)
614{
/// Get the JCalibration object from JApplication for the run number of
/// the current event and call its Get() method to get the constants.

vals.clear();

JCalibration *calib = GetJCalibration();
if(!calib){
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<622<<" "<<"Unable to get JCalibration object for run "<<event.GetRunNumber()<<std::endl;
return true;
}

return calib->Get(namepath, vals, event.GetEventNumber());
627}

629//-------------
630// GetCalib (single)
631//-------------
632template<class T> bool JEventLoop::GetCalib(string namepath, T &val)
633{
/// This is a convenience method for getting a single entry. It
/// simply calls the vector version and returns the first entry.
/// It returns true if the vector version returns true AND there
/// is at least one entry in the vector. No check is made for there
/// there being more than one entry in the vector.

vector<T> vals;
bool ret = GetCalib(namepath, vals);
if(vals.empty()) return true;
val = vals[0];

return ret;
646}

648//-------------
649// GetGeom (map)
650//-------------
651template<class T>
652bool JEventLoop::GetGeom(string namepath, map<string,T> &vals)
653{
/// Get the JGeometry object from JApplication for the run number of
/// the current event and call its Get() method to get the constants.

// Note that we could do this by making "vals" a generic type T thus, combining
// this with the vector version below. However, doing this explicitly will make
// it easier for the user to understand how to call us.

vals.clear();

JGeometry *geom = GetJGeometry();
if(!geom){
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<665<<" "<<"Unable to get JGeometry object for run "<<event.GetRunNumber()<<std::endl;
return true;
}

return geom->Get(namepath, vals);
670}

672//-------------
673// GetGeom (atomic)
674//-------------
675template<class T> bool JEventLoop::GetGeom(string namepath, T &val)
676{
/// Get the JCalibration object from JApplication for the run number of
/// the current event and call its Get() method to get the constants.

JGeometry *geom = GetJGeometry();
if(!geom){
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<682<<" "<<"Unable to get JGeometry object for run "<<event.GetRunNumber()<<std::endl;
return true;
}

return geom->Get(namepath, val);
687}

689//-------------
690// SetRef
691//-------------
692template<class T>
693void JEventLoop::SetRef(T *t)
694{
pair<const char*, void*> p(typeid(T).name(), (void*)t);
user_refs.push_back(p);
697}

699//-------------
700// GetResource
701//-------------
702template<class T> bool JEventLoop::GetResource(string namepath, T vals, int event_number)
703{
JResourceManager *resource_manager = GetJResourceManager();
if(!resource_manager){
string mess = string("Unable to get the JResourceManager object (namepath=\"")+namepath+"\")";
throw JException(mess);
}

return resource_manager->Get(namepath, vals, event_number);
711}

713//-------------
714// GetRef
715//-------------
716template<class T>
717T* JEventLoop::GetRef(void)
718{
/// Get a user-defined reference (a pointer)
for(unsigned int i=0; i<user_refs.size(); i++){
if(user_refs[i].first == typeid(T).name()) return (T*)user_refs[i].second;
}

return NULL__null;
725}

727//-------------
728// GetRefsT
729//-------------
730template<class T>
731vector<T*> JEventLoop::GetRefsT(void)
732{
vector<T*> refs;
for(unsigned int i=0; i<user_refs.size(); i++){
if(user_refs[i].first == typeid(T).name()){
	refs.push_back((T*)user_refs[i].second);
}
}

return refs;
741}

743//-------------
744// RemoveRef
745//-------------
746template<class T>
747void JEventLoop::RemoveRef(T *t)
748{
vector<pair<const char*, void*> >::iterator iter;
for(iter=user_refs.begin(); iter!= user_refs.end(); iter++){
if(iter->second == (void*)t){
	user_refs.erase(iter);
	return;
}
}
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<756<<" "<<" Attempt to remove user reference not in event loop!" << std::endl;
757}


760#endif //__CINT__  __CLING__

762} // Close JANA namespace



766#endif // _JEventLoop_


←

/usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/bits/stl_iterator.h

1// Iterators -*- C++ -*-

3// Copyright (C) 2001-2013 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*/

51/** @file bits/stl_iterator.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{iterator}
*
*  This file implements reverse_iterator, back_insert_iterator,
*  front_insert_iterator, insert_iterator, __normal_iterator, and their
*  supporting functions and overloaded operators.
*/

60#ifndef _STL_ITERATOR_H1
61#define _STL_ITERATOR_H1 1

63#include <bits/cpp_type_traits.h>
64#include <ext/type_traits.h>
65#include <bits/move.h>

67namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
68{
69_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup iterators
 * @{
 */

// 24.4.1 Reverse iterators
/**
 *  Bidirectional and random access iterators have corresponding reverse
 *  %iterator adaptors that iterate through the data structure in the
 *  opposite direction.  They have the same signatures as the corresponding
 *  iterators.  The fundamental relation between a reverse %iterator and its
 *  corresponding %iterator @c i is established by the identity:
 *  @code
 *      &*(reverse_iterator(i)) == &*(i - 1)
 *  @endcode
 *
 *  <em>This mapping is dictated by the fact that while there is always a
 *  pointer past the end of an array, there might not be a valid pointer
 *  before the beginning of an array.</em> [24.4.1]/1,2
 *
 *  Reverse iterators can be tricky and surprising at first.  Their
 *  semantics make sense, however, and the trickiness is a side effect of
 *  the requirement that the iterators must be safe.
*/
template<typename _Iterator>
  class reverse_iterator
  : public iterator<typename iterator_traits<_Iterator>::iterator_category,
      typename iterator_traits<_Iterator>::value_type,
      typename iterator_traits<_Iterator>::difference_type,
      typename iterator_traits<_Iterator>::pointer,
                    typename iterator_traits<_Iterator>::reference>
  {
  protected:
    _Iterator current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::difference_type	difference_type;
    typedef typename __traits_type::pointer		pointer;
    typedef typename __traits_type::reference		reference;

    /**
     *  The default constructor value-initializes member @p current.
     *  If it is a pointer, that means it is zero-initialized.
    */
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 235 No specification of default ctor for reverse_iterator
    reverse_iterator() : current() { }

    /**
     *  This %iterator will move in the opposite direction that @p x does.
    */
    explicit
    reverse_iterator(iterator_type __x) : current(__x) { }

    /**
     *  The copy constructor is normal.
    */
    reverse_iterator(const reverse_iterator& __x)
    : current(__x.current) { }

    /**
     *  A %reverse_iterator across other types can be copied if the
     *  underlying %iterator can be converted to the type of @c current.
    */
    template<typename _Iter>
      reverse_iterator(const reverse_iterator<_Iter>& __x)
: current(__x.base()) { }

    /**
     *  @return  @c current, the %iterator used for underlying work.
    */
    iterator_type
    base() const
    { return current; }

    /**
     *  @return  A reference to the value at @c --current
     *
     *  This requires that @c --current is dereferenceable.
     *
     *  @warning This implementation requires that for an iterator of the
     *           underlying iterator type, @c x, a reference obtained by
     *           @c *x remains valid after @c x has been modified or
     *           destroyed. This is a bug: http://gcc.gnu.org/PR51823
    */
    reference
    operator*() const
    {
_Iterator __tmp = current;
return *--__tmp;
    }

    /**
     *  @return  A pointer to the value at @c --current
     *
     *  This requires that @c --current is dereferenceable.
    */
    pointer
    operator->() const
    { return &(operator*()); }

    /**
     *  @return  @c *this
     *
     *  Decrements the underlying iterator.
    */
    reverse_iterator&
    operator++()
    {
--current;
return *this;
    }

    /**
     *  @return  The original value of @c *this
     *
     *  Decrements the underlying iterator.
    */
    reverse_iterator
    operator++(int)
    {
reverse_iterator __tmp = *this;
--current;
return __tmp;
    }

    /**
     *  @return  @c *this
     *
     *  Increments the underlying iterator.
    */
    reverse_iterator&
    operator--()
    {
++current;
return *this;
    }

    /**
     *  @return  A reverse_iterator with the previous value of @c *this
     *
     *  Increments the underlying iterator.
    */
    reverse_iterator
    operator--(int)
    {
reverse_iterator __tmp = *this;
++current;
return __tmp;
    }

    /**
     *  @return  A reverse_iterator that refers to @c current - @a __n
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator
    operator+(difference_type __n) const
    { return reverse_iterator(current - __n); }

    /**
     *  @return  *this
     *
     *  Moves the underlying iterator backwards @a __n steps.
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator&
    operator+=(difference_type __n)
    {
current -= __n;
return *this;
    }

    /**
     *  @return  A reverse_iterator that refers to @c current - @a __n
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator
    operator-(difference_type __n) const
    { return reverse_iterator(current + __n); }

    /**
     *  @return  *this
     *
     *  Moves the underlying iterator forwards @a __n steps.
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator&
    operator-=(difference_type __n)
    {
current += __n;
return *this;
    }

    /**
     *  @return  The value at @c current - @a __n - 1
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reference
    operator[](difference_type __n) const
    { return *(*this + __n); }
  };

//@{
/**
 *  @param  __x  A %reverse_iterator.
 *  @param  __y  A %reverse_iterator.
 *  @return  A simple bool.
 *
 *  Reverse iterators forward many operations to their underlying base()
 *  iterators.  Others are implemented in terms of one another.
 *
*/
template<typename _Iterator>
  inline bool
  operator==(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return __x.base() == __y.base(); }

template<typename _Iterator>
  inline bool
  operator<(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y.base() < __x.base(); }

template<typename _Iterator>
  inline bool
  operator!=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__x == __y); }

template<typename _Iterator>
  inline bool
  operator>(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y < __x; }

template<typename _Iterator>
  inline bool
  operator<=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__y < __x); }

template<typename _Iterator>
  inline bool
  operator>=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__x < __y); }

template<typename _Iterator>
  inline typename reverse_iterator<_Iterator>::difference_type
  operator-(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y.base() - __x.base(); }

template<typename _Iterator>
  inline reverse_iterator<_Iterator>
  operator+(typename reverse_iterator<_Iterator>::difference_type __n,
     const reverse_iterator<_Iterator>& __x)
  { return reverse_iterator<_Iterator>(__x.base() - __n); }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 280. Comparison of reverse_iterator to const reverse_iterator.
template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator==(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return __x.base() == __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  { return __y.base() < __x.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator!=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__x == __y); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  { return __y < __x; }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__y < __x); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__x < __y); }

template<typename _IteratorL, typename _IteratorR>
376#if __cplusplus201103L >= 201103L
  // DR 685.
  inline auto
  operator-(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  -> decltype(__y.base() - __x.base())
382#else
  inline typename reverse_iterator<_IteratorL>::difference_type
  operator-(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
386#endif
  { return __y.base() - __x.base(); }
//@}

// 24.4.2.2.1 back_insert_iterator
/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator appends it to the container using
 *  push_back.
 *
 *  Tip:  Using the back_inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class back_insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /// The only way to create this %iterator is with a container.
    explicit
    back_insert_iterator(_Container& __x) : container(&__x) { }

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator doesn't really have a @a position in the
     *  container (you can think of the position as being permanently at
     *  the end, if you like).  Assigning a value to the %iterator will
     *  always append the value to the end of the container.
    */
427#if __cplusplus201103L < 201103L
    back_insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
container->push_back(__value);
return *this;
    }
434#else
    back_insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
container->push_back(__value);
return *this;
    }

    back_insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
container->push_back(std::move(__value));
return *this;
    }
448#endif

    /// Simply returns *this.
    back_insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    back_insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    back_insert_iterator
    operator++(int)
    { return *this; }
  };

/**
 *  @param  __x  A container of arbitrary type.
 *  @return  An instance of back_insert_iterator working on @p __x.
 *
 *  This wrapper function helps in creating back_insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container>
  inline back_insert_iterator<_Container>
  back_inserter(_Container& __x)
  { return back_insert_iterator<_Container>(__x); }

/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator prepends it to the container using
 *  push_front.
 *
 *  Tip:  Using the front_inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class front_insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /// The only way to create this %iterator is with a container.
    explicit front_insert_iterator(_Container& __x) : container(&__x) { }

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator doesn't really have a @a position in the
     *  container (you can think of the position as being permanently at
     *  the front, if you like).  Assigning a value to the %iterator will
     *  always prepend the value to the front of the container.
    */
517#if __cplusplus201103L < 201103L
    front_insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
container->push_front(__value);
return *this;
    }
524#else
    front_insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
container->push_front(__value);
return *this;
    }

    front_insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
container->push_front(std::move(__value));
return *this;
    }
538#endif

    /// Simply returns *this.
    front_insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    front_insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    front_insert_iterator
    operator++(int)
    { return *this; }
  };

/**
 *  @param  __x  A container of arbitrary type.
 *  @return  An instance of front_insert_iterator working on @p x.
 *
 *  This wrapper function helps in creating front_insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container>
  inline front_insert_iterator<_Container>
  front_inserter(_Container& __x)
  { return front_insert_iterator<_Container>(__x); }

/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator inserts it in the container at the
 *  %iterator's position, rather than overwriting the value at that
 *  position.
 *
 *  (Sequences will actually insert a @e copy of the value before the
 *  %iterator's position.)
 *
 *  Tip:  Using the inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;
    typename _Container::iterator iter;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /**
     *  The only way to create this %iterator is with a container and an
     *  initial position (a normal %iterator into the container).
    */
    insert_iterator(_Container& __x, typename _Container::iterator __i)
    : container(&__x), iter(__i) {}

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator maintains its own position in the
     *  container.  Assigning a value to the %iterator will insert the
     *  value into the container at the place before the %iterator.
     *
     *  The position is maintained such that subsequent assignments will
     *  insert values immediately after one another.  For example,
     *  @code
     *     // vector v contains A and Z
     *
     *     insert_iterator i (v, ++v.begin());
     *     i = 1;
     *     i = 2;
     *     i = 3;
     *
     *     // vector v contains A, 1, 2, 3, and Z
     *  @endcode
    */
628#if __cplusplus201103L < 201103L
    insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
iter = container->insert(iter, __value);
++iter;
return *this;
    }
636#else
    insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
iter = container->insert(iter, __value);
++iter;
return *this;
    }

    insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
iter = container->insert(iter, std::move(__value));
++iter;
return *this;
    }
652#endif

    /// Simply returns *this.
    insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    insert_iterator&
    operator++(int)
    { return *this; }
  };

/**
 *  @param __x  A container of arbitrary type.
 *  @return  An instance of insert_iterator working on @p __x.
 *
 *  This wrapper function helps in creating insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container, typename _Iterator>
  inline insert_iterator<_Container>
  inserter(_Container& __x, _Iterator __i)
  {
    return insert_iterator<_Container>(__x,
			 typename _Container::iterator(__i));
  }

// @} group iterators

691_GLIBCXX_END_NAMESPACE_VERSION
692} // namespace

694namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
695{
696_GLIBCXX_BEGIN_NAMESPACE_VERSION

// This iterator adapter is @a normal in the sense that it does not
// change the semantics of any of the operators of its iterator
// parameter.  Its primary purpose is to convert an iterator that is
// not a class, e.g. a pointer, into an iterator that is a class.
// The _Container parameter exists solely so that different containers
// using this template can instantiate different types, even if the
// _Iterator parameter is the same.
using std::iterator_traits;
using std::iterator;
template<typename _Iterator, typename _Container>
  class __normal_iterator
  {
  protected:
    _Iterator _M_current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::iterator_category iterator_category;
    typedef typename __traits_type::value_type  	value_type;
    typedef typename __traits_type::difference_type 	difference_type;
    typedef typename __traits_type::reference 	reference;
    typedef typename __traits_type::pointer   	pointer;

    _GLIBCXX_CONSTEXPRconstexpr __normal_iterator() : _M_current(_Iterator()) { }

    explicit
    __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

    // Allow iterator to const_iterator conversion
    template<typename _Iter>
      __normal_iterator(const __normal_iterator<_Iter,
	  typename __enable_if<
    	       (std::__are_same<_Iter, typename _Container::pointer>::__value),
      _Container>::__type>& __i)
      : _M_current(__i.base()) { }

    // Forward iterator requirements
    reference
    operator*() const
    { return *_M_current; }

    pointer
    operator->() const
    { return _M_current; }

    __normal_iterator&
    operator++()
    {
++_M_current;
return *this;
    }

    __normal_iterator
    operator++(int)
    { return __normal_iterator(_M_current++); }

    // Bidirectional iterator requirements
    __normal_iterator&
    operator--()
    {
--_M_current;
return *this;
    }

    __normal_iterator
    operator--(int)
    { return __normal_iterator(_M_current--); }

    // Random access iterator requirements
    reference
    operator[](const difference_type& __n) const
    { return _M_current[__n]; }

    __normal_iterator&
    operator+=(const difference_type& __n)
    { _M_current += __n; return *this; }

    __normal_iterator
    operator+(const difference_type& __n) const
    { return __normal_iterator(_M_current + __n); }

    __normal_iterator&
    operator-=(const difference_type& __n)
    { _M_current -= __n; return *this; }

    __normal_iterator
    operator-(const difference_type& __n) const
    { return __normal_iterator(_M_current - __n); }

    const _Iterator&
    base() const
    { return _M_current; }
  };

// Note: In what follows, the left- and right-hand-side iterators are
// allowed to vary in types (conceptually in cv-qualification) so that
// comparison between cv-qualified and non-cv-qualified iterators be
// valid.  However, the greedy and unfriendly operators in std::rel_ops
// will make overload resolution ambiguous (when in scope) if we don't
// provide overloads whose operands are of the same type.  Can someone
// remind me what generic programming is about? -- Gaby

// Forward iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }
18
←
Assuming the condition is true→
19
←
Returning the value 1, which participates in a condition later→

// Random access iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// According to the resolution of DR179 not only the various comparison
// operators but also operator- must accept mixed iterator/const_iterator
// parameters.
template<typename _IteratorL, typename _IteratorR, typename _Container>
881#if __cplusplus201103L >= 201103L
  // DR 685.
  inline auto
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  -> decltype(__lhs.base() - __rhs.base())
887#else
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
891#endif
  { return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline typename __normal_iterator<_Iterator, _Container>::difference_type
  operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
     __n, const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }

906_GLIBCXX_END_NAMESPACE_VERSION
907} // namespace

909#if __cplusplus201103L >= 201103L

911namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
912{
913_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup iterators
 * @{
 */

// 24.4.3  Move iterators
/**
 *  Class template move_iterator is an iterator adapter with the same
 *  behavior as the underlying iterator except that its dereference
 *  operator implicitly converts the value returned by the underlying
 *  iterator's dereference operator to an rvalue reference.  Some
 *  generic algorithms can be called with move iterators to replace
 *  copying with moving.
 */
template<typename _Iterator>
  class move_iterator
  {
  protected:
    _Iterator _M_current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::iterator_category iterator_category;
    typedef typename __traits_type::value_type  	value_type;
    typedef typename __traits_type::difference_type	difference_type;
    // NB: DR 680.
    typedef _Iterator					pointer;
    typedef value_type&&				reference;

    move_iterator()
    : _M_current() { }

    explicit
    move_iterator(iterator_type __i)
    : _M_current(__i) { }

    template<typename _Iter>
move_iterator(const move_iterator<_Iter>& __i)
: _M_current(__i.base()) { }

    iterator_type
    base() const
    { return _M_current; }

    reference
    operator*() const
    { return std::move(*_M_current); }

    pointer
    operator->() const
    { return _M_current; }

    move_iterator&
    operator++()
    {
++_M_current;
return *this;
    }

    move_iterator
    operator++(int)
    {
move_iterator __tmp = *this;
++_M_current;
return __tmp;
    }

    move_iterator&
    operator--()
    {
--_M_current;
return *this;
    }

    move_iterator
    operator--(int)
    {
move_iterator __tmp = *this;
--_M_current;
return __tmp;
    }

    move_iterator
    operator+(difference_type __n) const
    { return move_iterator(_M_current + __n); }

    move_iterator&
    operator+=(difference_type __n)
    {
_M_current += __n;
return *this;
    }

    move_iterator
    operator-(difference_type __n) const
    { return move_iterator(_M_current - __n); }
  
    move_iterator&
    operator-=(difference_type __n)
    { 
_M_current -= __n;
return *this;
    }

    reference
    operator[](difference_type __n) const
    { return std::move(_M_current[__n]); }
  };

// Note: See __normal_iterator operators note from Gaby to understand
// why there are always 2 versions for most of the move_iterator
// operators.
template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator==(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return __x.base() == __y.base(); }

template<typename _Iterator>
  inline bool
  operator==(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return __x.base() == __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator!=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__x == __y); }

template<typename _Iterator>
  inline bool
  operator!=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__x == __y); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  { return __x.base() < __y.base(); }

template<typename _Iterator>
  inline bool
  operator<(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  { return __x.base() < __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__y < __x); }

template<typename _Iterator>
  inline bool
  operator<=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__y < __x); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  { return __y < __x; }

template<typename _Iterator>
  inline bool
  operator>(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  { return __y < __x; }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__x < __y); }

template<typename _Iterator>
  inline bool
  operator>=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__x < __y); }

// DR 685.
template<typename _IteratorL, typename _IteratorR>
  inline auto
  operator-(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  -> decltype(__x.base() - __y.base())
  { return __x.base() - __y.base(); }

template<typename _Iterator>
  inline auto
  operator-(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  -> decltype(__x.base() - __y.base())
  { return __x.base() - __y.base(); }

template<typename _Iterator>
  inline move_iterator<_Iterator>
  operator+(typename move_iterator<_Iterator>::difference_type __n,
     const move_iterator<_Iterator>& __x)
  { return __x + __n; }

template<typename _Iterator>
  inline move_iterator<_Iterator>
  make_move_iterator(_Iterator __i)
  { return move_iterator<_Iterator>(__i); }

template<typename _Iterator, typename _ReturnType
  = typename conditional<__move_if_noexcept_cond
    <typename iterator_traits<_Iterator>::value_type>::value,
              _Iterator, move_iterator<_Iterator>>::type>
  inline _ReturnType
  __make_move_if_noexcept_iterator(_Iterator __i)
  { return _ReturnType(__i); }

// @} group iterators

1137_GLIBCXX_END_NAMESPACE_VERSION
1138} // namespace

1140#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter)std::make_move_iterator(_Iter) std::make_move_iterator(_Iter)
1141#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter)std::__make_move_if_noexcept_iterator(_Iter) \
std::__make_move_if_noexcept_iterator(_Iter)
1143#else
1144#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter)std::make_move_iterator(_Iter) (_Iter)
1145#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter)std::__make_move_if_noexcept_iterator(_Iter) (_Iter)
1146#endif // C++11

1148#endif