// ------------------------------------------------------------- 
 // File:Herwig.cxx
 // Generators/Herwig.cxx Description: Allows the user
 // to generate Herwig events and store the result in the
 // Transient Store.
 //
 // AuthorList:
 // Ian Hinchliffe:  Initial Code October : 2000
 // Modeled after the CDF code by Marge Shapriro and Jeremy Lys
 // Modified for Version 6.4 Jan 2002-- Ian Hinchliffe
 // AcerMC 1.x interface added by Borut Paul Kersevan (February 2003)
 // TAUOLA/PHOTOS interface added by Borut Paul Kersevan (October 2003)
 // Jimmy merged in by Jon Butterworth (Feb 2007)
 // Removed lots, but not all, of the irrelevant CDF stuff (JMB, Nov 2008) 
 // Header for this module:-
 
 #include "Herwig_i/Herwig.h"
 #include "GeneratorModules/GeneratorName.h"
 
 // Framework Related Headers:-
 #include "GaudiKernel/MsgStream.h"
 
 // Other classes used by this class:-
 
 #include "Herwig_i/herwig6510.h"
 #include "Charybdis_i/CharybdisInterface.h"
 #include "HepMC/IO_HERWIG.h"
 #include "HepMC/IO_HEPEVT.h"
 #include "HepMC/IO_Ascii.h"
 #include "HepMC/HEPEVT_Wrapper.h"
 #include "GeneratorUtils/StringParse.h"
 #include <stdlib.h>
 #include "CLHEP/Random/RandFlat.h"
 #include "AthenaKernel/IAtRndmGenSvc.h"
 #include "StoreGate/StoreGateSvc.h"
 
 //-------------------------------
 
 #define evtcon evtcon_
 
 extern struct
 {
   int istg;
 } evtcon;
 
 // Pointer On AtRndmGenSvc
 IAtRndmGenSvc*  p_AtRndmGenSvc;
 namespace {
   static std::string   herwig_stream   =       "HERWIG_INIT";
 }
 extern "C" double atl_hwrgen_( int* idummy )
 {
   CLHEP::HepRandomEngine* engine = p_AtRndmGenSvc->GetEngine(herwig_stream);
   return CLHEP::RandFlat::shoot(engine);
 }
 
 // calls to fortran routines
 extern "C" double atl_phoran_( int* /*idummy*/ )
 {
   CLHEP::HepRandomEngine* engine = p_AtRndmGenSvc->GetEngine("PHOTOS");
   return CLHEP::RandFlat::shoot(engine);
 }
 
 extern "C" float atl_ranmar_()
 {
   CLHEP::HepRandomEngine* engine = p_AtRndmGenSvc->GetEngine("TAUOLA");
   return (float) CLHEP::RandFlat::shoot(engine);
 }
 
 void InitHerwigCommonBlocks();
 
 // calls to fortran routines
 extern "C" {
   //  void stdhepctb_();
   // In Herwig_i  area:
   void herwiginterface_(int* itopd);
   //  void cdfreadsusy_(char* file,int *syunit);
   void cdfreadsusy_(const char* ,int * , int);
   //  In Herwig 
   //susy
   void hwissp_(int *syunit);
 
   // added for RPV 4-body decays
   // Sebastian Fleischmann/JMB
   void hwirpv_();
   // NB: if the RPV code is not linked, a dummy version is called.
     
   void hwuinc_();
   //  void hwusta(int *tstab);
   //  void hwabeg_();
   void hweini_();
   void hwuine_();
   void hwupro_();
   void hwepro_();
   void hwbgen_();
   void hwdhob_();
   void hwcfor_();
   void hwcdec_();
   void hwdhad_();
   void hwdhvy_();
   void hwmevt_();
   void hwufne_(); 
   void hwefin_();
   void hwanal_(int *ihwcod);
   void hwmsct_(int *abort);
   void hwgpdg_(int *mconv);
   void extproc_(int*);
 
   void upveto_(int*);
 
   void jminit_();
   void jmefin_();
 
   //charybdis fix 
   void charybdfix_();
 
   // PDF information
   void hwpdfinfo_();
   
 }
 //-----------------------------------
 
 using HepMC::IO_HERWIG;
 using HepMC::IO_HEPEVT;
 using HepMC::IO_Ascii;
 
 // File scope declarations:-
 
 // set pointer to zero at start
 Atlas_HEPEVT*  Herwig::atlas_HEPEVT = new Atlas_HEPEVT();
 
 //--------------------------------------------------------------------------
 Herwig::Herwig(const std::string& name, 
                ISvcLocator* pSvcLocator): GenModule(name,pSvcLocator)
 {
   //--------------------------------------------------------------------------  
   declareProperty("HerwigCommand", m_herwigCommandVector);
 }
 //--------------------------------------------------------------------------
 Herwig::~Herwig(){
   //--------------------------------------------------------------------------
 }
 //-------------------------------------------------------------
 AcerMC_acset& Herwig::acermc_acset() {
   return m_acermc_acset;
 }
 
 //---------------------------------------------------------------------------
 StatusCode Herwig::genInitialize() {
   //---------------------------------------------------------------------------
   // Initialise the listing output, parameter and decay data input streams
   //
   MsgStream log(messageService(), name());
   log << MSG:: INFO << " HERWIG INITIALISING.  \n"  << endreq;
   
   static const bool CREATEIFNOTTHERE(true);
   StatusCode RndmStatus = service("AtRndmGenSvc", p_AtRndmGenSvc, CREATEIFNOTTHERE);
   if (!RndmStatus.isSuccess() || 0 == p_AtRndmGenSvc)
     {
       log << MSG::ERROR << " Could not initialize Random Number Service" << endreq;
       return RndmStatus;
     }   
 
   m_noshower_Parm=false;
   m_nohadroniz_Parm=false;
   // default is to shower and hadronize
 
   HepMC::HEPEVT_Wrapper::set_sizeof_int(sizeof(int));
   HepMC::HEPEVT_Wrapper::set_sizeof_real(8);
   HepMC::HEPEVT_Wrapper::set_max_number_entries(10000); 
   // Map Herwig Common blocks to global C structures
   InitHerwigCommonBlocks();
 
   // Default the top decay, beams and beam energies
   gHwproc->pbeam1=7000.;  // beam energies
   gHwproc->pbeam2=7000.;  // beam energies
   m_itopd = 0;
   strncpy(gHwbmch->part1,"P       ",8);
   strncpy(gHwbmch->part2,"P       ",8);
   // ALL other settings should be given after the call to hwigin (in herwiginterface)
 
   // Special loop over the input parameters to load iproc, beam type and beam energy 
   // before the call to herwiginterface_()
   CommandVector::const_iterator ic              =       m_herwigCommandVector.begin();
   do {
     StringParse mystring(*ic);
     string myvar=mystring.piece(1);
     int myint1=mystring.intpiece(2);
     double  myfl1=mystring.numpiece(2);
     string myvar2 = mystring.piece(2);
     myvar2.resize(8,' ');
 
     if(myvar=="iproc") {
       gHwproc->iproc             =       myint1;
     } 
     else if(myvar=="beam1energy") {
       gHwproc->pbeam1             =       myfl1;
     }
     else if(myvar=="beam2energy") {
       gHwproc->pbeam2             =       myfl1;
     }
     else if(myvar=="topdec") {
       m_itopd             =       myint1;
     }
     else if(myvar=="beam1type") {
       strncpy(gHwbmch->part1,myvar2.c_str(),8);      
    }
     else if(myvar=="beam2type") {
       strncpy(gHwbmch->part2,myvar2.c_str(),8);      
     }
     ic++;
   } while (ic != m_herwigCommandVector.end());
 
   
   // Call Fortran Routine to Initialize Herwig Common Block
   herwiginterface_(&m_itopd);
 
   // set timeout and maximum number of errors to sensibe defaults
   gHwevnt->maxer = 10000000;
   gHwevnt->tlout = -10000000.0;
 
 
   m_ExternalProcess = 0;
 
   // No hardcoded defaults here!! 
   //
   // Anything different from generator default should
   // be set in job options.
 
   //now read in all the parameter changes from the user
   for (size_t i = 0; i < m_herwigCommandVector.size(); i++) {
     log << MSG:: INFO  << " Command is: " << m_herwigCommandVector[i] << endreq;
     StringParse mystring(m_herwigCommandVector[i]);
     string myvar=mystring.piece(1);
     string myvar1=mystring.piece(2);
     int myint1=mystring.intpiece(2);
     int myint2=mystring.intpiece(3);
     double  myfl1=mystring.numpiece(2);
     double  myfl2=mystring.numpiece(3);
     if (  myvar== "beam1type" || myvar== "beam2type" || myvar== "beam1energy" ||
           myvar== "beam2energy") { 
       // Beam types and energy already done.
     }
     // process number for external processes set here.
     else if(myvar=="iproc"){
       if (myvar1 == "charybdis") {
         gHwproc->iproc=-200;
         m_ExternalProcess = CHARYBDIS;
       } else if (myvar1 == "acermc") {
         gHwproc->iproc=-600;
         m_ExternalProcess = ACERMC;
       } else if(myvar1 == "alpgen") {
         gHwproc->iproc=-1400;
         m_ExternalProcess = ALPGEN;
         if (myint2 > 0) {
           gHwproc->iproc-=myint2;
         }
       } else if (myvar1 == "madgraph") {
         gHwproc->iproc=-950;
         m_ExternalProcess = MADGRAPH;
       } else if (myvar1 == "madcup") {
         gHwproc->iproc=-800;
         m_ExternalProcess = MADCUP;
       } else if(myvar1 == "lhaext") {
         gHwproc->iproc=-900;
         m_ExternalProcess = LHAEXT;
       } else if (myvar1 == "mcatnlo") {
         gHwproc->iproc=-700;
         m_ExternalProcess = MCATNLO;
       } else if (myvar1 == "lhef") {
         gHwproc->iproc=-100;
         m_ExternalProcess = LHEF;
       } else if (myvar1 == "horace") {
         gHwproc->iproc=-300;
         m_ExternalProcess = HORACE;
       } else {gHwproc->iproc=myint1;}
       extproc_(&m_ExternalProcess);
     }
     // AcerMC tt~ decay mode switching
     else if(myvar=="acset12") {
       if (gHwproc->iproc==-600) {
         this->acermc_acset().acset12()=myint1;
       }
     }
 
     // ------- HWHARD common block
     // kinematic limits    
     else if(myvar=="ptmin"){gHwhard->ptmin=myfl1;}
     else if(myvar=="ptmax"){gHwhard->ptmax=myfl1;}
     else if(myvar=="emmin"){gHwhard->emmin=myfl1;}
     else if(myvar=="emmax"){gHwhard->emmax=myfl1;}
     else if(myvar=="q2min"){gHwhard->q2min=myfl1;}
 
     // ------- HWDIST common block
     else if(myvar=="pltcut"){ gHwdist->pltcut=myfl1;}
     else if(myvar=="mixing"){ gHwdist->mixing=myint1;}
 
     // -------  HWPRAM common block
     else if (myvar=="ispac") { gHwpram->ispac=myint1;}
     else if (myvar=="qspac") { gHwpram->qspac=myfl1;}
 
     else if(myvar=="azsoft"){
       if(myvar1=="false"){
         gHwpram->azsoft=false;
       } else { 
         gHwpram->azsoft=true;
       }
     }
     else if(myvar=="azspin"){
       if(myvar1=="false"){
         gHwpram->azspin=false;
       } else { 
         gHwpram->azspin=true;
       }
     }
     else if(myvar=="nospac"){
       if(myvar1=="false"){
         gHwpram->nospac=false;
       } else { 
         gHwpram->nospac=true;
       }
     }
     else if(myvar=="hardme"){
       if(myvar1=="false"){
         gHwpram->hardme=false;
       } else { 
         gHwpram->hardme=true;
       }
     }
     else if(myvar=="softme"){
       if(myvar1=="false"){
         gHwpram->softme=false;
       } else { 
         gHwpram->softme=true;
       }
     }
 
 
 
     // weak paramters and widths
     else if (myvar=="ncolo") { gHwpram->ncolo=myint1;}
     else if (myvar=="nflav") { gHwpram->nflav=myint1;}
     else if (myvar=="swein") { gHwpram->swein=myfl1;}
     else if (myvar=="scabi") { gHwpram->scabi=myfl1;}
 
     // print options
     else if (myvar=="prvtx"){ gHwpram->prvtx=myint1;}
     else if (myvar=="prndef"){ gHwpram->prndef=myint1;}
     else if (myvar=="prntex"){ gHwpram->prntex=myint1;}
     else if (myvar=="prnweb"){ gHwpram->prnweb=myint1;}
     else if (myvar=="nprfmt"){ gHwpram->nprfmt=myint1;}
     else if (myvar=="iprint"){ gHwpram->iprint=myint1;}
 
     else if (myvar=="gamh") { gHwpram->gamh=myfl1;}
     else if (myvar=="gamw") { gHwpram->gamw=myfl1;}
     else if (myvar=="gamz") { gHwpram->gamz=myfl1;}
     // Zprime width 
     else if(myvar=="gamzp"){ gHwpram->gamzp=myfl1;}
 
 
     else if(myvar=="zprime"){
       if(myvar1=="false"){
         gHwpram->zprime=false;
       } else { 
         gHwpram->zprime=true;
       }
     }
 
     else if (myvar=="effmin") { gHwpram->effmin=myfl1;}
     else if (myvar=="psplt") { 
       gHwpram->psplt[0]=myfl1;
       gHwpram->psplt[1]=myfl2;
     }
     else if (myvar=="cldir") { 
       gHwpram->cldir[0]=myint1;
       gHwpram->cldir[1]=myint2;
     }
     else if (myvar=="clsmr") { 
       gHwpram->clsmr[0]=myfl1;
       gHwpram->clsmr[1]=myfl2;
     }
     else if (myvar=="ensof") { gHwpram->ensof=myfl1;}
     else if (myvar=="qcdlam"){ gHwpram->qcdlam=myfl1;}
     else if (myvar=="clpow") { gHwpram->clpow=myfl1;}
     else if (myvar=="prsof") { gHwpram->prsof=myfl1;}
     else if (myvar=="ptrms") { gHwpram->ptrms=myfl1;}
     else if (myvar=="vgcut") { gHwpram->vgcut=myfl1;}
     else if (myvar=="vqcut") { gHwpram->vqcut=myfl1;}
     else if (myvar=="vpcut") { gHwpram->vpcut=myfl1;}
     // allow user to set different PDF for each beam. Might
     // be need for none LHC runs or photoproduction
     else if(myvar=="modpdf1"){ gHwpram->modpdf[0]=myint1;}
     else if(myvar=="modpdf2"){ gHwpram->modpdf[1]=myint1;}
     // if beam id not specified, assume both are the same PDF.
     else if(myvar=="modpdf"){ 
       gHwpram->modpdf[0]=myint1;
       gHwpram->modpdf[1]=myint1;
     }
 
     // HWPRCH common block
     else if(myvar=="autpdf"){
       string autlocal = myvar1;
       int nch = (autlocal.size()<20) ? autlocal.size() : 19;  
       for(int i=0; i<20; i++) {
         if(i<nch) {
           gHwprch->autpdf[0][i] = autlocal.data()[i];
           gHwprch->autpdf[1][i] = autlocal.data()[i];
         }    else {
           gHwprch->autpdf[0][i] = ' ';
           gHwprch->autpdf[1][i] = ' ';
         }
       }
     }
 
     // output control and random numbers
     else if(myvar=="maxer"){gHwevnt->maxer=myint1;}
     else if(myvar=="maxpr"){gHwevnt->maxpr=myint1;}
 
     else if(myvar=="nrn"){
       if(myint1==1){gHwevnt ->nrn[0]=myint2;}
       else if(myint1==2){ gHwevnt->nrn[1]=myint2;}
     }
     else if(myvar=="nowgt"){
       if(myvar1=="false"){gHwevnt->nowgt=false;}
     }
     else if(myvar=="wgtmax"){gHwevnt->wgtmax=myfl1;}
     else if(myvar=="tlout"){gHwevnt->tlout=myfl1;}
 
     // particle masses
     else if(myvar=="rmass"){
       if (myint1>0 && myint1<501){
         gHwprop->rmass[myint1]=myfl2;
       }
     }
 
     // particle stability
     else if(myvar=="rstab"){
       if (myint1>0 && myint1<501){
         gHwupdt->rstab[myint1]=myint2;
       }
     }
 
     // boson decay modes
     else if(myvar=="modbos") {
       if(myint1>0 && myint1<10) {
         gHwbosc->modbos[myint1-1]=myint2;
       }
     }
 
     // susy filename 
     else if(myvar=="susyfile"){m_read_Filesusy=myvar1;}
 
 
     // version 6.3 
     // graviton stuff
 
     else if(myvar=="grvlam"){gHwgrav->grvlam=myfl1;}
     else if(myvar=="emgrv") {gHwgrav ->emgrv=myfl1;}
     else if(myvar=="gamgrv"){gHwgrav ->gamgrv=myfl1;}
 
     // version 6.506 stuff
     else if(myvar=="pdfx0"){gHw6506->pdfx0=myfl1;}
     else if(myvar=="pdfpow"){gHw6506->pdfpow=myfl1;}
 
     // version 6.510 stuff
     else if(myvar=="ndetry"){m_ndetry=myint1;}
 
     // tauola switch
     else if(myvar=="taudec"){
       int nch = (myvar1.size()<7) ? myvar1.size() : 6;
       for(int i=0; i<6; i++) {
         if(i<nch) {
           gHwdspn->taudec[i] = myvar1.data()[i];
         }
       }
     }
 
     // Spin correlations menu
     else if(myvar=="syspin"){gHwdspn->syspin=myint1;}
     else if(myvar=="spcopt"){gHwspin->spcopt=myint1;}
 
     // Jimmy common blocks
     else if(myvar=="msflag"){gJmparm->msflag=myint1;}
 
     else if(myvar=="jmbug") {gJmparm->jmbug=myint1;}
     else if(myvar=="ptjim") {gJmparm->ptjim=(double)myfl1;}
     else if(myvar=="jmueo") {gJmparm->jmueo=myint1;}
     else if(myvar=="jmrad"){
       if (myint1 > 0 && myint1 < 264) { gJmparm->jmrad[myint1-1] = myfl2; }
       else {  log << MSG:: ERROR << " JMRAD ARRAY HAS ONLY 264 elements [1 to 264]" << endreq; }
     } 
     
     // Charybdis Parameters - added by nick brett - 04-02-05
     else if(myvar=="charyb"){::WriteCharybdisParam(myint1,myint2,(double)myfl2);}
     
     // Colour singlet exchange parameters - added by James Monk 25.Apr.2008
     else if(myvar =="asfixd"){gHwhard ->asfixd=myfl1;}
     else if(myvar =="omega0"){gHwhard ->omega0=myfl1;}
 
     else {
       if (myvar!="topdec") log << MSG::WARNING << " ERROR in HERWIG PARAMETERS   " << myvar << " is not a variable name that I recognize. it could be a typo on your part or a mistake on mine. Not all variables are changeable" << endreq;
     }
   }
 
   // Save the HERWIG_INIT stream seeds....
   CLHEP::HepRandomEngine* engine = p_AtRndmGenSvc->GetEngine(herwig_stream);
   const long*   sip     =       engine->getSeeds();
   long  int     si1     =       sip[0];
   long  int     si2     =       sip[1];
 
   // Special settings for Alpgen
   if ( m_ExternalProcess == ALPGEN ) gHwevnt->maxpr=4;
 
   // now for susy
   if((gHwproc->iproc >= 3000 && gHwproc->iproc < 5000) || (gHwproc->iproc >= 13000 && gHwproc->iproc < 15000)){
     int syunit = 66;
     ////    cdfreadsusy_(const_cast<char*>(_read_Filesusy.value().c_str()),&syunit); 
     const string& fileName = m_read_Filesusy; 
     cdfreadsusy_(fileName.c_str(),&syunit,fileName.size()); 
     hwissp_(&syunit);
   }     
   
   // added for RPV 4-body decays
   // Sebastian Fleischmann/JMB
   hwirpv_();
   // NB: if the RPV code is not linked, a dummy version is called.
 
   hwuinc_(); // calculate herwig constants
   hweini_(); // initialise herwig event.
   jminit_(); // initialise jimmy event.
 
   
   // ... and set them back to the stream for proper save
   p_AtRndmGenSvc->CreateStream(si1, si2, herwig_stream);
   herwig_stream = "HERWIG";
 
   return StatusCode::SUCCESS;
 }
 
 //---------------------------------------------------------------------------
 StatusCode Herwig::callGenerator() {
   //---------------------------------------------------------------------------
   MsgStream log(messageService(), name());
   log << MSG::DEBUG << " HERWIG generating.  \n"  << endreq;
 
   bool goodev = false;
   int abort = 1;
 
   // Save the random number seeds in the event
   CLHEP::HepRandomEngine*       engine  =       p_AtRndmGenSvc->GetEngine(herwig_stream);
   const long*           s       =       engine->getSeeds();
   m_seeds.clear();
   m_seeds.push_back(s[0]);
   m_seeds.push_back(s[1]);
 
   while(!goodev && abort==1){
     hwuine_();  // Initialize event
     if ( m_ExternalProcess == ALPGEN) {
       log << MSG::DEBUG << " HERWIG/ALPGEN  \n"  << endreq;
       hwepro_();
       // Store info for PDFInfo
       hwpdfinfo_();
 
       // matching-driven veto
       int ipveto = 0;
       upveto_(&ipveto);
       if(ipveto != 0) {
         gHwevnt->ierror = -1;
         log << MSG::INFO << " EVENT KILLED BY UPVETO. EXECUTION CONTINUES" << endreq;
       }
 
       
       if (evtcon.istg <= 0) {
         hwbgen_();  // Generate parton cascade
         // Do Jimmy underlying event if required.
         abort = 0;
         if (gJmparm->msflag == 1) { hwmsct_(&abort); }
         if (abort == 0) {
           hwdhob_();  // Do heavy quark decays 
           hwcfor_();  // Do cluster formation
           hwcdec_();  // Do cluster decays
           hwdhad_();  // Do unstable particle decays
           hwdhvy_();  // Do heavy flavor decays
           hwmevt_();  // Add soft underlying event
         }
       }
     } else {
       hwepro_();  // Generate Hard Process      
       // Store info for PDFInfo
       hwpdfinfo_();
 
       if (gHwproc->iproc == -200 ) {
         charybdfix_(); //reset hard cms code to BH=40
       }
       if ( evtcon.istg <= 0 ) {
         if(! m_noshower_Parm) {
           hwbgen_();  // Generate parton cascade
           abort = 0;
           if (gJmparm->msflag == 1) { hwmsct_(&abort); }
           if (abort == 0) {
             hwdhob_();  // Do heavy quark decays 
             if(! m_nohadroniz_Parm) {
               hwcfor_();  // Do cluster formation
               hwcdec_();  // Do cluster decays
               hwdhad_();  // Do unstable particle decays
               hwdhvy_();  // Do heavy flavor decays
               hwmevt_();  // Add soft underlying event
             }
           }
         }
       }
     } 
     // User event analysis if wanted
     if ( evtcon.istg > 0 ) {
       std::cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
       std::cout << "!! " << generator_name(m_ExternalProcess) << " TERMINATES NORMALLY: NO MORE EVENTS IN FILE !!!" << std::endl;
       std::cout << "!! PLEASE IGNORE ANY ATHENA ERROR MESSAGES LIKE                              !!" << std::endl;
       std::cout << "!! AthenaEventLoopMgr  ERROR Terminating event processing loop due to errors !!" << std::endl;
       std::cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
       return StatusCode::FAILURE;
     }
     
     if (abort == 0) {
       hwufne_();  // Finish event
       
       int ihwcod = 1;
       hwanal_(&ihwcod);
       if(gHwevnt->ierror == 0){
         goodev=true;
       } else { //modified by T.Sasaki
         goodev=false; //explicit , not necessary;
         abort=1; //for loop again
       }
     }
   }
 
   return StatusCode::SUCCESS;  
   log << MSG::DEBUG << " HERWIG generating done.  \n"  << endreq;
 }
 
 //---------------------------------------------------------------------------
 StatusCode Herwig::genFinalize() {
   //---------------------------------------------------------------------------
   MsgStream log(messageService(), name());
   log << MSG:: INFO << " HERWIG Ending.  \n"  << endreq;
   // Don't call this again for AlpGen
   if ( m_ExternalProcess != ALPGEN ) {
     // Don't do this for ALPGEN.
     log << MSG::INFO <<"Call HWEFIN and HWAEND at endRun" << endreq;
     hwefin_();
   }
   if (gJmparm->msflag == 1) { jmefin_(); }
   // User terminal calculations if wanted
   std::cout << "MetaData: cross-section (nb)= " << gHwevnt->avwgt << std::endl;
   // hwaend_();
   return StatusCode::SUCCESS;
 }
 //---------------------------------------------------------------------------
 StatusCode Herwig::fillEvt(GenEvent* evt) {
   //---------------------------------------------------------------------------
   MsgStream log(messageService(), name());
 
   log << MSG::DEBUG << " HERWIG Atlas_HEPEVT Filling.  \n"  << endreq;
   store_Atlas_HEPEVT();
 
   log << MSG::DEBUG << " HERWIG Filling.  \n"  << endreq;
   HepMC::IO_HERWIG hepio;
   //  hepio.set_trust_mothers_before_daughters(0);
   //hepio.set_print_inconsistency_errors(0);
   //HepMC::HEPEVT_Wrapper::check_hepevt_consistency(); 
   //HepMC::IO_Ascii output("dump.dat",ios::out);
   //  int i = 1;
   // Fill event into HepMC and transient store
   hepio.fill_next_event(evt);
   int pr_id = HERWIG + m_ExternalProcess + gHwproc->iproc;
   if (gHwproc->iproc < 0) pr_id = HERWIG + m_ExternalProcess;
   string taustring;
   taustring.assign(gHwdspn->taudec,6);
   if ( taustring == "TAUOLA") pr_id += TAUOLA_PHOTOS;
   evt->set_signal_process_id(pr_id);
   evt->set_random_states(m_seeds);
 
   int id1=gHrwpdf->id1;
   int id2=gHrwpdf->id2;
   double x1=gHrwpdf->x1;
   double x2=gHrwpdf->x2;
   double q=gHrwpdf->q;
   double pdf1=gHrwpdf->idpdf1;
   double pdf2=gHrwpdf->idpdf2;
   HepMC::PdfInfo tmp_pdi(id1,id2,x1,x2,q,pdf1,pdf2);
   evt->set_pdf_info(tmp_pdi);
   /*
   std::cout << "pdfinfo:"<<  evt->pdf_info()->id1() << std::endl;
   std::cout << "pdfinfo:"<<  evt->pdf_info()->id2() << std::endl;
   std::cout << "pdfinfo:"<<  evt->pdf_info()->x1() << std::endl;
   std::cout << "pdfinfo:"<<  evt->pdf_info()->x2() << std::endl;
   std::cout << "pdfinfo:"<<  evt->pdf_info()->scalePDF() << std::endl;
   std::cout << "pdfinfo:"<<  (int)evt->pdf_info()->pdf1() << std::endl;
   std::cout << "pdfinfo:"<<  (int)evt->pdf_info()->pdf2() << std::endl; 
   */
 
   if (gHwevnt->evwgt < 0.) evt->weights().push_back(-1.);
   if (gHwevnt->evwgt > 0.) evt->weights().push_back(1.);
   if (gHwevnt->evwgt == 0.) log << MSG::WARNING << " EVENT WEIGHT = 0 !!!!!! \n" << endreq;
   //  cout << " ----------------- Print evt " << endl;
   //    evt -> print();
   //  cout << " ----------------- END " << endl;
   
   //  output << evt;
   
   // Convert cm->mm and GeV->MeV
   //   cmTomm(evt);
   GeVToMeV(evt);
   
   return StatusCode::SUCCESS;
 }
 
 
 void
 Herwig::store_Atlas_HEPEVT(void)
 {
   MsgStream log(messageService(), name());
 
   // std::cout << "atlas_HEPEVT------" << atlas_HEPEVT->nhep()  << std::endl;
   //std::cout << "atlas_HEPEVT------" << atlas_HEPEVT->isthep(10)  << std::endl;
   //std::cout << "atlas_HEPEVT------" << atlas_HEPEVT->idhep(10)  << std::endl;
   //std::cout << "atlas_HEPEVT------" << atlas_HEPEVT->jmohep(1,10)  << std::endl;
   //std::cout << "atlas_HEPEVT------" << atlas_HEPEVT->jdahep(2,10)  << std::endl;
 
   atlas_HEPEVT->fill();
 
   Atlas_HEPEVT* Ahep = new Atlas_HEPEVT();
   *(Ahep)=*(atlas_HEPEVT);
   std::string keyid = "Herwig";
   StatusCode sc = m_sgSvc->record(Ahep, keyid);
   if (!sc.isSuccess()) log << MSG::WARNING << " Could not record Atlas_HEPEVT" << endreq;
 
 }

Due to the LXR bug, the updates fail sometimes to remove references to deleted files. The Saturday's full rebuilds fix these problems
This page was automatically generated by the LXR engine.