HepevtModule Class Reference

#include <HepevtModule.h>

Inheritance diagram for HepevtModule:

JobCModule List of all members.

Public Member Functions

 HepevtModule ()
 ~HepevtModule ()
JobCResult Get (MomNavigator *mom)
JobCResult Ana (const MomNavigator *mom)
const RegistryDefaultConfig () const
void Config (const Registry &r)
void EndJob ()

Static Public Member Functions

static void SetDefaultDetector (Detector::Detector_t det)
static void SetDefaultStartVldTimeStamp (const VldTimeStamp &vts)
static void SetDefaultSpillTimeInterval (Double_t dt)
static VldTimeStamp GetDefaultStartVldTimeStamp ()
static Double_t GetDefaultStartVldTimeInterval ()

Private Member Functions

SimSnarlRecordFindOrCreateSimSnarlRecord (MomNavigator *mom)
 Find a record we can modify.
int CountNeededBogusNeuKin (TClonesArray *stdhep, std::vector< int > &splitIndices)
 Add bogus REROOT_NeuKin entries to make PTSim happy.
void AddBogusNeuKinEntries (SimSnarlRecord *record, int nneukin, TClonesArray *stdhep, std::vector< int > &splitIndices)
void FillNeuKinStructFromStdHepRange (NEUKIN_DEF *neukin, TClonesArray *stdhep, int ibeg, int iend)
void ModifyStdHep (TClonesArray *stdhep)
 adjust status codes, squeeze out unwanted lines

Private Attributes

Detector::Detector_t fDetector
VldTimeStamp fTimeStampStart
Double_t fDtSpill
Int_t fRun
Int_t fSubRun
Int_t fSnarl
TLorentzVector fVtxOffset
std::string fStdHepInputFileName
std::ifstream fStdHepInputFile
Int_t fInputBinaryFD
Bool_t fGetApplyRollback
Bool_t fAnaPrintStdHep
Int_t fIonScheme
Bool_t fFixCharmDKStatus
Bool_t fDropGeantEntries
Bool_t fDropTauDecayProducts
Bool_t fDropCharmDecayProducts
Bool_t fDropStatus999
std::string fStdHepEditString
Bool_t fForceNevHEPSnarl
Int_t fMakeBogusNeuKinEntries
Int_t fAddedLists
Int_t fAddedEntries
UtilHepevt::cunits_t fVtxConvert
UtilHepevt::cunits_t fTConvert
UtilHepevt::cunits_t fEConvert

Static Private Attributes

static Detector::Detector_t fgDefaultDetector = Detector::kUnknown
static VldTimeStamp fgDefaultStartTime = VldTimeStamp()
static Double_t fgDefaultDtSpill = 1.9

Detailed Description

Definition at line 33 of file HepevtModule.h.


Constructor & Destructor Documentation

HepevtModule::HepevtModule (  ) 

Definition at line 83 of file HepevtModule.cxx.

References LoadMinosPDG().

00084     : fDetector(fgDefaultDetector)
00085     , fTimeStampStart(fgDefaultStartTime)
00086     , fDtSpill(fgDefaultDtSpill)
00087     , fRun(1)
00088     , fSubRun(0)
00089     , fSnarl(-1)
00090     , fInputBinaryFD(-1)
00091     , fGetApplyRollback(true)
00092     , fAnaPrintStdHep(true)
00093     , fIonScheme(UtilPDG::kIonUnchanged)
00094     , fFixCharmDKStatus(true)
00095     , fDropGeantEntries(false)
00096     , fDropTauDecayProducts(false)
00097     , fDropCharmDecayProducts(false)
00098     , fDropStatus999(false)
00099     , fStdHepEditString("")
00100     , fForceNevHEPSnarl(false)
00101     , fMakeBogusNeuKinEntries(3)
00102     , fAddedLists(0)
00103     , fAddedEntries(0)
00104     , fVtxConvert(UtilHepevt::k_none)
00105     , fTConvert(UtilHepevt::k_none)
00106     , fEConvert(UtilHepevt::k_none)
00107 {
00108    // construct a new "HepevtModule" JobControl module
00109 
00110    // initialize detector to non-legal value
00111 
00112    LoadMinosPDG();
00113 
00114 }

HepevtModule::~HepevtModule (  ) 

Definition at line 118 of file HepevtModule.cxx.

References Msg::kVerbose, and MSG.

00119 {
00120   MSG("Hepevt", Msg::kVerbose) << "HepevtModule::Destructor\n";
00121 
00122 }


Member Function Documentation

void HepevtModule::AddBogusNeuKinEntries ( SimSnarlRecord record,
int  nneukin,
TClonesArray *  stdhep,
std::vector< int > &  splitIndices 
) [private]

Definition at line 497 of file HepevtModule.cxx.

References RecDataRecord< T >::AdoptComponent(), FillNeuKinStructFromStdHepRange(), RecDataRecord< T >::FindComponent(), and fMakeBogusNeuKinEntries.

Referenced by Get().

00500 {
00501   // Add REROOT_NeuKin entries to the "NeuKinList" in the SimSnarlRecord 
00502   // (create list if necessary).  Do this to keep PTSim happy...
00503 
00504   // if fMakeBogusNeuKinEntries is negative try to fill them in a meaningful way
00505 
00506   const TObject* const_obj = record->FindComponent("TClonesArray","NeuKinList");
00507   // cast away constness!!! so we can modify it ... bad, bad us!
00508   TObject* obj = const_cast<TObject*>(const_obj);
00509   if ( ! obj ) {
00510     // record didn't have a list ... make one
00511     TClonesArray* newarray = new TClonesArray("REROOT_NeuKin",0);
00512     newarray->SetName("NeuKinList");
00513     record->AdoptComponent(newarray); // add to the record
00514     obj = newarray;
00515   }
00516   // Now to the right type
00517   TClonesArray* neukinlist = dynamic_cast<TClonesArray*>(obj);  // this is already owned
00518   // Add entries
00519   int ientry = neukinlist->GetLast() + 1;
00520   for (int ikin = 0; ikin < nneukin; ++ikin) {
00521     if ( fMakeBogusNeuKinEntries < 0 ) {
00522       new((*neukinlist)[ientry++])REROOT_NeuKin();  // make bogus entries
00523     } else {
00524       // make bogus entries, but try to fill them in a meaningful way
00525       NEUKIN_DEF neukin;
00526       FillNeuKinStructFromStdHepRange(&neukin,stdhep,
00527                                       splitIndices[ikin],splitIndices[ikin+1]);
00528       new((*neukinlist)[ientry++])REROOT_NeuKin(&neukin);  
00529     }
00530   }
00531 }

JobCResult HepevtModule::Ana ( const MomNavigator mom  )  [virtual]

Implement this for read only access to the MomNavigator

Reimplemented from JobCModule.

Definition at line 737 of file HepevtModule.cxx.

