lcsim/src/org/lcsim/mc/fast/frontend
diff -N Main.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ Main.java 5 Feb 2013 23:15:09 -0000 1.1
@@ -0,0 +1,198 @@
+package org.lcsim.mc.fast.frontend;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Random;
+
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.HelpFormatter;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.ParseException;
+import org.apache.commons.cli.PosixParser;
+import org.freehep.record.source.NoSuchRecordException;
+import org.lcsim.geometry.compact.Detector;
+import org.lcsim.geometry.util.DetectorLocator;
+import org.lcsim.mc.fast.MCFast;
+import org.lcsim.util.Driver;
+import org.lcsim.util.loop.LCIODriver;
+import org.lcsim.util.loop.LCSimLoop;
+
+/**
+ * This is a reworked class from an old main program provided by Tim and Norman.
+ * The jet and vertex reconstruction was removed, so this now only runs the Fast MC
+ * and writes the output LCIO file. Analysis and reconstruction would be performed
+ * in a subsequent lcsim XML job.
+ *
+ * @author Norman A. Graf
+ * @author Jeremy McCormick
+ */
+public class Main
+{
+ private static final String defaultDetector = "sidloi3";
+ private static final int defaultNumProcess = -1;
+ private static final int defaultNumSkip = -1;
+ private static final boolean defaultRefPoint000 = true;
+ private static final String defaultOutputFileName = "fastmc.slcio";
+ private static final boolean defaultBeamSpotConstraint = true;
+ private static final boolean defaultSimple = true;
+ private static final int defaultSeed = (new Random()).nextInt();
+ private static final boolean defaultDebug = false;
+
+ String inputFileName;
+ String outputFileName;
+ String detector;
+ int numToProcess;
+ int numToSkip;
+ int seed;
+ boolean refPoint000;
+ boolean beamSpotConstraint;
+ boolean simple;
+ boolean debug;
+
+ private static Options options = null;
+
+ private Main() {
+ createOptions();
+ }
+
+ Options getOptions() {
+ return options;
+ }
+
+ void parse(String[] args) throws ParseException {
+
+ // Create the parser and parse command line options.
+ PosixParser parser = new PosixParser();
+
+ CommandLine cmd = null;
+ try {
+ cmd = parser.parse(options, args);
+ } catch (ParseException x) {
+ System.out.println("Parsing failed: " + x.getMessage());
+ usage();
+ }
+
+ // Set the parameters from the parsed command line.
+ setParameters(cmd);
+
+ // Print out the parameters to System.out.
+ printParameters();
+ }
+
+ private void setParameters(CommandLine cmd) {
+ inputFileName = cmd.getOptionValue("i");
+ if (inputFileName == null)
+ usage();
+ outputFileName = cmd.getOptionValue("o", defaultOutputFileName);
+ detector = cmd.getOptionValue("d", defaultDetector);
+ numToProcess = Integer.valueOf(cmd.getOptionValue("r", String.valueOf(defaultNumProcess)));
+ numToSkip = Integer.valueOf(cmd.getOptionValue("s", String.valueOf(defaultNumSkip)));
+ seed = Integer.valueOf(cmd.getOptionValue("m", String.valueOf(defaultSeed)));
+ refPoint000 = Boolean.valueOf(cmd.getOptionValue("p", String.valueOf(defaultRefPoint000)));
+ beamSpotConstraint = Boolean.valueOf(cmd.getOptionValue("b", String.valueOf(defaultBeamSpotConstraint)));
+ simple = Boolean.valueOf(cmd.getOptionValue("S", String.valueOf(defaultSimple)));
+ debug = Boolean.valueOf(cmd.getOptionValue("d", String.valueOf(defaultDebug)));
+ }
+
+ private void printParameters() {
+ System.out.println("Received the following command line parameters:");
+ System.out.println('\t' + "inputFileName = " + inputFileName);
+ System.out.println('\t' + "outputFileName = " + outputFileName);
+ System.out.println('\t' + "detector = " + detector);
+ System.out.println('\t' + "events to process = " + numToProcess);
+ System.out.println('\t' + "events to skip = " + numToSkip);
+ System.out.println('\t' + "seed = " + seed);
+ System.out.println('\t' + "refPoint000 = " + refPoint000);
+ System.out.println('\t' + "beamSpotConstraint = " + beamSpotConstraint);
+ System.out.println('\t' + "simple mode = " + simple);
+ System.out.println('\t' + "debug mode = " + debug);
+ }
+
+ private void createOptions() {
+ options = new Options();
+ options.addOption("h", false, "print usage information");
+ options.addOption("i", true, "input file");
+ options.addOption("o", true, "output file name");
+ options.addOption("d", true, "detector name");
+ options.addOption("r", true, "number of events to process");
+ options.addOption("s", true, "number of events to skip");
+ options.addOption("m", true, "random seed");
+ options.addOption("p", false, "use default ref point");
+ options.addOption("b", false, "use beam spot constraint");
+ options.addOption("S", false, "use simple");
+ options.addOption("d", false, "print debug info");
+ }
+
+ private void usage()
+ {
+ HelpFormatter formatter = new HelpFormatter();
+ formatter.printHelp(getClass().getCanonicalName(), options);
+ System.exit(1);
+ }
+
+ private void error(String message)
+ {
+ System.out.println(message);
+ System.exit(1);
+ }
+
+ private void run() throws IOException, NoSuchRecordException {
+
+ // Check existence of detector.
+ Detector det = DetectorLocator.findDetector(detector);
+ if (det == null) {
+ error("Unknown detector: " + detector);
+ }
+
+ // Check existence of input file.
+ File input = new File(inputFileName);
+ if (!input.exists()) {
+ error("The input file " + input + " does not exist!");
+ }
+
+ // Setup the LCIO output driver.
+ LCIODriver writer = null;
+ File output = new File(outputFileName);
+ if(output.exists())
+ {
+ throw new RuntimeException("Output file already exists!");
+ }
+ writer = new LCIODriver(output);
+
+ // Initialize Fast MC driver.
+ Driver fast = new MCFast(beamSpotConstraint, simple, seed, debug, refPoint000);
+
+ // create the event loop
+ LCSimLoop loop = new LCSimLoop();
+ if (input.getName().contains(".stdhep")) {
+ loop.setStdhepRecordSource(input, detector);
+ } else {
+ loop.setLCIORecordSource(input);
+ }
+
+ // Add drivers.
+ if (debug) {
+ MonitorStdhep analysis = new MonitorStdhep();
+ loop.add(analysis);
+ }
+ loop.add(fast);
+ loop.add(writer);
+
+ // Run the job.
+ if (numToSkip > 0) {
+ System.out.println("skipping " + numToSkip + " events");
+ loop.skip(numToSkip);
+ }
+ loop.loop(numToProcess);
+ loop.dispose();
+ System.out.println(getClass().getSimpleName() + ": processed " + loop.getTotalSupplied() + " events");
+ }
+
+
+ public static void main(String[] args) throws Exception
+ {
+ Main main = new Main();
+ main.parse(args);
+ main.run();
+ }
+}
lcsim/src/org/lcsim/mc/fast/frontend
diff -N MonitorStdhep.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ MonitorStdhep.java 5 Feb 2013 23:15:09 -0000 1.1
@@ -0,0 +1,84 @@
+package org.lcsim.mc.fast.frontend;
+
+import static java.lang.Math.abs;
+
+import hep.physics.particle.properties.ParticlePropertyManager;
+import hep.physics.particle.properties.ParticlePropertyProvider;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.MCParticle;
+import org.lcsim.event.ReconstructedParticle;
+import org.lcsim.util.Driver;
+
+public class MonitorStdhep extends Driver
+{
+
+ final int nEventSkip = 0;
+ // final int nEventSkip=95;
+ // final int nEventSkip=233;
+ // final int nEventSkip=684;
+ final int nprintMax = 20;
+ // final int nprintMax=Integer.MAX_VALUE;
+ final int nCloudMax = Integer.MAX_VALUE;
+ int ncnt = 0;
+ int ncnt_in = 0;
+ int ncnt_out = 0;
+ int eventNumber;
+ float eventWeight;
+ final ParticlePropertyProvider dPPP;
+ List<ReconstructedParticle> recoParticles;
+ int idrup;
+
+ int m_eventCount;
+
+ int ievt;
+ int nmax = 1000000;
+
+ public MonitorStdhep() throws IOException
+ {
+
+ m_eventCount = 0;
+ dPPP = ParticlePropertyManager.getParticlePropertyProvider();
+ System.out.println(" MonitorStdhep constructor ");
+ }
+
+ protected void process(EventHeader event)
+ {
+ // super.process(event);
+ ncnt_in++;
+ if (ncnt_in <= nEventSkip) {
+ // System.out.println(" event.getEventNumber= "+event.getEventNumber());
+ throw new Driver.NextEventException();
+ } else {
+ eventNumber = event.getEventNumber();
+ ncnt++;
+ if (ncnt <= nprintMax || ncnt % 100 == 0)
+ System.out.println(" ncnt_in= " + ncnt_in + " ncnt= " + ncnt + " eventNumber= " + eventNumber);
+ // super.process(event);
+ // idrup=event.getIntegerParameters().get("idrup")[0];
+
+ eventWeight = event.getWeight();
+ if (ncnt <= nprintMax) {
+ Map<String, float[]> headerFloatMap = event.getFloatParameters();
+ Map<String, int[]> headerIntMap = event.getIntegerParameters();
+ for (String headerFloatName : headerFloatMap.keySet())
+ System.out.println(" headerFloatName= " + headerFloatName + " value= " + headerFloatMap.get(headerFloatName)[0]);
+ for (String headerIntName : headerIntMap.keySet())
+ System.out.println(" headerIntName= " + headerIntName + " value= " + headerIntMap.get(headerIntName)[0]);
+ System.out.println(" idrup= " + idrup);
+ long eventTimeStamp = event.getTimeStamp();
+ System.out.println(" eventWeight= " + eventWeight);
+ }
+ List<MCParticle> particles = event.get(MCParticle.class, event.MC_PARTICLES);
+ for (MCParticle particle : particles) {
+ int iPdgId = abs(particle.getPDGID());
+ if (ncnt <= nprintMax)
+ System.out.println(" iPdgId= " + iPdgId);
+ }
+ }
+ }
+}