//==========================================
//
//  Prereq  -- filter module for selecting events by Trigger
//
//  Authors: Kevin McFarland, Kirsten Tollefson
//
//==========================================

#ifdef DEFECT_OLD_IOSTREAM_HEADERS
#include <iostream.h>
#include <iomanip.h>
#else
#include <iostream>
#include <iomanip>
#endif

#ifndef DEFECT_NO_STDLIB_NAMESPACES
using std::dec;
using std::setw;
using std::hex;
using std::cout;
using std::endl;
using std::string;
#endif

#include<vector.h>
using std::vector;

#include "Level3Mods/newPrereq.hh"

#include "StorableBanks/EVCL_StorableBank.hh"
#include "TriggerObjects/TFRD_StorableBank.hh"
#include "TriggerObjects/TL2D_StorableBank.hh"
#include "TriggerObjects/TL3D_StorableBank.hh"
#include "Level3Objects/Level3ModuleResults.hh"
#include "Edm/EventRecord.hh"
#include "Edm/ConstHandle.hh"
#include "AbsEnv/AbsEnv.hh"

#include "Level3Mods/RawTriggerQuery.hh"

//-------------------
// ConsumerServerLogger headers --  used here for trigger bits
//-------------------
extern "C" {
#include "ConsumerInterface/l3_cs_pointer_space.h"
}

const long Prereq::_defaultRandomSeed = 1485669224;