References UtilHepevt::dump(), fAnaPrintStdHep, RecDataRecord< T >::FindComponent(), MomNavigator::GetFragment(), SimSnarlRecord::GetSimSnarlHeader(), JobCResult::kPassed, JobCResult::kWarning, Msg::kWarning, MSG, SimSnarlRecord::Print(), and SimSnarlHeader::Print().

00738 {
00739    // Check out current RecSimSnarl Record from the current REROOT event
00740 
00741    const TObject* obj = 0;
00742 
00743    SimSnarlRecord* simrec = 
00744       dynamic_cast<SimSnarlRecord*>(mom->GetFragment("SimSnarlRecord"));
00745    if (!simrec) {
00746       MSG("Hepevt", Msg::kWarning) << 
00747         "HepevtModule::Ana no SimSnarlRecord" << endl;
00748       return JobCResult::kWarning;
00749    }
00750 
00751    // leading space
00752    cout << endl;
00753    cout << "HepevtModule::Ana() begin: " << endl;
00754    // print the header
00755    simrec->GetSimSnarlHeader()->Print();
00756    cout << endl; // finish off header
00757 
00758    if (fAnaPrintStdHep) {
00759        obj = simrec->FindComponent("TClonesArray","StdHep");
00760        const TClonesArray* newstdhep = dynamic_cast<const TClonesArray*>(obj);
00761        if (!newstdhep) {
00762            MSG("Hepevt", Msg::kWarning) << 
00763                "HepevtModule::Ana no StdHep " << obj << endl;
00764            simrec->Print();
00765            return JobCResult::kWarning;
00766        }
00767        else UtilHepevt::dump(newstdhep,1);  //alt_print_tclones_stdhep(newstdhep);
00768    }
00769    cout << "HepevtModule::Ana() done ================================================== " << endl;
00770 
00771    return JobCResult::kPassed; // All Ok
00772 }

void HepevtModule::Config ( const Registry r  )  [virtual]

Return the actual configuration. If your module directly pulls its configuration from the fConfig Registry, you don't need to override this. Override if you have local config variables.

Reimplemented from JobCModule.

Definition at line 838 of file HepevtModule.cxx.

References UtilHepevt::asString(), UtilHepevt::closeBinary(), fAnaPrintStdHep, fDetector, fDropCharmDecayProducts, fDropGeantEntries, fDropStatus999, fDropTauDecayProducts, fDtSpill, fEConvert, fFixCharmDKStatus, fForceNevHEPSnarl, fGetApplyRollback, fInputBinaryFD, fIonScheme, fMakeBogusNeuKinEntries, fRun, fSnarl, fStdHepEditString, fStdHepInputFile, fStdHepInputFileName, fSubRun, fTConvert, fVtxConvert, fVtxOffset, Registry::Get(), Registry::GetCharString(), JobCModule::GetName(), UtilPDG::ionSchemeName(), Msg::kInfo, MSG, UtilHepevt::openBinary(), and UtilHepevt::string2cunits().

