#include <HepevtModule.h>
Inheritance diagram for HepevtModule:
Definition at line 33 of file HepevtModule.h.
| 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 }
| 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] |
| 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; }
Int_t HepevtModule::fAddedEntries [private] |
Int_t HepevtModule::fAddedLists [private] |
Bool_t HepevtModule::fAnaPrintStdHep [private] |
Detector::Detector_t HepevtModule::fDetector [private] |
Definition at line 87 of file HepevtModule.h.
Referenced by Config(), and FindOrCreateSimSnarlRecord().
Bool_t HepevtModule::fDropCharmDecayProducts [private] |
Bool_t HepevtModule::fDropGeantEntries [private] |
Bool_t HepevtModule::fDropStatus999 [private] |
Bool_t HepevtModule::fDropTauDecayProducts [private] |
Double_t HepevtModule::fDtSpill [private] |
Definition at line 89 of file HepevtModule.h.
Referenced by Config(), and FindOrCreateSimSnarlRecord().
UtilHepevt::cunits_t HepevtModule::fEConvert [private] |
Bool_t HepevtModule::fFixCharmDKStatus [private] |
Bool_t HepevtModule::fForceNevHEPSnarl [private] |
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] |
Int_t HepevtModule::fInputBinaryFD [private] |
Int_t HepevtModule::fIonScheme [private] |
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] |
std::ifstream HepevtModule::fStdHepInputFile [private] |
std::string HepevtModule::fStdHepInputFileName [private] |
Int_t HepevtModule::fSubRun [private] |
Definition at line 91 of file HepevtModule.h.
Referenced by Config(), and FindOrCreateSimSnarlRecord().
UtilHepevt::cunits_t HepevtModule::fTConvert [private] |
VldTimeStamp HepevtModule::fTimeStampStart [private] |
TLorentzVector HepevtModule::fVtxOffset [private] |
1.4.7