Prereq::Prereq( const char* const theName,
                                      const char* const theDescription )
  : AppFilterModule( theName, theDescription ),
    _reportedMissingL1Bits(false),
    _reportedMissingL2Bits(false),
    _GetL1TriggerBitsFromTFRD("GetL1TriggerBitsFromTFRD",this,true),
    _GetL1TriggerBitsFromTL2D("GetL1TriggerBitsFromTL2D",this,false),
    _GetL3TriggerBitsFromTL3D("GetL3TriggerBitsFromTL3D",this,true),
    _UseUnprescaledBits("UseUnprescaledBits",this,false),
    _L1TriggerBits("L1TriggerBits",this, 0, L1_BITMASK_WORDS*BITMASK_BITS, 0),
    _L2TriggerBits("L2TriggerBits",this, 0, L2_BITMASK_WORDS*BITMASK_BITS, 0),
    _L3TriggerBits("L3TriggerBits",this, 0, L3_BITMASK_WORDS*BITMASK_BITS, 0),
    _databaseForTrigger("databaseForTrigger",this,"database_oracle_offline"),
    _printTriggerMap("printTriggerMap",this,false),
    _printTriggerSummary("printTriggerSummary",this,false),
    _L1TriggerNames("L1TriggerNames",this, 0),
    _L2TriggerNames("L2TriggerNames",this, 0),
    _L3TriggerNames("L3TriggerNames",this, 0),
    _L1TriggerIds("L1TriggerIds",this, 0),
    _L2TriggerIds("L2TriggerIds",this, 0),
    _L3TriggerIds("L3TriggerIds",this, 0),
    _L1Accept("L1Accept",this,true),
    _L2Accept("L2Accept",this,true),
    _L3Accept("L3Accept",this,true),
    _debug("debug",this,false),
    _useEvclBits("useEvclBits",this,false),
    _integralPrescale("integralPrescale",this,1),
    _randomPrescale("randomPrescale",this,1.),
    _randomSeed("RandomSeed",this,_defaultRandomSeed),
    _randomEngine(0),
    _flatGenerator(0),
    _notPrintedYet(true)
{
  // Define parameters for talk-to
  // -----------------------------
  _GetL1TriggerBitsFromTFRD.addDescription(
"\tGet Level-1 Trigger Bits from TFRD Bank (default true)");
  _GetL1TriggerBitsFromTL2D.addDescription(
"\tGet Level-1 Trigger Bits from TL2D Bank (default false)");
  _GetL3TriggerBitsFromTL3D.addDescription(
"\tGet Level-3 Trigger Bits from TL3D Bank instead of Level3ModuleResults object (default true -- for now)");
  _UseUnprescaledBits.addDescription(
"\tUse L1 trigger bits from FRED before prescale \n\t\t(default for seeded triggering is false; \n\t\t setting true is meaningless without setting GetL1TriggerBitsFromTFRD also)");
  _L1TriggerBits.addDescription(
" \tList of Level-1 Trigger Bits to Accept (default none)");
  _L2TriggerBits.addDescription(
" \tList of Level-2 Trigger Bits to Accept (default none)");
  _L3TriggerBits.addDescription(
" \tList of Level-3 Trigger Bits to Accept (default none)");
  _L1TriggerIds.addDescription(
" \tList of Level-1 Trigger Ids to Accept (default none)");
  _L2TriggerIds.addDescription(
" \tList of Level-2 Trigger Ids to Accept (default none)");
  _L3TriggerIds.addDescription(
" \tList of Level-3 Trigger Ids to Accept (default none)");
  _databaseForTrigger.addDescription(
" \tName of the reader database account to use for trigger lookup (default database_oracle_offline)");
  _printTriggerMap.addDescription(
" \tPrint out trigger map at the beginning of each run (default true)");
  _printTriggerSummary.addDescription(
" \tPrint out trigger accounting information at the end of each run (default false)");
  _L1TriggerNames.addDescription(
" \tList of Level-1 Trigger Bits to Accept (default none)");
  _L2TriggerNames.addDescription(
" \tList of Level-2 Trigger Bits to Accept (default none)");
  _L3TriggerNames.addDescription(
" \tList of Level-3 Trigger Bits to Accept (default none)");
  _L1Accept.addDescription(
" \tAccept L1 without Prerequisite (default false)");
  _L2Accept.addDescription(
" \tAccept L2 without Prerequisite (default false)");
  _L3Accept.addDescription(
" \tAccept L3 without Prerequisite (default false)");
  _debug.addDescription(
" \tDebug flag (default false)");
  _useEvclBits.addDescription(
" \tUse trigger summary bits from EVCL instead of TL2D, implemented for backwords compatibility (default false)");
  _integralPrescale.addDescription(
" \tPrescale trigger results by allowing a pass EXACTLY only once every N calls with a randomly generated initial seed (default 1, no prescale)");
  _randomPrescale.addDescription(
" \tPrescale trigger results by event-by-event random selection (default 1., no prescale)");
  _randomSeed.addDescription(
" \tSeed for the random number generator");
  commands()->append(&_GetL1TriggerBitsFromTFRD);
  commands()->append(&_GetL1TriggerBitsFromTL2D);
  commands()->append(&_GetL3TriggerBitsFromTL3D);
  commands()->append(&_UseUnprescaledBits);
  commands()->append(&_L1TriggerBits);
  commands()->append(&_L2TriggerBits);
  commands()->append(&_L3TriggerBits);
  commands()->append(&_L1TriggerIds);
  commands()->append(&_L2TriggerIds);
  commands()->append(&_L3TriggerIds);
  commands()->append(&_databaseForTrigger);
  commands()->append(&_printTriggerMap);
  commands()->append(&_printTriggerSummary);
  commands()->append(&_L1TriggerNames);
  commands()->append(&_L2TriggerNames);
  commands()->append(&_L3TriggerNames);
  commands()->append(&_L1Accept);
  commands()->append(&_L2Accept);
  commands()->append(&_L3Accept);
  commands()->append(&_debug);
  commands()->append(&_useEvclBits);
  commands()->append(&_integralPrescale);
  commands()->append(&_randomPrescale);
  commands()->append(&_randomSeed);

}

Prereq::~Prereq() 
{
  if (_randomEngine) delete _randomEngine;
  if (_flatGenerator) delete _flatGenerator;
}