00839 {
00840 //======================================================================
00841 // Configure the module given the registry r
00842 //======================================================================
00843   const char*  tmps;
00844   double tmpd;
00845   int    tmpi;
00846 
00847   if (r.Get("Detector",   tmpi)) { fDetector = (Detector::Detector_t)tmpi; }
00848   if (r.Get("DtSpill",    tmpd)) { fDtSpill  = tmpd; }
00849   if (r.Get("Run",        tmpi)) { fRun      = tmpi; }
00850   if (r.Get("SubRun",     tmpi)) { fSubRun   = tmpi; }
00851   if (r.Get("FirstSnarl", tmpi)) { fSnarl    = tmpi-1; } // start -1 so ++ works
00852 
00853   // changing file or input binary mode triggers close/re-open
00854   bool new_file = false;
00855   if (r.Get("StdHepInputFile", tmps)) { 
00856     std::string fname = tmps;
00857     if ( fname != "" ) {
00858       if ( fname != fStdHepInputFileName ) new_file = true;
00859       fStdHepInputFileName = fname;
00860     }
00861   }
00862   int isbinary = 0;
00863   if (r.Get("InputBinary", tmpi)) { isbinary = tmpi; }
00864   int current_binary = ( fInputBinaryFD != -1 ) ? 1 : 0;
00865   bool switch_mode = ( current_binary != isbinary );
00866 
00867   if ( new_file || switch_mode ) {
00868     // close any binary file
00869     UtilHepevt::closeBinary(fInputBinaryFD);
00870     // close any open ascii file
00871     if ( fStdHepInputFile.is_open() ) fStdHepInputFile.close();
00872 
00873     if ( fStdHepInputFileName != "" ) {
00874       if ( isbinary ) {
00875         fInputBinaryFD = UtilHepevt::openBinary(fStdHepInputFileName.c_str(),false);
00876         if ( fInputBinaryFD != -1 ) {
00877           MSG("Hepevt",Msg::kInfo) 
00878             << "Successfully opened binary file " << fStdHepInputFileName
00879             << " for StdHep events to append to SimSnarl" << endl;
00880         }
00881       } else {
00882         fStdHepInputFile.open(fStdHepInputFileName.c_str(),ifstream::in);
00883         if ( fStdHepInputFile.is_open() ) {
00884           MSG("Hepevt",Msg::kInfo) 
00885             << "Successfully opened ascii file " << fStdHepInputFileName
00886             << " for StdHep events to append to SimSnarl" << endl;
00887         }
00888       }
00889     }
00890   }
00891 
00892   TLorentzVector voffset(fVtxOffset);
00893   if (r.Get("VtxOffsetX", tmpd)) { voffset.SetX(tmpd); }
00894   if (r.Get("VtxOffsetY", tmpd)) { voffset.SetY(tmpd); }
00895   if (r.Get("VtxOffsetZ", tmpd)) { voffset.SetZ(tmpd); }
00896   if (r.Get("VtxOffsetT", tmpd)) { voffset.SetT(tmpd); }
00897   if ( voffset != fVtxOffset ) {
00898     fVtxOffset = voffset;
00899     MSG("Hepevt",Msg::kInfo) 
00900       << "Using vtx offset of { " 
00901       << fVtxOffset.X() << ", "
00902       << fVtxOffset.Y() << ", "
00903       << fVtxOffset.Z() << ", "
00904       << fVtxOffset.T() << " }" << endl;
00905   }
00906 
00907   bool changeUnits = false;
00908   if ( r.Get("vtxConvert",tmps) ) {
00909     UtilHepevt::cunits_t vtxConvert = UtilHepevt::string2cunits(tmps);
00910     //MSG("Hepevt",Msg::kInfo) << " vtxC " << tmps << " " << vtxConvert << " " << fVtxConvert << endl;
00911     if ( fVtxConvert != vtxConvert ) {
00912       fVtxConvert = vtxConvert;
00913       changeUnits = true;
00914     }
00915   }
00916   if ( r.Get("tConvert",tmps) ) {
00917     UtilHepevt::cunits_t tConvert = UtilHepevt::string2cunits(tmps);
00918     //MSG("Hepevt",Msg::kInfo) << " vtxC " << tmps << " " << tConvert << " " << fTConvert << endl;
00919     if ( fTConvert != tConvert ) {
00920       fTConvert = tConvert;
00921       changeUnits = true;
00922     }
00923   }
00924   if ( r.Get("eConvert",tmps) ) {
00925     UtilHepevt::cunits_t eConvert = UtilHepevt::string2cunits(tmps);
00926     //MSG("Hepevt",Msg::kInfo) << " vtxC " << tmps << " " << eConvert << " " << fEConvert << endl;
00927     if ( fEConvert != eConvert ) {
00928       fEConvert = eConvert;
00929       changeUnits = true;
00930     }
00931   }
00932   if ( changeUnits ) {
00933     MSG("Hepevt",Msg::kInfo) 
00934       << "Setting unit conversion "
00935       << "vtx = " << UtilHepevt::asString(fVtxConvert)
00936       << ", t = " << UtilHepevt::asString(fTConvert)
00937       << ", e = " << UtilHepevt::asString(fEConvert)
00938       << endl;
00939   }
00940 
00941   if (r.Get("GetApplyRollback",    tmpi)) { fGetApplyRollback   = tmpi; }
00942   if (r.Get("AnaPrintStdHep",      tmpi)) { fAnaPrintStdHep     = tmpi; }
00943 
00944   if (r.Get("ConvertIonPDG",tmpi)) {
00945     if (fIonScheme != tmpi) {
00946       MSG("Hepevt",Msg::kInfo) 
00947         << GetName() << " will convert ions using the "
00948         << UtilPDG::ionSchemeName((UtilPDG::ionscheme_t)tmpi)
00949         << " scheme." << endl;
00950     }
00951     fIonScheme = tmpi;
00952   }
00953   
00954   bool changeEdit = false;
00955   if (r.Get("FixCharmDKStatus",      tmpi)) 
00956     { if ( fFixCharmDKStatus != tmpi ) 
00957       { fFixCharmDKStatus = tmpi; changeEdit=true; } }
00958   if (r.Get("DropGeantEntries",      tmpi)) 
00959     { if ( fDropGeantEntries != tmpi )
00960       { fDropGeantEntries = tmpi; changeEdit=true; } }
00961   if (r.Get("DropTauDecayProducts",  tmpi)) 
00962     { if ( fDropTauDecayProducts != tmpi ) 
00963       { fDropTauDecayProducts = tmpi; changeEdit=true; } }
00964   if (r.Get("DropCharmDecayProducts",tmpi)) 
00965     { if ( fDropCharmDecayProducts != tmpi )
00966       { fDropCharmDecayProducts = tmpi; changeEdit=true; } }
00967   if (r.Get("DropStatus999",         tmpi)) 
00968     { if ( fDropStatus999 != tmpi )
00969       { fDropStatus999 = tmpi; changeEdit=true; } }
00970 
00971   std::string tmpstr = r.GetCharString("StdHepEditString");
00972   if ( tmpstr != fStdHepEditString )
00973     { fStdHepEditString = tmpstr; changeEdit=true; }
00974 
00975   if ( changeEdit ) {
00976     MSG("Hepevt",Msg::kInfo)
00977       << GetName() << " StdHep list editing,"
00978       << " FixCharmDKStatus " << (fFixCharmDKStatus?"yes":"no")
00979       << endl <<  "    Drop:  "
00980       << " GeantEntries="       << (fDropGeantEntries?"yes":"no")
00981       << " TauDecayProducts="   << (fDropTauDecayProducts?"yes":"no")
00982       << " CharmDecayProducts=" << (fDropCharmDecayProducts?"yes":"no")
00983       << " Status999="          << (fDropStatus999?"yes":"no")
00984       << endl;
00985     if (fStdHepEditString != "") {
00986       MSG("Hepevt",Msg::kInfo)
00987         << " StdHepEditString: \"" << fStdHepEditString << "\""
00988         << endl;
00989     }
00990   }
00991 
00992   bool change2 = false;
00993   if (r.Get("ForceNevHEPSnarl",      tmpi)) 
00994     { if ( fForceNevHEPSnarl != tmpi ) 
00995       { fForceNevHEPSnarl = tmpi; change2=true; } }
00996   if (r.Get("BogusNeuKin",     tmpi)) 
00997     { if ( fMakeBogusNeuKinEntries != tmpi )
00998       { fMakeBogusNeuKinEntries = tmpi; change2=true; } }
00999   if ( change2 ) {
01000     MSG("Hepevt",Msg::kInfo)
01001       << GetName() << " ForceNevHEPSnarl = "
01002       << (fForceNevHEPSnarl?"true":"false")
01003       << ", MakeBogusNeuKinEntries = " << fMakeBogusNeuKinEntries
01004       << endl;
01005   }
01006 
01007 }

int HepevtModule::CountNeededBogusNeuKin ( TClonesArray *  stdhep,
std::vector< int > &  splitIndices 
) [private]

Add bogus REROOT_NeuKin entries to make PTSim happy.

Definition at line 403 of file HepevtModule.cxx.

References fMakeBogusNeuKinEntries, hepevtmdlns::isInitialState(), Msg::kWarning, and MAXMSG.

Referenced by Get().

00405 {
00406   // Determing # of "events" PTSim is going to consider this stdhep
00407   // as having based on an imitation of its algorithm for splitting.
00408 
00409 
00410   Int_t nstdhep = stdhep->GetEntriesFast();
00411 
00412   Int_t nevents = 0;
00413   splitIndices.clear();
00414 
00415   // how to count
00416   switch ( abs(fMakeBogusNeuKinEntries) ) {
00417   case  1:
00418     {
00419       // no splitting, always assume 1 
00420       nevents = 1;
00421       splitIndices.push_back(0);
00422       break; 
00423     }
00424   case  2: 
00425     {
00426       // try to approximate "simple" splitting scheme in PTSim 
00427       // each "event" is a unspecified series of status 0 
00428       // (or 1001, 2001 for Minerva)  entries followed by some w/ 
00429       // other status values.  Seeing status 0 again triggers new event.
00430       int mcindex = -1;
00431       bool ready_for_trigger = true;
00432       for ( Int_t istd = 0; istd < nstdhep; istd++ ) {
00433         TParticle* simstdhep = dynamic_cast<TParticle*>(stdhep->At(istd));
00434         Int_t status = simstdhep->GetStatusCode();
00435         // 0=neugen/genie initial state
00436         // 3=nuance initial state
00437         // 1001/2001 minerva/argoneut initial state 
00438         //   (after propagation through those detectors)
00439         if ( hepevtmdlns::isInitialState(status) ) {
00440           if ( ready_for_trigger ) {
00441             // start new event
00442             ++mcindex;
00443             splitIndices.push_back(istd);
00444             ready_for_trigger = false;
00445           }
00446         } else {
00447           ready_for_trigger = true;
00448         }
00449       }
00450       nevents = mcindex+1;
00451       break;
00452     }
00453   case  3: 
00454     {
00455       // try to approximate splitting scheme in PTSim
00456       int mcindex = -1;
00457       int nprim = 0;
00458       bool prevchild = true;
00459       
00460       for ( Int_t istd = 0; istd < nstdhep; istd++ ) {
00461         TParticle* simstdhep = dynamic_cast<TParticle*>(stdhep->At(istd));
00462         
00463         if ( simstdhep->GetMother(0) == -1 && simstdhep->GetMother(1) == -1 ) {
00464           // primary, check to make sure its new event
00465           nprim++;
00466           if ( nprim > 2 || prevchild ) {
00467             mcindex++;
00468             splitIndices.push_back(istd);
00469             nprim = 1;
00470           }
00471           prevchild = false;
00472         } else {
00473           prevchild = true;
00474           nprim = 0;
00475         }
00476       }
00477       nevents = mcindex+1;
00478       break;
00479     }
00480   default:
00481     {
00482       MAXMSG("Hepevt",Msg::kWarning,5)
00483         << "CountNeededBogusNeuKin switch=" << fMakeBogusNeuKinEntries
00484         << " not a recognized setting" << endl;
00485       nevents = 1;
00486       splitIndices.push_back(0);
00487     }
00488 
00489   }
00490   splitIndices.push_back(nstdhep);
00491 
00492   return nevents;
00493 }