AppResult Prereq::beginJob( AbsEvent* aJob )
{
  // Initialize the trigger source
  _triggerSource.L1 = RawTriggerQuery::noSource;
  _triggerSource.L2 = RawTriggerQuery::noSource;
  _triggerSource.L3 = RawTriggerQuery::noSource;
  _triggerSource.debug = _debug.value();
  if ( _GetL1TriggerBitsFromTFRD.value()){ 
    if ( _UseUnprescaledBits.value())
      _triggerSource.L1=RawTriggerQuery::fromTFRDunprescaled;
    else
      _triggerSource.L1=RawTriggerQuery::fromTFRD;
  }
  else if ( _GetL1TriggerBitsFromTL2D.value())
    _triggerSource.L1=RawTriggerQuery::fromTL2D;
  
  _triggerSource.L2=RawTriggerQuery::fromTL2D;


  // Initialize the random number engine with a seed
  _randomEngine = new Ranlux64Engine(_randomSeed.value());
  // Initialize the flat random number generator (0,1) with our engine --
  // passing as a reference tells it to leave memory cleanup of the
  // engine to us
  _flatGenerator = new RandFlat(*_randomEngine,0.,1.);

  // Initialize a random count
  _cyclicCount = (_integralPrescale.value())*float(_flatGenerator->fire());

  errlog.setSubroutine("Prereq::beginJob");
  if ( _integralPrescale.value() > 1 ||
       _randomPrescale.value() < 1. )
    {
      errlog(ELwarning,
             "Prereq PRESCALE ACTIVE; will cut events")
               << endmsg;
    }

  // rationalize autoaccepts given other inputs
  
  if (_L1TriggerNames.size()+_L1TriggerBits.size()+_L1TriggerIds.size() > 0)
    _L1Accept.set(false);
  if (_L2TriggerNames.size()+_L2TriggerBits.size()+_L2TriggerIds.size() > 0)
    _L2Accept.set(false);
  if (_L3TriggerNames.size()+_L3TriggerBits.size()+_L3TriggerIds.size() > 0)
    _L3Accept.set(false);

  return AppResult::OK;
}

AppResult Prereq::beginRun( AbsEvent* aRun )
{
  if (_printTriggerSummary.value()) {
    // Initialize counters
    _L1Counter.assign(HepSymMatrix(L1_BITMASK_WORDS*BITMASK_BITS,0));
    _L2Counter.assign(HepSymMatrix(L2_BITMASK_WORDS*BITMASK_BITS,0));
    _L3Counter.assign(HepSymMatrix(L3_BITMASK_WORDS*BITMASK_BITS,0));
     // Moved this line inside if statement so Prereq would not access
     // offline database unless asked to - KAT 12/27/01
    _databaseTriggerMap = new TriggerMap(_databaseForTrigger.value());
    _notPrintedYet = true;
  }
  
  // Construct trigger bit lists from the OR of the bits, ids, names
  _L1BitList.clear();
  _L2BitList.clear();
  _L3BitList.clear();
  // First copy from bit list
  for (AbsParmList<int>::ConstIterator 
         bit=_L1TriggerBits.begin(); 
       bit!=_L1TriggerBits.end(); bit++)
    _L1BitList.push_back(*bit);
  for (AbsParmList<int>::ConstIterator 
         bit=_L2TriggerBits.begin(); 
       bit!=_L2TriggerBits.end(); bit++)
    _L2BitList.push_back(*bit);
  for (AbsParmList<int>::ConstIterator 
         bit=_L3TriggerBits.begin(); 
       bit!=_L3TriggerBits.end(); bit++)
    _L3BitList.push_back(*bit);

  // Now add from trigger names or ids, but only if any are requested...
  //  (this database access code takes some time)

  // Get mapping of Level1 and Level2 triggers from online database
  // given a particular run number

   
  if ( _L1TriggerNames.size()!=0 || 
       _L2TriggerNames.size()!=0 || 
       _L3TriggerNames.size()!=0 ||
       _L1TriggerIds.size()!=0 || 
       _L2TriggerIds.size()!=0 || 
       _L3TriggerIds.size()!=0 )
    { 

      // The printSummary method also needs the TriggerMap information so
      // if this is true have already done this above so skip it here KAT 12/27/01
      if (!_printTriggerSummary.value()) {
          _databaseTriggerMap = new TriggerMap(_databaseForTrigger.value());
      }

      // print out for user benefit
      if ( _printTriggerMap.value() )
        {
          cout << "Prereq:: beginRun, Trigger list for run " 
               << gblEnv->runNumber() << endl;
          _databaseTriggerMap->print(); 
        }
      
      for (AbsParmList<string>::ConstIterator 
             name=_L1TriggerNames.begin(); 
           name!=_L1TriggerNames.end(); name++)
        {
          vector<int> L1NamedBits = _databaseTriggerMap->getBits(*name,1);
          for (vector<int>::const_iterator
                 bit=L1NamedBits.begin();
               bit!=L1NamedBits.end(); bit++)
            _L1BitList.push_back(*bit);
        }
      for (AbsParmList<string>::ConstIterator 
             name=_L2TriggerNames.begin(); 
           name!=_L2TriggerNames.end(); name++)
        {
          vector<int> L2NamedBits = _databaseTriggerMap->getBits(*name,2);
          for (vector<int>::const_iterator
                 bit=L2NamedBits.begin();
               bit!=L2NamedBits.end(); bit++)
            _L2BitList.push_back(*bit);
        }
      for (AbsParmList<string>::ConstIterator 
             name=_L3TriggerNames.begin(); 
           name!=_L3TriggerNames.end(); name++)
        {
          vector<int> L3NamedBits = _databaseTriggerMap->getBits(*name,3);
          for (vector<int>::const_iterator
                 bit=L3NamedBits.begin();
               bit!=L3NamedBits.end(); bit++)
            _L3BitList.push_back(*bit);
        }

     for (AbsParmList<int>::ConstIterator 
             id=_L1TriggerIds.begin(); 
             id!=_L1TriggerIds.end(); id++)
        {
          _L1BitList.push_back(_databaseTriggerMap->getBit(*id,1));
        }
     for (AbsParmList<int>::ConstIterator 
             id=_L2TriggerIds.begin(); 
             id!=_L2TriggerIds.end(); id++)
        {
          _L2BitList.push_back(_databaseTriggerMap->getBit(*id,2));
        }
     for (AbsParmList<int>::ConstIterator 
             id=_L3TriggerIds.begin(); 
             id!=_L3TriggerIds.end(); id++)
        {
          _L3BitList.push_back(_databaseTriggerMap->getBit(*id,3));
        }
    }

   return AppResult::OK;
}