const Registry & HepevtModule::DefaultConfig (  )  const [virtual]

Get the default configuration registry. This should normally be overridden. One useful idiom is to implement it like:

const Registry& MyModule::DefaultConfig() const { static Registry cfg; // never is destroyed if (cfg.Size()) return cfg; // already filled it // set defaults: cfg.Set("TheAnswer",42); cfg.Set("Units","unknown"); return cfg; }

Reimplemented from JobCModule.

Definition at line 775 of file HepevtModule.cxx.

References JobCModule::GetName(), UtilPDG::kIonUnchanged, Detector::kUnknown, Registry::LockValues(), Registry::Set(), and Registry::UnLockValues().

00776 {
00777 //======================================================================
00778 // Create a registry which holds the default configuration and return it
00779 //======================================================================
00780   static Registry r;
00781  
00782   // Set name of config
00783   std::string name = this->GetName();
00784   name += ".config.default";
00785   r.SetName(name.c_str());
00786 
00787   // Set values of config
00788   r.UnLockValues();
00789 
00790   // if creating records out of whole cloth here's a starting point
00791   r.Set("Detector", Detector::kUnknown); // user must set!
00792   r.Set("DtSpill",  1.9);  // time between spills
00793   r.Set("Run",        1);  //
00794   r.Set("SubRun",     0);
00795   r.Set("FirstSnarl", 0);  // starting snarl #
00796 
00797   // This module assumes that the input file is in the minossoft
00798   // offline coordinate system (though stored internally the the StdHep
00799   // units of millimeters).  If the input file is from GMINOS (i.e. z=0
00800   // is the front of the hall rather than 2mm upstream of the front
00801   // of the plane 0 steel) then you must add the appropriate offset:
00802   //     NearDet:    VtxOffsetZ = -49.07 
00803   //     FarDet:     VtxOffsetZ = -14.02
00804   r.Set("VtxOffsetX", 0.0);
00805   r.Set("VtxOffsetY", 0.0);
00806   r.Set("VtxOffsetZ", 0.0);
00807   r.Set("VtxOffsetT", 0.0);
00808 
00809   r.Set("vtxConvert", "none");
00810   r.Set("tConvert",   "none");
00811   r.Set("eConvert",   "none");
00812 
00813   r.Set("StdHepInputFile",    "");
00814   r.Set("InputBinary",         0);
00815 
00816   r.Set("GetApplyRollback",    1);
00817   r.Set("AnaPrintStdHep",      1);
00818 
00819   r.Set("ConvertIonPDG",(int)UtilPDG::kIonUnchanged);
00820   r.Set("FixCharmDKStatus",       1);  // do *this* by default
00821   r.Set("DropGeantEntries",       0);
00822   r.Set("DropTauDecayProducts",   0);
00823   r.Set("DropCharmDecayProducts", 0);
00824   r.Set("DropStatus999",          0);
00825   r.Set("StdHepEditString",      "");
00826 
00827   r.Set("ForceNevHEPSnarl",       0);
00828 
00829   r.Set("BogusNeuKin",            3); // make bogus REROOT_NeuKin entries (PTSim default algorithm for splitting)
00830 
00831   r.LockValues();
00832 
00833   return r;
00834 }

void HepevtModule::EndJob (  )  [virtual]

Implement for notification of end of job

Reimplemented from JobCModule.

Definition at line 1011 of file HepevtModule.cxx.

References fAddedEntries, fAddedLists, Msg::kInfo, and MSG.

01012 {
01013 
01014   MSG("Hepevt",Msg::kInfo)
01015     << "HepevtModule Added " << fAddedEntries << " entries to " 
01016     << fAddedLists << " lists" << endl;
01017 
01018 }

void HepevtModule::FillNeuKinStructFromStdHepRange ( NEUKIN_DEF neukin,
TClonesArray *  stdhep,
int  ibeg,
int  iend 
) [private]

Definition at line 534 of file HepevtModule.cxx.

References NEUKIN_DEF::A, NEUKIN_DEF::EMFrac, UtilPDG::getIonAZJ(), NEUKIN_DEF::IAction, NEUKIN_DEF::IBoson, NEUKIN_DEF::ID, NEUKIN_DEF::IFlags, NEUKIN_DEF::INu, INULL, NEUKIN_DEF::INuNoOsc, NEUKIN_DEF::IResonance, UtilPDG::isElectron(), hepevtmdlns::isInitialState(), UtilPDG::isMuon(), UtilPDG::isNeutrino(), UtilPDG::isNeutron(), UtilPDG::isProton(), UtilPDG::isTau(), NEUKIN_DEF::IStruckQ, NEUKIN_DEF::ITg, NEUKIN_DEF::P4El1, NEUKIN_DEF::P4El2, NEUKIN_DEF::P4Mu1, NEUKIN_DEF::P4Mu2, NEUKIN_DEF::P4Neu, NEUKIN_DEF::P4NeuNoOsc, NEUKIN_DEF::P4Shw, NEUKIN_DEF::P4Tau, NEUKIN_DEF::P4Tgt, NEUKIN_DEF::Q2, RNULL, NEUKIN_DEF::Sigma, NEUKIN_DEF::SigmaDiff, NEUKIN_DEF::W2, NEUKIN_DEF::X, NEUKIN_DEF::Y, and NEUKIN_DEF::Z.

Referenced by AddBogusNeuKinEntries().

00537 {
00538 
00539   const int   INULL = 2147483647;  /* null values ala ADAMO */
00540   const float RNULL = 699050.*65536.*65536.*65536.*65536.*65536.*65536.*256.;
00541 
00542   // set default to what ADAMO nulwin would set the values to
00543   neukin->ID         = INULL;
00544   neukin->INu        = INULL;
00545   neukin->INuNoOsc   = INULL;
00546   neukin->ITg        = INULL;
00547   neukin->IBoson     = INULL;
00548   neukin->IResonance = INULL;
00549   neukin->IAction    = INULL;
00550   neukin->IStruckQ   = INULL;
00551   neukin->IFlags     = INULL;
00552   neukin->A          = RNULL;
00553   neukin->Z          = RNULL;
00554   neukin->Sigma      = RNULL;
00555   neukin->SigmaDiff  = RNULL;
00556   neukin->X          = RNULL;
00557   neukin->Y          = RNULL;
00558   neukin->Q2         = RNULL;
00559   neukin->W2         = RNULL;
00560   neukin->EMFrac     = RNULL;
00561 
00562 // Fill simple arrays from NeuKin struct.
00563   Int_t i;
00564   for (i=0; i<4; i++) {
00565         neukin->P4Neu[i]      = RNULL;
00566         neukin->P4NeuNoOsc[i] = RNULL;
00567         neukin->P4Tgt[i]      = RNULL;
00568         neukin->P4Shw[i]      = RNULL;
00569         neukin->P4Mu1[i]      = RNULL;
00570         neukin->P4Mu2[i]      = RNULL;
00571         neukin->P4El1[i]      = RNULL;
00572         neukin->P4El2[i]      = RNULL;
00573         neukin->P4Tau[i]      = RNULL;
00574   }
00575 
00576   neukin->IFlags       = INULL;
00577   neukin->IStruckQ     = INULL;
00578   neukin->SigmaDiff    = RNULL;
00579 
00580   int     tmp_nshw = 0;
00581   Float_t tmp_p4shw[4] = { 0, 0, 0, 0 };
00582 
00583   // work backward through the StdHep list
00584   for (int ihep=iend-1; ihep >= ibeg; --ihep) {
00585     const TParticle* apart = dynamic_cast<const TParticle*>(stdhep->At(ihep));
00586     if ( ! apart ) continue;
00587 
00588     int istatus = apart->GetStatusCode();
00589     int ipdg    = apart->GetPdgCode();
00590 
00591     bool isnu  = UtilPDG::isNeutrino(ipdg);
00592     bool isel  = UtilPDG::isElectron(ipdg);
00593     bool ismu  = UtilPDG::isMuon(ipdg);
00594     bool istau = UtilPDG::isTau(ipdg);
00595     
00596     if ( hepevtmdlns::isInitialState(istatus) ) {
00597       if ( isnu ) {
00598         // initial state neutrino
00599         if ( neukin->INu == INULL ) {
00600           neukin->INu = ipdg;
00601           neukin->P4Neu[0] = apart->Px();
00602           neukin->P4Neu[1] = apart->Py();
00603           neukin->P4Neu[2] = apart->Pz();
00604           neukin->P4Neu[3] = apart->Energy();
00605         }
00606         neukin->INuNoOsc = ipdg;
00607         neukin->P4NeuNoOsc[0] = apart->Px();
00608         neukin->P4NeuNoOsc[1] = apart->Py();
00609         neukin->P4NeuNoOsc[2] = apart->Pz();
00610         neukin->P4NeuNoOsc[3] = apart->Energy();
00611       } else {
00612         // initial state target
00613         neukin->ITg = ipdg;
00614         neukin->P4Tgt[0] = apart->Px();
00615         neukin->P4Tgt[1] = apart->Py();
00616         neukin->P4Tgt[2] = apart->Pz();
00617         neukin->P4Tgt[3] = apart->Energy();
00618         if ( ipdg >= 1000000000 && ipdg < 2000000000 ) {
00619           int ia, iz, ij;
00620           UtilPDG::getIonAZJ(ipdg,ia,iz,ij);
00621           neukin->A = ia;
00622           neukin->Z = iz;
00623         } else if ( UtilPDG::isProton(ipdg) ) {
00624           neukin->A = 1;
00625           neukin->Z = 1;
00626         } else if ( UtilPDG::isNeutron(ipdg) ) {
00627           neukin->A = 1;
00628           neukin->Z = 0;
00629         }
00630       }
00631     } // initial state
00632 
00633     if ( abs(ipdg) > 0 && abs(ipdg) < 9 ) neukin->IStruckQ = ipdg;
00634 
00635     if ( istatus == 1 ) {
00636       // final state particles
00637       // for now ASSUME no 2nd lepton
00638       if ( isel ) {
00639         neukin->P4El1[0] = apart->Px();
00640         neukin->P4El1[1] = apart->Py();
00641         neukin->P4El1[2] = apart->Pz();
00642         // sign of energy reflects sign of electron
00643         double esign = ( ipdg == 11 ) ? -1 : 1 ;
00644         neukin->P4El1[3] = apart->Energy() * esign;
00645       } else if ( ismu ) {
00646         neukin->P4Mu1[0] = apart->Px();
00647         neukin->P4Mu1[1] = apart->Py();
00648         neukin->P4Mu1[2] = apart->Pz();
00649         // sign of energy reflects sign of muon
00650         double esign = ( ipdg == 13 ) ? -1 : 1 ;
00651         neukin->P4Mu1[3] = apart->Energy() * esign;
00652       } else if ( istau ) {
00653         neukin->P4Tau[0] = apart->Px();
00654         neukin->P4Tau[1] = apart->Py();
00655         neukin->P4Tau[2] = apart->Pz();
00656         // sign of energy reflects sign of tau
00657         double esign = ( ipdg == 15 ) ? -1 : 1 ;
00658         neukin->P4Tau[3] = apart->Energy() * esign;
00659       } else if ( ! isnu ) {
00660         // everything else (that isn't a neutrino) is "shower"
00661         ++tmp_nshw;
00662         tmp_p4shw[0] += apart->Px();
00663         tmp_p4shw[1] += apart->Py();
00664         tmp_p4shw[2] += apart->Pz();
00665         tmp_p4shw[3] += apart->Energy();
00666       }
00667     }
00668 
00669   } // loop over particles
00670 
00671   if ( tmp_nshw > 0 ) {
00672     // saw something "shower-ish"
00673     for (int j=0; j<4; ++j ) neukin->P4Shw[j] = tmp_p4shw[j];
00674   }
00675 
00676 }

SimSnarlRecord * HepevtModule::FindOrCreateSimSnarlRecord ( MomNavigator mom  )  [private]

Find a record we can modify.

Definition at line 332 of file HepevtModule.cxx.

References VldTimeStamp::Add(), RecDataRecord< T >::AdoptComponent(), MomNavigator::AdoptFragment(), RecJobHistory::CreateJobRecord(), fDetector, fDtSpill, RecDataRecord< T >::FindComponent(), MomNavigator::FragmentIter(), fRun, fSnarl, fSubRun, fTimeStampStart, UtilHepevt::getEmptyStdHep(), RecRecordImp< T >::GetJobHistory(), RecRecordImp< T >::GetTempTags(), gSystem(), Msg::kDebug, RecJobHistory::kGMinos, SimFlag::kMC, MSG, and Registry::Set().

Referenced by Get().

00333 {
00334    // Find SimSnarlRecord 
00335    // Ensure that it has a TClonesArray "StdHep" of TParticle objects
00336 
00337    SimSnarlRecord* record = 0;
00338 
00339    // See if a SimSnarlRecord already exists. 
00340    TObject* tobj;
00341    TIter    fragiter = mom->FragmentIter();
00342    while( ( tobj = fragiter.Next() ) ) {
00343      record = dynamic_cast<SimSnarlRecord*>(tobj);
00344      if (record) break;
00345    }
00346 
00347    // If not, make one.
00348    if ( record == 0 ) {
00349      ++fSnarl;
00350 
00351      VldTimeStamp ts(fTimeStampStart);
00352      ts.Add(fDtSpill*fSnarl);
00353      VldContext vldc(fDetector,SimFlag::kMC,ts);
00354 
00355      Short_t runtype = 0;
00356      UInt_t  trigsrc = 0;
00357      UInt_t  errcode = 0;
00358      Int_t   timeframe = fSnarl; // ? what to choose
00359      Int_t   spilltype = -1;
00360 
00361      VldTimeStamp mcGenTime;
00362      std::string  mcCodename("HepevtModule");
00363      std::string  mcHostname(gSystem->HostName());
00364      SimSnarlHeader simheader(vldc,fRun,fSubRun,runtype,errcode,
00365                               fSnarl,trigsrc,timeframe,spilltype,
00366                               mcGenTime,mcCodename,mcHostname);
00367      record = new SimSnarlRecord(simheader);
00368      // Add the history information to the record
00369      RecJobHistory& jobhist 
00370        = const_cast<RecJobHistory&>(record->GetJobHistory());
00371      jobhist.CreateJobRecord(RecJobHistory::kGMinos,mcCodename.c_str(),"",
00372                              mcHostname.c_str(),mcGenTime);
00373      
00374      MSG("Hepevt",Msg::kDebug)
00375        << "New SimSnarlRecord " << simheader << endl;
00376      
00377      // give the RecSimSnarl to MOM to hold as a "fragment"
00378      record->GetTempTags().Set("stream","SimSnarl");  
00379      record->GetTempTags().Set("tree","SimSnarl");  
00380      record->GetTempTags().Set("file","no-input-file");
00381      record->GetTempTags().Set("index",fSnarl);
00382      mom->AdoptFragment(record);
00383    }
00384    
00385    // Even if we didn't create the record make sure it has a StdHep list
00386    const TObject* const_obj = record->FindComponent("TClonesArray","StdHep");
00387    if ( ! const_obj ) {
00388      TClonesArray* stdhep = UtilHepevt::getEmptyStdHep();
00389      record->AdoptComponent(stdhep);
00390    }
00391 
00392    // Create a DigiRerootInfo to hold miscellaneous information about
00393    // the event generation.
00394    //DigiRerootInfo* drInfo = new DigiRerootInfo(fRun,fSnarl,fSnarl,vldc);
00395    //record->AdoptComponent(drInfo);
00396 
00397    return record;
00398 
00399 }

JobCResult HepevtModule::Get ( MomNavigator mom  )  [virtual]

Implement if your module needs to read data from some external source and fill mom

Reimplemented from JobCModule.

Definition at line 202 of file HepevtModule.cxx.

References AddBogusNeuKinEntries(), UtilHepevt::appendStdHep(), UtilHepevt::applyUnitConvert(), VldTimeStamp::AsString(), CountNeededBogusNeuKin(), UtilHepevt::dump(), fAddedEntries, fAddedLists, fEConvert, fForceNevHEPSnarl, fGetApplyRollback, RecDataRecord< T >::FindComponent(), FindOrCreateSimSnarlRecord(), fInputBinaryFD, fIonScheme, fMakeBogusNeuKinEntries, Form(), fRun, fSnarl, fStdHepInputFile, fStdHepInputFileName, fTConvert, fVtxConvert, fVtxOffset, CfgConfigurable::GetConfig(), UtilPDG::getDfltStdIonScheme(), UtilHepevt::getEmptyStdHep(), UtilHepevt::getNevHep(), MINFHeader::GetRun(), SimSnarlRecord::GetSimSnarlHeader(), gSystem(), header, DbiTableProxyRegistry::Instance(), MsgService::Instance(), MsgService::IsActive(), UtilHepevt::k_none, JobCResult::kAOK, Msg::kDebug, Msg::kError, JobCResult::kFailed, Msg::kInfo, Msg::kWarning, ModifyStdHep(), MSG, Registry::Print(), UtilHepevt::readAscii(), UtilHepevt::readBinary(), CfgConfigurable::Set(), MsgService::SetCurrentRunSnarl(), UtilPDG::setDfltStdIonScheme(), UtilHepevt::unpackCommon(), and CfgConfigurable::Update().

00203 {
00204   // Read input file for StdHep
00205   // Create SimSnarlRecord (if necessary)
00206   // Append StdHep
00207 
00208    const int sigEndJob = SIGTERM; // what signal to raise on EOF (or no file)
00209 
00210    TClonesArray* addon = 0;
00211    if ( fStdHepInputFileName != "" ) {
00212      bool isFail = gSystem->AccessPathName(fStdHepInputFileName.c_str());
00213      if ( isFail ) {
00214        MSG("Hepevt",Msg::kError) << "No such StdHep file: "
00215                                  << fStdHepInputFileName << endl;
00216        raise(sigEndJob);
00217        return JobCResult::kFailed; // signal this record is junk as well
00218      }
00219      // reading from some input file ...
00220      if ( fStdHepInputFile.is_open() || fInputBinaryFD != -1 ) {
00221        if ( fInputBinaryFD != -1 ) {
00222          addon = UtilHepevt::getEmptyStdHep();
00223          addon->SetName("StdHep");
00224          UtilHepevt::readBinary(fInputBinaryFD);
00225          // readBinary will set filedescriptor < 0 if EOF and file got closed
00226          if ( fInputBinaryFD != -1 ) {
00227            UtilHepevt::unpackCommon(addon);
00228          } else {
00229            delete addon; addon = 0;  // signal EOF
00230          }
00231        } else {
00232          addon = UtilHepevt::readAscii(fStdHepInputFile);
00233        }
00234        // end-of-file signalled by no TClonesArray
00235        if ( ! addon ) {
00236          MSG("Hepevt",Msg::kWarning)
00237            << "No StdHep list read in from "
00238            << fStdHepInputFileName << " assume EOF {"
00239            << fStdHepInputFile.is_open() << " " << fInputBinaryFD << "}"
00240            << endl;
00241          // signal processing to end ... leaves useless last entry intact
00242          raise(sigEndJob);  // signal no more passes through jobc path
00243          return JobCResult::kFailed; // signal this record is junk as well
00244        }
00245      }
00246    }
00247 
00249    // Find or make the SimSnarl
00250 
00251    if ( fForceNevHEPSnarl ) {
00252      int nevhep = UtilHepevt::getNevHep();
00253      // use only if it looks like it is being set
00254      if ( nevhep > 0 ) fSnarl = nevhep-1; // will pre-increment if record is created
00255    }
00256   
00257    SimSnarlRecord* record = FindOrCreateSimSnarlRecord(mom);
00258    const SimSnarlHeader* header = record->GetSimSnarlHeader();
00259    fRun   = header->GetRun();
00260    fSnarl = header->GetSnarl();
00261    VldContext vldc = header->GetVldContext();
00262 
00263    // if we created this one then we'll be wanting to update this
00264    MsgService::Instance()->SetCurrentRunSnarl(fRun,fSnarl);
00265 
00266    static VldTimeStamp rollbackTS;
00267    VldTimeStamp mcGenTime = header->GetMcGenTime();
00268    if ( fGetApplyRollback && mcGenTime < rollbackTS ) {
00269      rollbackTS = mcGenTime;
00270      // rollback the database for Ugli* and Bfld*
00271      DbiTableProxyRegistry& dbiCfg = DbiTableProxyRegistry::Instance();
00272      // something like: 
00273      //   dbiCfg.Set("Rollback:Ugli*         =  '2002-08-01'");
00274      dbiCfg.Set(Form("Rollback:UGLIDBI* = '%s'",rollbackTS.AsString("sql")));
00275      dbiCfg.Set(Form("Rollback:BFLDDBIPLANEMAP* = '%s'",rollbackTS.AsString("sql")));
00276      dbiCfg.Set("RollbackType:UGLIDBI* = 'CREATIONDATE'");
00277      dbiCfg.Set("RollbackType:BFLDDBIPLANEMAP* = 'CREATIONDATE'");
00278      
00279      MSG("Hepevt",Msg::kInfo)
00280        << "HepevtModule is setting dbiCfg to: " << endl;
00281      MsgService* msgserv = MsgService::Instance();
00282      if (msgserv->IsActive("Hepevt",Msg::kInfo))
00283        dbiCfg.GetConfig().Print();
00284      
00285      dbiCfg.Update();
00286    }
00287 
00288    const TObject* const_obj = record->FindComponent("TClonesArray","StdHep");
00289    // cast away constness!!! so we can modify it ... bad, bad us!
00290    TObject* obj = const_cast<TObject*>(const_obj);
00291    // now to the right type
00292    TClonesArray* stdhep = dynamic_cast<TClonesArray*>(obj);  // this is already owned
00293    
00294    // adjust units for what we read in (if need be)
00295    if ( fVtxConvert != UtilHepevt::k_none ||
00296         fTConvert   != UtilHepevt::k_none ||
00297         fEConvert   != UtilHepevt::k_none    )
00298      UtilHepevt::applyUnitConvert(addon,fVtxConvert,fTConvert,fEConvert);
00299 
00300    if ( fMakeBogusNeuKinEntries != 0 ) {
00301      // [i]=start, [i+1]=end [start,end) for separate events
00302      std::vector<int> splitIndices;  
00303      int nneukin = CountNeededBogusNeuKin(addon,splitIndices);
00304      AddBogusNeuKinEntries(record,nneukin,addon,splitIndices);
00305    }
00306 
00307    fAddedLists++;
00308    fAddedEntries += addon->GetLast()+1;
00309    UtilHepevt::appendStdHep(stdhep,addon,fVtxOffset);
00310    delete addon;  // delete unowned array
00311 
00312    // dump stuff at kDebug level
00313    if ( MsgService::Instance()->IsActive("Hepevt",Msg::kDebug) ) {
00314      MSG("Hepevt",Msg::kInfo)
00315        << " >>>>> Processing StdHep list:" << endl;
00316      UtilHepevt::dump(stdhep,1);
00317    }
00318 
00319    // Set/Reset the PDG scheme used for ions before/after conversion.
00320    UtilPDG::ionscheme_t old_ionscheme = UtilPDG::getDfltStdIonScheme();
00321    UtilPDG::setDfltStdIonScheme((UtilPDG::ionscheme_t)fIonScheme);
00322 
00323    ModifyStdHep(stdhep);
00324 
00325    UtilPDG::setDfltStdIonScheme(old_ionscheme);
00326 
00327    return JobCResult::kAOK; // All Ok
00328 }

Double_t HepevtModule::GetDefaultStartVldTimeInterval (  )  [static]

Definition at line 72 of file HepevtModule.cxx.

References fgDefaultDtSpill.

00073 { return fgDefaultDtSpill; }

VldTimeStamp HepevtModule::GetDefaultStartVldTimeStamp (  )  [static]

Definition at line 70 of file HepevtModule.cxx.

References fgDefaultStartTime.

00071 { return fgDefaultStartTime; }

void HepevtModule::ModifyStdHep ( TClonesArray *  stdhep  )  [private]

adjust status codes, squeeze out unwanted lines

Definition at line 678 of file HepevtModule.cxx.

References fDropCharmDecayProducts, fDropGeantEntries, fDropStatus999, fDropTauDecayProducts, fFixCharmDKStatus, fStdHepEditString, UtilHepevt::modStatusStdHep(), and UtilHepevt::squeezeStdHep().

Referenced by Get().

00679 {
00680   // Fix up decay chain of StdHep list 
00681   // Trim it appropriately
00682 
00683   if (fFixCharmDKStatus) {
00684     // Fix cases where charm hadron generated particles (e.g. delta-rays)
00685     // before it decayed.  In this case the original was tagged ist=2,
00686     // the decay point was ist=1205 but the daughters had ist=205
00687     // rather than 1.  Be a bit careful in case we have charm->charm->stuff
00688     // (perhaps a D* -> D + gamma/pi0, but I haven't seen any of those
00689     // come out of NEUGEN in my study of a few files...)
00690 
00691     // decay products of charm that are ist=205 should be 1
00692     string charmDKDaughters1("fromcharm && ( ! ischarm ) && ist==205 ");
00693     UtilHepevt::modStatusStdHep(stdhep_list,charmDKDaughters1,1);
00694     // in case of charm(2)->charm(1205)->charm(205)->stuff, tag last charm 2
00695     string charmDKDaughters2("fromcharm && ischarm && ist==205 && da0 > -1  ");
00696     UtilHepevt::modStatusStdHep(stdhep_list,charmDKDaughters2,2);
00697   }
00698 
00699   if (fDropGeantEntries) {
00700     // drop entries added in GEANT propagation that aren't charm/tau related
00701     string dropGeant("(  (ist> 200 && ist< 231) || "
00702                      "   (ist> 300 && ist< 310) || "
00703                      "   (ist>1200 && ist<1231) || "
00704                      "   (ist>1300 && ist<1310) )  "
00705                      " && !ischarm && !istau ");
00706     UtilHepevt::modStatusStdHep(stdhep_list,dropGeant);
00707     UtilHepevt::squeezeStdHep(stdhep_list);
00708   }
00709   if (fDropTauDecayProducts) {
00710     // flag and remove tau decay point entry and decay daughters
00711     string dropTauDK("(istau && ist==1205) || (fromtau && ist==1)");
00712     UtilHepevt::modStatusStdHep(stdhep_list,dropTauDK);
00713     UtilHepevt::squeezeStdHep(stdhep_list);
00714     // reactivate tau as an active particle subject to decay IST=1
00715     UtilHepevt::modStatusStdHep(stdhep_list,"istau && ist==2 && da0==-1",1);
00716   }
00717   if (fDropCharmDecayProducts) {
00718      // flag and remove charm decay point entry and decay daughters
00719     string dropCharmDK("(ischarm && ist==1205) || (fromcharm && ist==1)");
00720     UtilHepevt::modStatusStdHep(stdhep_list,dropCharmDK);
00721     UtilHepevt::squeezeStdHep(stdhep_list);
00722     // reactivate tau as an active particle subject to decay IST=1
00723     UtilHepevt::modStatusStdHep(stdhep_list,"ischarm && ist==2 && da0==-1",1);
00724   }
00725   if (fDropStatus999) {
00726     UtilHepevt::modStatusStdHep(stdhep_list,"ist==999");
00727     UtilHepevt::squeezeStdHep(stdhep_list);
00728   }
00729   if (fStdHepEditString != "") {
00730     UtilHepevt::modStatusStdHep(stdhep_list,fStdHepEditString);
00731     UtilHepevt::squeezeStdHep(stdhep_list);
00732   }
00733 
00734 }

void HepevtModule::SetDefaultDetector ( Detector::Detector_t  det  )  [static]

Definition at line 63 of file HepevtModule.cxx.

00064 { fgDefaultDetector = det; }

void HepevtModule::SetDefaultSpillTimeInterval ( Double_t  dt  )  [static]

Definition at line 67 of file HepevtModule.cxx.

References fgDefaultDtSpill.

00068 { fgDefaultDtSpill = dt; }

void HepevtModule::SetDefaultStartVldTimeStamp ( const VldTimeStamp vts  )  [static]

Definition at line 65 of file HepevtModule.cxx.

References fgDefaultStartTime.

00066 { fgDefaultStartTime = vts; }


Member Data Documentation

Int_t HepevtModule::fAddedEntries [private]

Definition at line 114 of file HepevtModule.h.

Referenced by EndJob(), and Get().

Int_t HepevtModule::fAddedLists [private]

Definition at line 113 of file HepevtModule.h.

Referenced by EndJob(), and Get().

Bool_t HepevtModule::fAnaPrintStdHep [private]

Definition at line 100 of file HepevtModule.h.

Referenced by Ana(), and Config().

Detector::Detector_t HepevtModule::fDetector [private]

Definition at line 87 of file HepevtModule.h.

Referenced by Config(), and FindOrCreateSimSnarlRecord().

Bool_t HepevtModule::fDropCharmDecayProducts [private]

Definition at line 106 of file HepevtModule.h.

Referenced by Config(), and ModifyStdHep().

Bool_t HepevtModule::fDropGeantEntries [private]

Definition at line 104 of file HepevtModule.h.

Referenced by Config(), and ModifyStdHep().

Bool_t HepevtModule::fDropStatus999 [private]

Definition at line 107 of file HepevtModule.h.

Referenced by Config(), and ModifyStdHep().

Bool_t HepevtModule::fDropTauDecayProducts [private]

Definition at line 105 of file HepevtModule.h.

Referenced by Config(), and ModifyStdHep().

Double_t HepevtModule::fDtSpill [private]

Definition at line 89 of file HepevtModule.h.

Referenced by Config(), and FindOrCreateSimSnarlRecord().

UtilHepevt::cunits_t HepevtModule::fEConvert [private]

Definition at line 118 of file HepevtModule.h.

Referenced by Config(), and Get().

Bool_t HepevtModule::fFixCharmDKStatus [private]

Definition at line 103 of file HepevtModule.h.

Referenced by Config(), and ModifyStdHep().

Bool_t HepevtModule::fForceNevHEPSnarl [private]

Definition at line 110 of file HepevtModule.h.

Referenced by Config(), and Get().

Detector::Detector_t HepevtModule::fgDefaultDetector = Detector::kUnknown [static, private]

Definition at line 122 of file HepevtModule.h.

Double_t HepevtModule::fgDefaultDtSpill = 1.9 [static, private]

Definition at line 124 of file HepevtModule.h.

Referenced by GetDefaultStartVldTimeInterval(), and SetDefaultSpillTimeInterval().

VldTimeStamp HepevtModule::fgDefaultStartTime = VldTimeStamp() [static, private]

Definition at line 123 of file HepevtModule.h.

Referenced by GetDefaultStartVldTimeStamp(), and SetDefaultStartVldTimeStamp().

Bool_t HepevtModule::fGetApplyRollback [private]

Definition at line 99 of file HepevtModule.h.

Referenced by Config(), and Get().

Int_t HepevtModule::fInputBinaryFD [private]

Definition at line 97 of file HepevtModule.h.

Referenced by Config(), and Get().

Int_t HepevtModule::fIonScheme [private]

Definition at line 102 of file HepevtModule.h.

Referenced by Config(), and Get().

Int_t HepevtModule::fMakeBogusNeuKinEntries [private]

Definition at line 111 of file HepevtModule.h.

Referenced by AddBogusNeuKinEntries(), Config(), CountNeededBogusNeuKin(), and Get().

Int_t HepevtModule::fRun [private]

Definition at line 90 of file HepevtModule.h.

Referenced by Config(), FindOrCreateSimSnarlRecord(), and Get().

Int_t HepevtModule::fSnarl [private]

Definition at line 92 of file HepevtModule.h.

Referenced by Config(), FindOrCreateSimSnarlRecord(), and Get().

std::string HepevtModule::fStdHepEditString [private]

Definition at line 108 of file HepevtModule.h.

Referenced by Config(), and ModifyStdHep().

std::ifstream HepevtModule::fStdHepInputFile [private]

Definition at line 96 of file HepevtModule.h.

Referenced by Config(), and Get().

std::string HepevtModule::fStdHepInputFileName [private]

Definition at line 95 of file HepevtModule.h.

Referenced by Config(), and Get().

Int_t HepevtModule::fSubRun [private]

Definition at line 91 of file HepevtModule.h.

Referenced by Config(), and FindOrCreateSimSnarlRecord().

UtilHepevt::cunits_t HepevtModule::fTConvert [private]

Definition at line 117 of file HepevtModule.h.

Referenced by Config(), and Get().

VldTimeStamp HepevtModule::fTimeStampStart [private]

Definition at line 88 of file HepevtModule.h.

Referenced by FindOrCreateSimSnarlRecord().

UtilHepevt::cunits_t HepevtModule::fVtxConvert [private]

Definition at line 116 of file HepevtModule.h.

Referenced by Config(), and Get().

TLorentzVector HepevtModule::fVtxOffset [private]

Definition at line 94 of file HepevtModule.h.

Referenced by Config(), and Get().


The documentation for this class was generated from the following files:
Generated on Thu Apr 10 23:02:45 2014 for loon by  doxygen 1.4.7