AppResult Prereq::event( AbsEvent* anEvent ) {

  bool Pass, PassLevel1, PassLevel2, PassLevel3;

  //
  // First handle any active prescales
  //

  bool PassPrescale = true;

  if (_integralPrescale.value() > 1)
    {
      if (++_cyclicCount < _integralPrescale.value())
        PassPrescale = false;
      else
        _cyclicCount = 0; // passed, so reset count
    }

  if (_randomPrescale.value() < 1.)
    {
      if (float(_flatGenerator->fire()) > _randomPrescale.value())
        PassPrescale = false;
    }

  if (!PassPrescale)  // if failed prescale, just exit
    {
      this->setPassed(PassPrescale);
      return AppResult::OK;
    }


  //
  // Now Examine Trigger Masks
  //
  int4 L1Trig[L1_BITMASK_WORDS*BITMASK_BITS/8/sizeof(int4)];
  for (int iw=0; iw<L1_BITMASK_WORDS*BITMASK_BITS/8/sizeof(int4) ; iw++)
    L1Trig[iw]=0;
  int4 L2Trig[L2_BITMASK_WORDS*BITMASK_BITS/8/sizeof(int4)];
  for (int iw=0; iw<L2_BITMASK_WORDS*BITMASK_BITS/8/sizeof(int4) ; iw++)
    L2Trig[iw]=0;

  bool foundL1Bits = RawTriggerQuery::fillL1TriggerMask( L1Trig, 
                                                         _triggerSource );
  bool foundL2Bits = RawTriggerQuery::fillL2TriggerMask( L2Trig, 
                                                         _triggerSource );

  if ( !foundL1Bits && !_L1Accept.value() )
    {
      errlog.setSubroutine("Prereq::event");
      if ( !_reportedMissingL1Bits ) 
        {
          errlog(ELsevere,
                 "L1 Trigger Bits not in event: no TFRD/TL2D") 
                   << endmsg;
          _reportedMissingL1Bits = true;
        }
      else
        errlog(ELwarning,
               "L1 Trigger Bits still not in event: no TFRD/TL2D") 
                 << endmsg;
    }
  
      
  if ( !foundL2Bits && !_L2Accept.value() )
    {
      errlog.setSubroutine("Prereq::event");
      if ( !_reportedMissingL2Bits ) 
        {
          errlog(ELsevere,
                 "L2 Trigger Bits not in event: no TL2D") 
                   << endmsg;
          _reportedMissingL2Bits = true;
        }
      else
        errlog(ELwarning,
               "L2 Trigger Bits still not in event: no TL2D") 
                 << endmsg;
    }
  
  if (_printTriggerSummary.value()) {
    //Increment counters
    for (int i = 0; i < L1_BITMASK_WORDS*BITMASK_BITS; i++) {
      for (int j = i; j < L1_BITMASK_WORDS*BITMASK_BITS; j++) {
	if (L1Trig[i/(sizeof(int4)*8)] & 
	    static_cast<int4>(1<<(i%(sizeof(int4)*8))) &&
	    L1Trig[j/(sizeof(int4)*8)] 
	    & static_cast<int4>(1<<(j%(sizeof(int4)*8))))
	  _L1Counter[i][j]++;
      }
    }
  }

  PassLevel1 = false;
  if ( _L1Accept.value() )
    PassLevel1 = true;
  else
    {
      for (vector<int>::const_iterator 
             bit=_L1BitList.begin(); 
           bit!=_L1BitList.end(); bit++)
        {
          //cout << "Testing L1 bit " << *bit << endl;
          //cout << "   comparing " << hex << L1Trig[*bit/(sizeof(int4)*8)]
          //     << " to " << static_cast<int4>(1<<((*bit)%(sizeof(int4)*8)))
          //     << dec << endl;
          if (*bit >= 0) // valid bit?
            {
              if ( L1Trig[*bit/(sizeof(int4)*8)] 
                   & static_cast<int4>(1<<((*bit)%(sizeof(int4)*8))))
                PassLevel1 = true;
            }
        }
    }
  
  if (_printTriggerSummary.value()) {
    //Increment counters
    for (int i = 0; i < L2_BITMASK_WORDS*BITMASK_BITS; i++) {
      for (int j = i; j < L2_BITMASK_WORDS*BITMASK_BITS; j++) {
	if (L2Trig[i/(sizeof(int4)*8)] & 
	    static_cast<int4>(1<<(i%(sizeof(int4)*8))) &&
	    L2Trig[j/(sizeof(int4)*8)] 
	    & static_cast<int4>(1<<(j%(sizeof(int4)*8))))
	_L2Counter[i][j]++;
      }
    }
  }

  PassLevel2 = false;
  if ( _L2Accept.value() )
    PassLevel2 = true;
  else
    {
      for (vector<int>::const_iterator 
             bit=_L2BitList.begin(); 
           bit!=_L2BitList.end(); bit++)
        if (*bit >= 0) // valid bit?
          {
            if ( L2Trig[*bit/(sizeof(int4)*8)] 
                 & static_cast<int4>(1<<((*bit)%(sizeof(int4)*8))))
              PassLevel2 = true;
          }
    }
  
  // Level 3
    
  if ( _debug.value() )
    {
      // TL3D
      EventRecord::ConstIterator TL3D_iter( anEvent, "TL3D_StorableBank" );
      if ( TL3D_iter.is_valid() )
        {
          ConstHandle<TL3D_StorableBank> tl3d( TL3D_iter );
          cout << "  TL3D set bits: " ;
          for ( int ibit = 0; 
                (ibit < L3_BITMASK_WORDS*BITMASK_BITS)
                  && (ibit < tl3d->nPaths()) ; ibit++ )
            {
              if (tl3d->didPathPass(ibit)) cout << ibit << ", "; 
            }
          cout << endl;
          //tl3d->print();
        }
      //
      // Level3ModuleResults
      EventRecord::ConstIterator L3Results_iter( anEvent, 
                                                 "Level3ModuleResults" );
      if ( L3Results_iter.is_valid() )
        {
          ConstHandle<Level3ModuleResults> L3Results( L3Results_iter );
          int nPaths = L3Results->numberOfPath();
          cout << "Found a Level3ModuleResults object reporting " 
               << nPaths << " paths" << endl;
          for ( int ibit = 0; ibit < nPaths ; ibit++ )
            {
              if (L3Results->thisEventPassedPath(ibit)) 
                {
                  cout << ibit << ", ";
                }
              //else
              //  if (L3Results->thisEventExecutedPath(ibit))
              //    {
              //      cout << "FAILED" << ibit << ", ";
              //    }
            }
          cout << endl;
          //L3Results->print();
        }
      cout << "  L3 Trig Accept Bits: ";
      for (vector<int>::const_iterator 
             bit=_L3BitList.begin(); 
           bit!=_L3BitList.end(); bit++)
        cout << *bit << ",";
      cout << endl;
    } // debug

  if (_printTriggerSummary.value()) {
    //Increment counters
    if ( _GetL3TriggerBitsFromTL3D.value() )
      {
        EventRecord::ConstIterator TL3D_iter( anEvent, "TL3D_StorableBank" );
        if ( TL3D_iter.is_valid() )
          {
            ConstHandle<TL3D_StorableBank> tl3d( TL3D_iter );
            for (int i = 0; i < L3_BITMASK_WORDS*BITMASK_BITS; i++) {
              for (int j = i; j < L3_BITMASK_WORDS*BITMASK_BITS; j++) {
                if ( tl3d->didPathPass(i) > 0 &&
                     tl3d->didPathPass(j))
                  _L3Counter[i][j]++;
              }
            }
          }
      }
    else // use TriggerObjects
      {
        EventRecord::ConstIterator L3Results_iter( anEvent, 
                                                   "Level3ModuleResults" );
        if ( L3Results_iter.is_valid() )
          {
            ConstHandle<Level3ModuleResults> L3Results( L3Results_iter );
            int nPaths = L3Results->numberOfPath();
            for (int i = 0; i < nPaths; i++) {
              for (int j = i; j < nPaths; j++) {
                if ( L3Results->thisEventPassedPath(i) > 0 &&
                     L3Results->thisEventPassedPath(j) > 0 )
                  _L3Counter[i][j]++;
              }
            }
          }
      } // TL3D or Level3Reults
  }
  
  if ( _L3Accept.value() )
    {
      PassLevel3 = true;
    }
  else
    {
      PassLevel3 = false;
      if ( _GetL3TriggerBitsFromTL3D.value() )
        {
          EventRecord::ConstIterator TL3D_iter( anEvent, "TL3D_StorableBank" );
          if ( TL3D_iter.is_valid() )
            {
              ConstHandle<TL3D_StorableBank> tl3d( TL3D_iter );
              for (vector<int>::const_iterator 
                     bit=_L3BitList.begin(); 
                   bit!=_L3BitList.end(); bit++)
                {
                  if ( *bit >= 0 ) // valid bit, -1 is invalid 
                    {
                      if ( (tl3d->didPathPass(*bit)) > 0 )
                        PassLevel3 = true;
                    }
                }
              
            } // found TL3D
          else
            {
              if ( !_L3Accept.value() )
                {
                  errlog.setSubroutine("Prereq::event");
                  if ( !_reportedMissingL3Bits ) 
                    {
                      errlog(ELsevere,
                             "L3 Trigger Bits not in event: no TL3D") 
                               << endmsg;
                      _reportedMissingL3Bits = true;
                    }
                  else
                    errlog(ELwarning,
                           "L3 Trigger Bits still not in event: no TL3D") 
                             << endmsg;
                }
            } // no TL3D found
        }
      else // use TriggerObjects
        {
          EventRecord::ConstIterator L3Results_iter( anEvent, 
                                                     "Level3ModuleResults" );
          if ( L3Results_iter.is_valid() )
            {
              ConstHandle<Level3ModuleResults> L3Results( L3Results_iter );
              int nPaths = L3Results->numberOfPath();
              for (vector<int>::const_iterator 
                     bit=_L3BitList.begin(); 
                   bit!=_L3BitList.end(); bit++)
                {
                  if ( *bit >= 0 ) // valid bit, -1 is invalid 
                    {
                      if ( (L3Results->thisEventPassedPath(*bit)) > 0 )
                        PassLevel3 = true;
                    }
                }
            }
          else
            {
              if ( !_L3Accept.value() )
                {
                  errlog.setSubroutine("Prereq::event");
                  if ( !_reportedMissingL3Bits ) 
                    {
                      errlog(ELsevere,
                             "L3 Trigger Bits not in event: no Level3ModuleResults") 
                               << endmsg;
                      _reportedMissingL3Bits = true;
                    }
                  else
                    errlog(ELwarning,
                           "L3 Trigger Bits still not in event: no Level3ModuleResults") 
                             << endmsg;
                }
            } // no Level3Results found
        } // TL3D or Level3Reults
    } // not L3 Auto-accept
        
  Pass = PassLevel1 & PassLevel2 & PassLevel3;
  if ( _debug.value() )
    {
      if (PassLevel1) cout << "  Passed Level1...";
      if (PassLevel2) cout << "  Passed Level2...";
      if (PassLevel3) cout << "  Passed Level3...";
      if (PassLevel1 || PassLevel2 || PassLevel3) cout << endl;
    }
  this->setPassed(Pass);
  return AppResult::OK;
}
    
    
AppResult Prereq::endRun( AbsEvent* aRun )
{
  if (_printTriggerSummary.value()) {
    _printSummary();
    _notPrintedYet = false;
  }
  return AppResult::OK;
}
 
AppResult Prereq::endJob( AbsEvent* aJob )
{
  if (_printTriggerSummary.value() && _notPrintedYet) _printSummary();
  return AppResult::OK;
}

void Prereq::_printSummary() const {
  int grandCounter,lastHighestBit,highestBit,totalBits;

  cout << endl;
  cout << "Prereq: L1 trigger bits, names and events passing:\n\n";
  for (int i = 0; i < L1_BITMASK_WORDS*BITMASK_BITS; i++) {
    if ( _databaseTriggerMap->getNameFromBit(i,1) != "" )
      cout << i << " "
	   << _databaseTriggerMap->getNameFromBit(i,1) << " " 
	   << _L1Counter[i][i]
	   << endl;
  }
  cout << endl;

  //Figure out the lowest and highest bits for this print block:
  grandCounter = 0;
  lastHighestBit = 0;
  highestBit = 0;
  totalBits = 0;
  cout << "L1 correlation matrix:\n\n";
  while (grandCounter < L1_BITMASK_WORDS*BITMASK_BITS) {
    if (_databaseTriggerMap->getNameFromBit(grandCounter,1) != "" ) {
      highestBit = grandCounter;
      totalBits++;
    }
    if (totalBits == 7|| grandCounter == L1_BITMASK_WORDS*BITMASK_BITS - 1) {

      //Create header
      cout << std::setw(10) << "Bit #";
      for (int i = lastHighestBit; i <= highestBit; i++) {
	if (_databaseTriggerMap->getNameFromBit(i,1) != "" ) 
	  cout << std::setw(10) << i;
      }
      cout << endl << endl;

      for (int i = 0; i < L1_BITMASK_WORDS*BITMASK_BITS; i++) {
	if (i > highestBit) break;
	if (_databaseTriggerMap->getNameFromBit(i,1) != "" ) {
	  cout << std::setw(10) << i;
	  for (int j = lastHighestBit; j <= highestBit; j++) {
	    if (_databaseTriggerMap->getNameFromBit(j,1) != "") {
	      if (j >= i) cout << std::setw(10) << _L1Counter[i][j];
	      else cout << std::setw(10) << "";
	    }
	  }
	  cout << endl;
	}
      }      
      cout << endl;
      lastHighestBit = grandCounter+1;
      totalBits = 0;
    }
    grandCounter++;
  }
  cout << endl;
  
  cout << endl;
  cout << "Prereq: L2 trigger bits, names and events passing:\n\n";
  for (int i = 0; i < L2_BITMASK_WORDS*BITMASK_BITS; i++) {
    if (_databaseTriggerMap->getNameFromBit(i,2) != "")
      cout << i << " "
	   << _databaseTriggerMap->getNameFromBit(i,2) << " " 
	   << _L2Counter[i][i]
	   << endl;
  }
  cout << endl;

  //Figure out the lowest and highest bits for this print block:
  grandCounter = 0;
  lastHighestBit = 0;
  highestBit = 0;
  totalBits = 0;
  cout << "L2 correlation matrix:\n\n";
  while (grandCounter < L2_BITMASK_WORDS*BITMASK_BITS) {
    if (_databaseTriggerMap->getNameFromBit(grandCounter,2) != "") {
      highestBit = grandCounter;
      totalBits++;
    }
    if (totalBits == 7 || grandCounter == L2_BITMASK_WORDS*BITMASK_BITS - 1) {

      //Create header
      cout << std::setw(10) << "Bit #";
      for (int i = lastHighestBit; i <= highestBit; i++) {
	if (_databaseTriggerMap->getNameFromBit(i,2) != "") 
	  cout << std::setw(10) << i;
      }
      cout << endl << endl;

      for (int i = 0; i < L2_BITMASK_WORDS*BITMASK_BITS; i++) {
	if (i > highestBit) break;
	if (_databaseTriggerMap->getNameFromBit(i,2) != "") {
	  cout << std::setw(10) << i;
	  for (int j = lastHighestBit; j <= highestBit; j++) {
	    if (_databaseTriggerMap->getNameFromBit(j,2) != "") {
	      if (j >= i) cout << std::setw(10) << _L2Counter[i][j];
	      else cout << std::setw(10) << "";
	    }
	  }
	  cout << endl;
	}
      }      
      cout << endl;
      lastHighestBit = grandCounter+1;
      totalBits = 0;
    }
    grandCounter++;
  }
  cout << endl;
  
  cout << endl;
  cout << "Prereq: L3 trigger bits, names and events passing:\n\n";
  for (int i = 0; i < L3_BITMASK_WORDS*BITMASK_BITS; i++) {
    if (_databaseTriggerMap->getNameFromBit(i,3) != "")
      cout << i << " "
	   << _databaseTriggerMap->getNameFromBit(i,3) << " " 
	   << _L3Counter[i][i]
	   << endl;
  }
  cout << endl;

  //Figure out the lowest and highest bits for this print block:
  grandCounter = 0;
  lastHighestBit = 0;
  highestBit = 0;
  totalBits = 0;
  cout << "L3 correlation matrix:\n\n";
  while (grandCounter < L3_BITMASK_WORDS*BITMASK_BITS) {
    if (_databaseTriggerMap->getNameFromBit(grandCounter,3) != "") {
      highestBit = grandCounter;
      totalBits++;
    }
    if (totalBits == 7|| grandCounter == L3_BITMASK_WORDS*BITMASK_BITS - 1) {

      //Create header
      cout << std::setw(10) << "Bit #";
      for (int i = lastHighestBit; i <= highestBit; i++) {
	if (_databaseTriggerMap->getNameFromBit(i,3) != "") 
	  cout << std::setw(10) << i;
      }
      cout << endl << endl;

      for (int i = 0; i < L3_BITMASK_WORDS*BITMASK_BITS; i++) {
	if (i > highestBit) break;
	if (_databaseTriggerMap->getNameFromBit(i,3) != "") {
	  cout << std::setw(10) << i;
	  for (int j = lastHighestBit; j <= highestBit; j++) {
	    if (_databaseTriggerMap->getNameFromBit(j,3) != "") {
	      if (j >= i) cout << std::setw(10) << _L3Counter[i][j];
	      else cout << std::setw(10) << "";
	    }
	  }
	  cout << endl;
	}
      }      
      cout << endl;
      lastHighestBit = grandCounter+1;
      totalBits = 0;
    }
    grandCounter++;
  }
  cout << endl;
  
  return;
}
 
AppResult Prereq::abortJob( AbsEvent* aJob )
{
   return AppResult::OK;
}

AppModule*
Prereq::clone(const char* cloneName)
{
  return new Prereq(cloneName,"this module is a clone of Prereq");
}